Merge branch '4.4'

* 4.4:
  Re-allow to use "tagged" in service definitions
  [HttpFoundation] Allow to not pass a parameter to Request::isMethodSafe()
  Add missing lock connection string in FrameworkExtension
  [DomCrawler] normalizeWhitespace should be true by default
  [DoctrineBridge] Auto-validation must work if no regex are passed
  Allows URL DSN in Lock and Cache

Author: nicolas-grekas

CHANGELOG.md

@@ -14,7 +14,10 @@ CHANGELOG
  * added InvalidTtlException  
  * deprecated `StoreInterface` in favor of `BlockingStoreInterface` and `PersistingStoreInterface`
  * `Factory` is deprecated, use `LockFactory` instead
-
+ * `StoreFactory::createStore` allows PDO and Zookeeper DSN. 
+ * deprecated services `lock.store.flock`, `lock.store.semaphore`, `lock.store.memcached.abstract` and `lock.store.redis.abstract`, 
+   use `StoreFactory::createStore` instead.
+    
 4.2.0
 -----
 

Store/PdoStore.php

@@ -13,6 +13,7 @@
 
 use Doctrine\DBAL\Connection;
 use Doctrine\DBAL\DBALException;
+use Doctrine\DBAL\DriverManager;
 use Doctrine\DBAL\Schema\Schema;
 use Symfony\Component\Lock\Exception\InvalidArgumentException;
 use Symfony\Component\Lock\Exception\InvalidTtlException;
@@ -219,8 +220,15 @@ private function getUniqueToken(Key $key): string
     private function getConnection(): object
     {
         if (null === $this->conn) {
-            $this->conn = new \PDO($this->dsn, $this->username, $this->password, $this->connectionOptions);
-            $this->conn->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
+            if (strpos($this->dsn, '://')) {
+                if (!class_exists(DriverManager::class)) {
+                    throw new InvalidArgumentException(sprintf('Failed to parse the DSN "%s". Try running "composer require doctrine/dbal".', $this->dsn));
+                }
+                $this->conn = DriverManager::getConnection(['url' => $this->dsn]);
+            } else {
+                $this->conn = new \PDO($this->dsn, $this->username, $this->password, $this->connectionOptions);
+                $this->conn->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
+            }
         }
 
         return $this->conn;

Store/StoreFactory.php

@@ -58,8 +58,24 @@ public static function createStore($connection)
                 return new FlockStore(substr($connection, 8));
             case 'semaphore' === $connection:
                 return new SemaphoreStore();
-            case class_exists(AbstractAdapter::class) && preg_match('#^[a-z]++://#', $connection):
-                return static::createStore(AbstractAdapter::createConnection($connection));
+            case 0 === strpos($connection, 'redis://') && class_exists(AbstractAdapter::class):
+            case 0 === strpos($connection, 'rediss://') && class_exists(AbstractAdapter::class):
+                return new RedisStore(AbstractAdapter::createConnection($connection, ['lazy' => true]));
+            case 0 === strpos($connection, 'memcached://') && class_exists(AbstractAdapter::class):
+                return new MemcachedStore(AbstractAdapter::createConnection($connection, ['lazy' => true]));
+            case 0 === strpos($connection, 'sqlite:'):
+            case 0 === strpos($connection, 'mysql:'):
+            case 0 === strpos($connection, 'pgsql:'):
+            case 0 === strpos($connection, 'oci:'):
+            case 0 === strpos($connection, 'sqlsrv:'):
+            case 0 === strpos($connection, 'sqlite3://'):
+            case 0 === strpos($connection, 'mysql2://'):
+            case 0 === strpos($connection, 'postgres://'):
+            case 0 === strpos($connection, 'postgresql://'):
+            case 0 === strpos($connection, 'mssql://'):
+                return new PdoStore($connection);
+            case 0 === strpos($connection, 'zookeeper://'):
+                return new ZookeeperStore(ZookeeperStore::createConnection($connection));
             default:
                 throw new InvalidArgumentException(sprintf('Unsupported Connection: %s.', $connection));
         }

Store/ZookeeperStore.php

@@ -11,6 +11,7 @@
 
 namespace Symfony\Component\Lock\Store;
 
+use Symfony\Component\Lock\Exception\InvalidArgumentException;
 use Symfony\Component\Lock\Exception\LockAcquiringException;
 use Symfony\Component\Lock\Exception\LockConflictedException;
 use Symfony\Component\Lock\Exception\LockReleasingException;
@@ -33,6 +34,24 @@ public function __construct(\Zookeeper $zookeeper)
         $this->zookeeper = $zookeeper;
     }
 
+    public static function createConnection(string $dsn): \Zookeeper
+    {
+        if (0 !== strpos($dsn, 'zookeeper:')) {
+            throw new InvalidArgumentException(sprintf('Unsupported DSN: %s.', $dsn));
+        }
+
+        if (false === $params = parse_url($dsn)) {
+            throw new InvalidArgumentException(sprintf('Invalid Zookeeper DSN: %s.', $dsn));
+        }
+
+        $host = $params['host'] ?? '';
+        if (isset($params['port'])) {
+            $host .= ':'.$params['port'];
+        }
+
+        return new \Zookeeper($host);
+    }
+
     /**
      * {@inheritdoc}
      */

Tests/Store/PdoStoreTest.php

@@ -73,4 +73,34 @@ public function testInvalidTtlConstruct()
 
         return new PdoStore('sqlite:'.self::$dbFile, [], 0.1, 0.1);
     }
+
+    /**
+     * @dataProvider provideDsn
+     */
+    public function testDsn(string $dsn, string $file = null)
+    {
+        $key = new Key(uniqid(__METHOD__, true));
+
+        try {
+            $store = new PdoStore($dsn);
+            $store->createTable();
+
+            $store->save($key);
+            $this->assertTrue($store->exists($key));
+        } finally {
+            if (null !== $file) {
+                @unlink($file);
+            }
+        }
+    }
+
+    public function provideDsn()
+    {
+        $dbFile = tempnam(sys_get_temp_dir(), 'sf_sqlite_cache');
+        yield ['sqlite://localhost/'.$dbFile, ''.$dbFile];
+        yield ['sqlite:'.$dbFile, ''.$dbFile];
+        yield ['sqlite3:///'.$dbFile, ''.$dbFile];
+        yield ['sqlite://localhost/:memory:'];
+        yield ['sqlite::memory:'];
+    }
 }

Tests/Store/StoreFactoryTest.php

@@ -16,6 +16,7 @@
 use Symfony\Component\Cache\Traits\RedisProxy;
 use Symfony\Component\Lock\Store\FlockStore;
 use Symfony\Component\Lock\Store\MemcachedStore;
+use Symfony\Component\Lock\Store\PdoStore;
 use Symfony\Component\Lock\Store\RedisStore;
 use Symfony\Component\Lock\Store\SemaphoreStore;
 use Symfony\Component\Lock\Store\StoreFactory;
@@ -50,13 +51,34 @@ public function validConnections()
         }
         if (class_exists(\Zookeeper::class)) {
             yield [$this->createMock(\Zookeeper::class), ZookeeperStore::class];
+            yield ['zookeeper://localhost:2181', ZookeeperStore::class];
         }
         if (\extension_loaded('sysvsem')) {
             yield ['semaphore', SemaphoreStore::class];
         }
         if (class_exists(\Memcached::class) && class_exists(AbstractAdapter::class)) {
             yield ['memcached://server.com', MemcachedStore::class];
         }
+        if (class_exists(\Redis::class) && class_exists(AbstractAdapter::class)) {
+            yield ['redis://localhost', RedisStore::class];
+        }
+        if (class_exists(\PDO::class)) {
+            yield ['sqlite:/tmp/sqlite.db', PdoStore::class];
+            yield ['sqlite::memory:', PdoStore::class];
+            yield ['mysql:host=localhost;dbname=test;', PdoStore::class];
+            yield ['pgsql:host=localhost;dbname=test;', PdoStore::class];
+            yield ['oci:host=localhost;dbname=test;', PdoStore::class];
+            yield ['sqlsrv:server=localhost;Database=test', PdoStore::class];
+            yield ['mysql://server.com/test', PdoStore::class];
+            yield ['mysql2://server.com/test', PdoStore::class];
+            yield ['pgsql://server.com/test', PdoStore::class];
+            yield ['postgres://server.com/test', PdoStore::class];
+            yield ['postgresql://server.com/test', PdoStore::class];
+            yield ['sqlite:///tmp/test', PdoStore::class];
+            yield ['sqlite3:///tmp/test', PdoStore::class];
+            yield ['oci:///server.com/test', PdoStore::class];
+            yield ['mssql:///server.com/test', PdoStore::class];
+        }
 
         yield ['flock', FlockStore::class];
         yield ['flock://'.sys_get_temp_dir(), FlockStore::class];

Tests/Store/ZookeeperStoreTest.php

@@ -30,11 +30,26 @@ public function getStore(): PersistingStoreInterface
     {
         $zookeeper_server = getenv('ZOOKEEPER_HOST').':2181';
 
-        $zookeeper = new \Zookeeper(implode(',', [$zookeeper_server]));
+        $zookeeper = new \Zookeeper($zookeeper_server);
 
         return StoreFactory::createStore($zookeeper);
     }
 
+    /**
+     * @dataProvider provideValidConnectionString
+     */
+    public function testCreateConnection(string $connectionString)
+    {
+        $this->assertInstanceOf(\Zookeeper::class, ZookeeperStore::createConnection($connectionString));
+    }
+
+    public function provideValidConnectionString(): iterable
+    {
+        yield 'single host' => ['zookeeper://localhost:2181'];
+        yield 'single multiple host' => ['zookeeper://localhost:2181,localhost:2181'];
+        yield 'with extra attributes' => ['zookeeper://localhost:2181/path?option=value'];
+    }
+
     public function testSaveSucceedsWhenPathContainsMoreThanOneNode()
     {
         $store = $this->getStore();

composer.json

@@ -20,10 +20,13 @@
         "psr/log": "~1.0"
     },
     "require-dev": {
-        "doctrine/dbal": "~2.4",
+        "doctrine/dbal": "~2.5",
         "mongodb/mongodb": "~1.1",
         "predis/predis": "~1.0"
     },
+    "conflict": {
+        "doctrine/dbal": "<2.5"
+    },
     "autoload": {
         "psr-4": { "Symfony\\Component\\Lock\\": "" },
         "exclude-from-classmap": [