decouple driver config from connection factory

Author: transistive

src/Bolt/SingleBoltConnectionPool.php

@@ -101,8 +101,8 @@ private function returnAnyAvailableConnection(string $encryptionLevel): ?BoltCon
         foreach ($this->activeConnections as $activeConnection) {
             // We prefer a connection that is just ready
             if ($activeConnection->getServerState() === 'READY') {
-                if (!$this->requiresReconnect($activeConnection, $encryptionLevel)) {
-                    return $activeConnection;
+                if ($this->factory->canReuseConnection($activeConnection)) {
+                    return $this->factory->reuseConnection($activeConnection);
                 } else {
                     $requiresReconnectConnection = $activeConnection;
                 }
@@ -116,7 +116,7 @@ private function returnAnyAvailableConnection(string $encryptionLevel): ?BoltCon
             // https://github.com/neo4j-php/neo4j-php-client/issues/146
             // NOTE: we cannot work with TX_STREAMING as we cannot force the transaction to implicitly close.
             if ($streamingConnection === null && $activeConnection->getServerState() === 'STREAMING') {
-                if (!$this->requiresReconnect($activeConnection, $encryptionLevel)) {
+                if ($this->factory->canReuseConnection($activeConnection)) {
                     $streamingConnection = $activeConnection;
                     $streamingConnection->consumeResults(); // State should now be ready
                 } else {
@@ -126,20 +126,15 @@ private function returnAnyAvailableConnection(string $encryptionLevel): ?BoltCon
         }
 
         if ($streamingConnection) {
-            return $streamingConnection;
+            return $this->factory->reuseConnection($streamingConnection);
         }
 
         if ($requiresReconnectConnection) {
             $this->release($requiresReconnectConnection);
 
-            return $this->createNewConnection();
+            return $this->factory->createConnection($this->auth);
         }
 
         return null;
     }
-
-    private function requiresReconnect(BoltConnection $activeConnection, string $requiredEncryptionLevel): bool
-    {
-        return
-    }
 }

src/Bolt/SslConfigurator.php

@@ -14,29 +14,26 @@
 use function explode;
 use const FILTER_VALIDATE_IP;
 use function filter_var;
-use Laudis\Neo4j\Databags\DriverConfiguration;
+use Laudis\Neo4j\Databags\SslConfiguration;
 use Laudis\Neo4j\Enum\SslMode;
 use Psr\Http\Message\UriInterface;
 
 final class SslConfigurator
 {
     /**
-     * @param UriInterface $uri
-     * @param DriverConfiguration $config
-     *
      * @return array{0: ''|'s'|'ssc', 1: array|null}
      */
-    public function configure(UriInterface $uri, DriverConfiguration $config): array
+    public function configure(UriInterface $uri, SslConfiguration $config): array
     {
-        $sslMode = $config->getSslConfiguration()->getMode();
+        $mode = $config->getMode();
         $sslConfig = '';
-        if ($sslMode === SslMode::FROM_URL()) {
+        if ($mode === SslMode::FROM_URL()) {
             $scheme = $uri->getScheme();
             $explosion = explode('+', $scheme, 2);
             $sslConfig = $explosion[1] ?? '';
-        } elseif ($sslMode === SslMode::ENABLE()) {
+        } elseif ($mode === SslMode::ENABLE()) {
             $sslConfig = 's';
-        } elseif ($sslMode === SslMode::ENABLE_WITH_SELF_SIGNED()) {
+        } elseif ($mode === SslMode::ENABLE_WITH_SELF_SIGNED()) {
             $sslConfig = 'ssc';
         }
 
@@ -47,10 +44,10 @@ public function configure(UriInterface $uri, DriverConfiguration $config): array
         return [$sslConfig, null];
     }
 
-    private function enableSsl(string $host, string $sslConfig, DriverConfiguration $config): ?array
+    private function enableSsl(string $host, string $sslConfig, SslConfiguration $config): ?array
     {
         $options = [
-            'verify_peer' => $config->getSslConfiguration()->isVerifyPeer(),
+            'verify_peer' => $config->isVerifyPeer(),
             'peer_name' => $host,
         ];
         if (!filter_var($host, FILTER_VALIDATE_IP)) {

src/BoltFactory.php

@@ -29,8 +29,8 @@
 use Laudis\Neo4j\Contracts\ConnectionFactoryInterface;
 use Laudis\Neo4j\Contracts\ConnectionInterface;
 use Laudis\Neo4j\Databags\DatabaseInfo;
-use Laudis\Neo4j\Databags\DriverConfiguration;
 use Laudis\Neo4j\Databags\SessionConfiguration;
+use Laudis\Neo4j\Databags\SslConfiguration;
 use Laudis\Neo4j\Databags\TransactionConfiguration;
 use Laudis\Neo4j\Enum\ConnectionProtocol;
 use Laudis\Neo4j\Exception\Neo4jException;
@@ -45,28 +45,22 @@
 final class BoltFactory implements ConnectionFactoryInterface
 {
     private UriInterface $uri;
-    private AuthenticateInterface $auth;
-    private DriverConfiguration $config;
     private SslConfigurator $sslConfigurator;
 
     /**
      * @psalm-external-mutation-free
      */
     public function __construct(
         UriInterface $uri,
-        AuthenticateInterface $authenticate,
-        DriverConfiguration $config,
         SslConfigurator $sslConfigurator
     ) {
         $this->uri = $uri;
-        $this->auth = $authenticate;
-        $this->config = $config;
         $this->sslConfigurator = $sslConfigurator;
     }
 
-    public function createConnection(AuthenticateInterface $auth, SessionConfiguration $config): ConnectionInterface
+    public function createConnection(string $userAgent, SslConfiguration $sslConfig, SessionConfiguration $sessionConfig, AuthenticateInterface $auth): ConnectionInterface
     {
-        [$encryptionLevel, $sslConfig] = $this->sslConfigurator->configure($this->uri, $this->config);
+        [$encryptionLevel, $sslConfig] = $this->sslConfigurator->configure($this->uri, $sslConfig);
         $port = $this->uri->getPort() ?? 7687;
         if (extension_loaded('sockets') && $sslConfig === null) {
             $connection = new Socket($this->uri->getHost(), $port, TransactionConfiguration::DEFAULT_TIMEOUT);
@@ -92,28 +86,30 @@ public function createConnection(AuthenticateInterface $auth, SessionConfigurati
                 throw new RuntimeException('Client only supports bolt version 3 and up.');
             }
 
-            $response = $auth->authenticateBolt($protocol, $this->config->getUserAgent());
+            $response = $auth->authenticateBolt($protocol, $userAgent);
         } catch (MessageException $e) {
             throw Neo4jException::fromMessageException($e);
         }
 
-        $config = new ConnectionConfiguration(
+        $sessionConfig = new ConnectionConfiguration(
             $response['server'],
             $this->uri,
             explode('/', $response['server'])[1] ?? '',
             ConnectionProtocol::determineBoltVersion($protocol),
-            $config->getAccessMode(),
-            $this->config,
-            $config->getDatabase() === null ? null : new DatabaseInfo($config->getDatabase())
+            $sessionConfig->getAccessMode(),
+            $sessionConfig->getDatabase() === null ? null : new DatabaseInfo($sessionConfig->getDatabase())
         );
 
-        return new BoltConnection($protocol, $connection, $config, $this->auth, $encryptionLevel);
+        return new BoltConnection($protocol, $connection, $sessionConfig, $auth, $encryptionLevel);
     }
 
-    public function canReuseConnection(ConnectionInterface $connection): bool
+    public function canReuseConnection(ConnectionInterface $connection, string $userAgent, SslConfiguration $sslConfig, AuthenticateInterface $auth): bool
     {
-        return $connection->getAuthentication()->toString($this->uri) == $this->auth->toString($this->uri) ||
-               $connection->getEncryptionLevel() === $this->sslConfigurator->configure($this->uri, $this->config)[0];
+        return $connection->getAuthentication()->toString($this->uri) === $auth->toString($this->uri) &&
+                $connection->getEncryptionLevel() === $this->sslConfigurator->configure($this->uri, $sslConfig)[0] &&
+                $connection->getUserAgent() === $userAgent &&
+                $connection->getServerAddress()->getHost() === $this->uri->getHost() &&
+                $connection->getServerAddress()->getPort() === $this->uri->getPort();
     }
 
     public function reuseConnection(ConnectionInterface $connection, SessionConfiguration $config): ConnectionInterface
@@ -124,12 +120,11 @@ public function reuseConnection(ConnectionInterface $connection, SessionConfigur
             $connection->getServerVersion(),
             $connection->getProtocol(),
             $config->getAccessMode(),
-            $this->config,
             $config->getDatabase() === null ? null : new DatabaseInfo($config->getDatabase())
         );
 
         [$protocol, $connectionImpl] = $connection->getImplementation();
 
-        return new BoltConnection($protocol, $connectionImpl, $config, $this->auth, $connection->getEncryptionLevel());
+        return new BoltConnection($protocol, $connectionImpl, $config, $connection->getAuthentication(), $connection->getEncryptionLevel());
     }
 }

src/Common/ConnectionConfiguration.php

@@ -14,7 +14,6 @@
 namespace Laudis\Neo4j\Common;
 
 use Laudis\Neo4j\Databags\DatabaseInfo;
-use Laudis\Neo4j\Databags\DriverConfiguration;
 use Laudis\Neo4j\Enum\AccessMode;
 use Laudis\Neo4j\Enum\ConnectionProtocol;
 use Psr\Http\Message\UriInterface;
@@ -29,7 +28,6 @@ final class ConnectionConfiguration
     private string $serverVersion;
     private ConnectionProtocol $protocol;
     private AccessMode $accessMode;
-    private DriverConfiguration $driverConfiguration;
     private ?DatabaseInfo $databaseInfo;
 
     public function __construct(
@@ -38,15 +36,13 @@ public function __construct(
         string $serverVersion,
         ConnectionProtocol $protocol,
         AccessMode $accessMode,
-        DriverConfiguration $driverConfiguration,
         ?DatabaseInfo $databaseInfo
     ) {
         $this->serverAgent = $serverAgent;
         $this->serverAddress = $serverAddress;
         $this->serverVersion = $serverVersion;
         $this->protocol = $protocol;
         $this->accessMode = $accessMode;
-        $this->driverConfiguration = $driverConfiguration;
         $this->databaseInfo = $databaseInfo;
     }
 
@@ -75,11 +71,6 @@ public function getAccessMode(): AccessMode
         return $this->accessMode;
     }
 
-    public function getDriverConfiguration(): DriverConfiguration
-    {
-        return $this->driverConfiguration;
-    }
-
     public function getDatabaseInfo(): ?DatabaseInfo
     {
         return $this->databaseInfo;

src/Contracts/ConnectionFactoryInterface.php

@@ -11,8 +11,8 @@
 
 namespace Laudis\Neo4j\Contracts;
 
-use Laudis\Neo4j\Bolt\Session;
 use Laudis\Neo4j\Databags\SessionConfiguration;
+use Laudis\Neo4j\Databags\SslConfiguration;
 
 /**
  * @template T
@@ -22,14 +22,14 @@ interface ConnectionFactoryInterface
     /**
      * @return ConnectionInterface<T>
      */
-    public function createConnection(AuthenticateInterface $auth, SessionConfiguration $config): ConnectionInterface;
+    public function createConnection(string $userAgent, SslConfiguration $sslConfig, SessionConfiguration $sessionConfig, AuthenticateInterface $auth): ConnectionInterface;
 
     /**
      * @param ConnectionInterface<T> $connection
      *
      * @return bool
      */
-    public function canReuseConnection(ConnectionInterface $connection): bool;
+    public function canReuseConnection(ConnectionInterface $connection, string $userAgent, SslConfiguration $sslConfig, AuthenticateInterface $auth): bool;
 
     /**
      * @param ConnectionInterface<T> $connection

src/Contracts/ConnectionInterface.php

@@ -106,4 +106,11 @@ public function isOpen(): bool;
      * @return string
      */
     public function getEncryptionLevel(): string;
+
+    /**
+     * Returns the user agent handling this connection.
+     *
+     * @return string
+     */
+    public function getUserAgent(): string;
 }