internal static IDriver CreateDriver(Uri uri, Config config, IPooledConnectionFactory connectionFactory)
{
var logger = config.Logger;
var parsedUri = uri.ParseBoltUri(DefaultBoltPort);
var routingContext = uri.ParseRoutingContext();
var routingSettings = new RoutingSettings(parsedUri, routingContext, config);
var metrics = config.MetricsEnabled ? new DefaultMetrics() : null;
var connectionPoolSettings = new ConnectionPoolSettings(config, metrics);
var retryLogic = new AsyncRetryLogic(config.MaxTransactionRetryTime, logger);
IConnectionProvider connectionProvider = null;
if (parsedUri.IsRoutingUri())
{
connectionProvider =
new LoadBalancer(connectionFactory, routingSettings, connectionPoolSettings, logger);
}
else
{
EnsureNoRoutingContext(uri, routingContext);
connectionProvider =
new ConnectionPool(parsedUri, connectionFactory, connectionPoolSettings, logger);
}
return(new Internal.Driver(parsedUri, connectionProvider, retryLogic, logger, metrics, config));
}
internal static IDriver CreateDriver(Uri uri, Config config, IPooledConnectionFactory connectionFactory)
{
var logger = config.Logger;
var parsedUri = uri.ParseBoltUri(DefaultBoltPort);
var routingContext = uri.ParseRoutingContext();
var routingSettings = new RoutingSettings(parsedUri, routingContext, config);
var metrics = config.MetricsFactory?.CreateMetrics(config);
var connectionPoolSettings = new ConnectionPoolSettings(config, metrics);
var retryLogic = new ExponentialBackoffRetryLogic(config.MaxTransactionRetryTime, logger);
IConnectionProvider connectionProvider = null;
switch (parsedUri.Scheme.ToLower())
{
case "bolt":
EnsureNoRoutingContext(uri, routingContext);
connectionProvider = new ConnectionPool(parsedUri, connectionFactory, connectionPoolSettings, logger);
break;
case "bolt+routing":
connectionProvider = new LoadBalancer(connectionFactory, routingSettings, connectionPoolSettings, logger);
break;
default:
throw new NotSupportedException($"Unsupported URI scheme: {parsedUri.Scheme}");
}
return(new Internal.Driver(parsedUri, connectionProvider, retryLogic, logger, metrics));
}
public SharedConnectionPoolFactory(
IConnectionFactory connectionFactory,
ConnectionPoolSettings connectionPoolSettings)
{
_connectionFactory = Ensure.IsNotNull(connectionFactory, "connectionFactory");
_connectionPoolSettings = Ensure.IsNotNull(connectionPoolSettings, "connectionPoolSettings");
}
public void GetChannel_should_update_topology_and_clear_connection_pool_on_network_error_or_timeout(
[Values("TimedOutSocketException", "NetworkUnreachableSocketException")] string errorType,
[Values(false, true)] bool async)
{
var serverId = new ServerId(_clusterId, _endPoint);
var connectionId = new ConnectionId(serverId);
var innerMostException = CoreExceptionHelper.CreateException(errorType);
var openConnectionException = new MongoConnectionException(connectionId, "Oops", new IOException("Cry", innerMostException));
var mockConnection = new Mock <IConnectionHandle>();
mockConnection.Setup(c => c.Open(It.IsAny <CancellationToken>())).Throws(openConnectionException);
mockConnection.Setup(c => c.OpenAsync(It.IsAny <CancellationToken>())).ThrowsAsync(openConnectionException);
var connectionFactory = new Mock <IConnectionFactory>();
connectionFactory.Setup(cf => cf.CreateConnection(serverId, _endPoint)).Returns(mockConnection.Object);
var mockExceptionHandler = new Mock <IConnectionExceptionHandler>();
var connectionPoolSettings = new ConnectionPoolSettings();
var connectionPool = new ExclusiveConnectionPool(serverId, _endPoint, connectionPoolSettings, connectionFactory.Object, new EventAggregator(), mockExceptionHandler.Object);
var mockConnectionPoolFactory = new Mock <IConnectionPoolFactory>();
mockConnectionPoolFactory
.Setup(f => f.CreateConnectionPool(It.IsAny <ServerId>(), _endPoint, It.IsAny <IConnectionExceptionHandler>()))
.Returns(connectionPool);
var mockMonitorServerDescription = new ServerDescription(serverId, _endPoint);
var mockServerMonitor = new Mock <IServerMonitor>();
mockServerMonitor.SetupGet(m => m.Description).Returns(mockMonitorServerDescription);
mockServerMonitor.SetupGet(m => m.Lock).Returns(new object());
var mockServerMonitorFactory = new Mock <IServerMonitorFactory>();
mockServerMonitorFactory.Setup(f => f.Create(It.IsAny <ServerId>(), _endPoint)).Returns(mockServerMonitor.Object);
var subject = new DefaultServer(_clusterId, _clusterClock, _clusterConnectionMode, _connectionModeSwitch, _directConnection, _settings, _endPoint, mockConnectionPoolFactory.Object, mockServerMonitorFactory.Object, _capturedEvents, _serverApi);
connectionPool._connectionExceptionHandler(subject);
subject.Initialize();
connectionPool.SetReady();
IChannelHandle channel = null;
Exception exception;
if (async)
{
exception = Record.Exception(() => channel = subject.GetChannelAsync(CancellationToken.None).GetAwaiter().GetResult());
}
else
{
exception = Record.Exception(() => channel = subject.GetChannel(CancellationToken.None));
}
channel.Should().BeNull();
exception.Should().Be(openConnectionException);
subject.Description.Type.Should().Be(ServerType.Unknown);
subject.Description.ReasonChanged.Should().Contain("ChannelException during handshake");
}
public ClusterConnectionPool(
IEnumerable <Uri> initUris,
IPooledConnectionFactory connectionFactory,
ConnectionPoolSettings poolSettings,
ILogger logger
) : this(initUris, new ConnectionPoolFactory(connectionFactory, poolSettings, logger), logger)
{
}
/// <summary>
/// Returns a driver for a Neo4j instance with custom configuration.
/// </summary>
/// <param name="uri">
/// The URI to the Neo4j instance. Should be in the form
/// <c>bolt://<server location>:<port></c>. If <c>port</c> is not supplied the default of <c>7687</c> will
/// be used.</param>
/// <param name="authToken">Authentication to use, <see cref="AuthTokens" />.</param>
/// <param name="config">
/// Configuration for the driver instance to use, if <c>null</c> <see cref="Config.DefaultConfig" />
/// is used.
/// </param>
/// <returns>A new driver to the database instance specified by the <paramref name="uri"/>.</returns>
public static IDriver Driver(Uri uri, IAuthToken authToken, Config config = null)
{
config = config ?? Config.DefaultConfig;
var encryptionManager = new EncryptionManager(config.EncryptionLevel, config.TrustStrategy, config.Logger);
var connectionPoolSettings = new ConnectionPoolSettings(config.MaxIdleSessionPoolSize);
return(new Internal.Driver(uri, authToken, encryptionManager, connectionPoolSettings, config.Logger));
}
public ConnectionPoolFactory(IPooledConnectionFactory connectionFactory, ConnectionPoolSettings poolSettings,
ILogger logger)
{
Throw.ArgumentNullException.IfNull(connectionFactory, nameof(connectionFactory));
Throw.ArgumentNullException.IfNull(poolSettings, nameof(poolSettings));
_connectionFactory = connectionFactory;
_poolSettings = poolSettings;
_logger = logger;
}
// private methods
private ExclusiveConnectionPool CreateSubject(ConnectionPoolSettings connectionPoolSettings = null)
{
return(new ExclusiveConnectionPool(
_serverId,
_endPoint,
connectionPoolSettings ?? _settings,
_mockConnectionFactory.Object,
_capturedEvents));
}
internal ClusterConnectionPool(IConnectionPool connectionPool,
ConcurrentDictionary <Uri, IConnectionPool> clusterPool = null,
ConnectionPoolSettings poolSettings = null,
ILogger logger = null) :
this(null, null, null, poolSettings, logger, null)
{
_fakeConnectionPool = connectionPool;
_pools = clusterPool;
}
private ConnectionPoolSettings ConfigureConnectionPool(ConnectionPoolSettings settings, ClusterKey clusterKey)
{
return(settings.With(
// maintenanceInterval: TODO: should this be configurable?
maxConnections: clusterKey.MaxConnectionPoolSize,
minConnections: clusterKey.MinConnectionPoolSize,
waitQueueSize: clusterKey.WaitQueueSize,
waitQueueTimeout: clusterKey.WaitQueueTimeout));
}
public ClusterConnectionPool(
ConnectionSettings connectionSettings,
ConnectionPoolSettings poolSettings,
ILogger logger
)
: base(logger)
{
_connectionSettings = connectionSettings;
_poolSettings = poolSettings;
}
public ConnectionPoolFactory(IPooledConnectionFactory connectionFactory, ConnectionPoolSettings poolSettings,
IDictionary <string, string> routingContext, ILogger logger)
{
Throw.ArgumentNullException.IfNull(connectionFactory, nameof(connectionFactory));
Throw.ArgumentNullException.IfNull(poolSettings, nameof(poolSettings));
_connectionFactory = connectionFactory;
_poolSettings = poolSettings;
_logger = logger;
_routingContext = routingContext;
}
public void ConnectionPoolAfterOpening(ServerId serverId, ConnectionPoolSettings settings)
{
var serverPackage = GetServerPackage(serverId.EndPoint);
ConnectionPoolPerformanceRecorder recorder = new ConnectionPoolPerformanceRecorder(settings.MaxConnections, _appPackage, serverPackage);
if (_connectionPoolRecorders.TryAdd(serverId, recorder))
{
recorder.Opened();
}
}
public void Setup()
{
_connectionFactory = Substitute.For <IConnectionFactory>();
_endPoint = new DnsEndPoint("localhost", 27017);
_serverId = new ServerId(new ClusterId(), _endPoint);
_settings = new ConnectionPoolSettings()
.WithMaintenanceInterval(Timeout.InfiniteTimeSpan)
.WithMaxConnections(4)
.WithMinConnections(2)
.WithWaitQueueSize(1);
}
public void Setup()
{
_connectionFactory = Substitute.For <IConnectionFactory>();
_endPoint = new DnsEndPoint("localhost", 27017);
_serverId = new ServerId(new ClusterId(), _endPoint);
_settings = new ConnectionPoolSettings(
maintenanceInterval: Timeout.InfiniteTimeSpan,
maxConnections: 4,
minConnections: 2,
waitQueueSize: 1);
}
// constructors
public SharedConnectionPool(
ServerId serverId,
EndPoint endPoint,
ConnectionPoolSettings settings,
IConnectionFactory connectionFactory)
{
_serverId = Ensure.IsNotNull(serverId, "serverId");
_endPoint = Ensure.IsNotNull(endPoint, "endPoint");
_settings = Ensure.IsNotNull(settings, "settings");
_connectionFactory = Ensure.IsNotNull(connectionFactory, "connectionFactory");
}
public ExclusiveConnectionPoolFactoryTests()
{
_connectionFactory = new Mock <IConnectionFactory>().Object;
_endPoint = new DnsEndPoint("localhost", 27017);
_serverId = new ServerId(new ClusterId(), _endPoint);
_eventSubscriber = new Mock <IEventSubscriber>().Object;
_settings = new ConnectionPoolSettings(
maintenanceInterval: Timeout.InfiniteTimeSpan,
maxConnections: 4,
minConnections: 2,
waitQueueSize: 1);
}
public void ShouldEnsureInitialRouter()
{
var uris = new HashSet <Uri> {
new Uri("bolt://123:456")
};
var connFactory = new Mock <IPooledConnectionFactory>().Object;
var poolSettings = new ConnectionPoolSettings(Config.DefaultConfig);
var pool = new ClusterConnectionPool(uris, connFactory, poolSettings, null);
pool.ToString().Should().Be(
"[{bolt://123:456/ : _idleConnections: {[]}, _inUseConnections: {[]}}]");
}
public LoadBalancer(
IPooledConnectionFactory connectionFactory,
RoutingSettings routingSettings,
ConnectionPoolSettings poolSettings,
IDriverLogger logger)
{
_logger = logger;
_clusterConnectionPool = new ClusterConnectionPool(Enumerable.Empty <Uri>(), connectionFactory, poolSettings, logger);
_routingTableManager = new RoutingTableManager(routingSettings, this, logger);
_loadBalancingStrategy = CreateLoadBalancingStrategy(routingSettings.Strategy, _clusterConnectionPool, _logger);
}
public void GetChannel_should_not_update_topology_and_clear_connection_pool_on_MongoConnectionException(
[Values("TimedOutSocketException", "NetworkUnreachableSocketException")] string errorType,
[Values(false, true)] bool async)
{
var serverId = new ServerId(_clusterId, _endPoint);
var connectionId = new ConnectionId(serverId);
var innerMostException = CoreExceptionHelper.CreateException(errorType);
var mockConnectionExceptionHandler = new Mock <IConnectionExceptionHandler>();
var openConnectionException = new MongoConnectionException(connectionId, "Oops", new IOException("Cry", innerMostException));
var mockConnection = new Mock <IConnectionHandle>();
mockConnection.Setup(c => c.Open(It.IsAny <CancellationToken>())).Throws(openConnectionException);
mockConnection.Setup(c => c.OpenAsync(It.IsAny <CancellationToken>())).ThrowsAsync(openConnectionException);
var connectionFactory = new Mock <IConnectionFactory>();
connectionFactory.Setup(cf => cf.CreateConnection(serverId, _endPoint)).Returns(mockConnection.Object);
var connectionPoolSettings = new ConnectionPoolSettings();
var connectionPool = new ExclusiveConnectionPool(serverId, _endPoint, connectionPoolSettings, connectionFactory.Object, new EventAggregator(), mockConnectionExceptionHandler.Object);
var mockConnectionPoolFactory = new Mock <IConnectionPoolFactory>();
mockConnectionPoolFactory
.Setup(f => f.CreateConnectionPool(It.IsAny <ServerId>(), _endPoint, It.IsAny <IConnectionExceptionHandler>()))
.Returns(connectionPool);
var subject = new LoadBalancedServer(_clusterId, _clusterClock, _settings, _endPoint, mockConnectionPoolFactory.Object, _capturedEvents, _serverApi);
subject.Initialize();
IChannelHandle channel = null;
Exception exception;
if (async)
{
exception = Record.Exception(() => channel = subject.GetChannelAsync(CancellationToken.None).GetAwaiter().GetResult());
}
else
{
exception = Record.Exception(() => channel = subject.GetChannel(CancellationToken.None));
}
channel.Should().BeNull();
exception.Should().Be(openConnectionException);
subject.Description.Type.Should().Be(ServerType.LoadBalanced);
subject.Description.ReasonChanged.Should().Be("Initialized");
subject.Description.State.Should().Be(ServerState.Connected);
_mockConnectionPool.Verify(c => c.Clear(It.IsAny <bool>()), Times.Never);
}
public LoadBalancer(
IPooledConnectionFactory connectionFactory,
RoutingSettings routingSettings,
ConnectionPoolSettings poolSettings,
ILogger logger)
{
_logger = logger;
_clusterConnectionPool =
new ClusterConnectionPool(Enumerable.Empty <Uri>(), connectionFactory, poolSettings, logger);
_routingTableManager = new RoutingTableManager(routingSettings, this, logger);
_loadBalancingStrategy = CreateLoadBalancingStrategy(_clusterConnectionPool, _logger);
_initialServerAddressProvider = routingSettings.InitialServerAddressProvider;
}
public void ShouldEnsureInitialRouter()
{
var uri = new Uri("bolt://123:456");
var config = Config.DefaultConfig;
var routingSettings = new RoutingSettings(new Dictionary <string, string>());
var connSettings = new ConnectionSettings(uri, new Mock <IAuthToken>().Object, config);
var poolSettings = new ConnectionPoolSettings(config);
var loadbalancer = new LoadBalancer(routingSettings, connSettings, poolSettings, null);
loadbalancer.ToString().Should().Be(
"_routingTable: {[_routers: bolt://123:456/], [_detachedRouters: ], [_readers: ], [_writers: ]}, " +
"_clusterConnectionPool: {[{bolt://123:456/ : _availableConnections: {[]}, _inUseConnections: {[]}}]}");
}
public LoadBalancer(
IPooledConnectionFactory connectionFactory,
RoutingSettings routingSettings,
ConnectionPoolSettings poolSettings,
ILogger logger)
{
_logger = logger;
var uris = routingSettings.InitialServers;
_clusterConnectionPool = new ClusterConnectionPool(uris, connectionFactory, poolSettings, logger);
_routingTableManager = new RoutingTableManager(routingSettings, this, logger);
_loadBalancingStrategy = CreateLoadBalancingStrategy(routingSettings.Strategy, _clusterConnectionPool, logger);
}
public void ShouldNotThrowExceptionWhenIdlePoolSizeReached()
{
var connectionPoolSettings = new ConnectionPoolSettings(2, Config.Infinite);
var pool = new ConnectionPool(MockedConnection, settings: connectionPoolSettings);
pool.Acquire();
pool.Acquire();
pool.NumberOfAvailableConnections.Should().Be(0);
pool.NumberOfInUseConnections.Should().Be(2);
var ex = Record.Exception(() => pool.Acquire());
ex.Should().BeNull();
}
public void ShouldThrowOnExecutionOfMultiConnectionInPool()
{
var host = "localhost";
var port = 8182;
var sessionId = Guid.NewGuid().ToString();
// set pool size more than 1
var poolSettings = new ConnectionPoolSettings {
PoolSize = 2
};
var gremlinServer = new GremlinServer(host, port);
Assert.Throws <ArgumentOutOfRangeException>(() => new GremlinClient(gremlinServer, connectionPoolSettings: poolSettings, sessionId: sessionId));
}
private void ParseSettings(
BsonDocument test,
out ConnectionPoolSettings connectionPoolSettings,
out ConnectionSettings connectionSettings)
{
connectionPoolSettings = new ConnectionPoolSettings(maintenanceInterval: TimeSpan.FromMilliseconds(200));
connectionSettings = new ConnectionSettings();
if (test.TryGetValue(Schema.poolOptions, out var poolOptionsBson))
{
var poolOptionsDocument = poolOptionsBson.AsBsonDocument;
foreach (var poolOption in poolOptionsDocument.Elements)
{
switch (poolOption.Name)
{
case "backgroundThreadIntervalMS":
connectionPoolSettings = connectionPoolSettings.With(maintenanceInterval: TimeSpan.FromMilliseconds(poolOption.Value.ToInt32()));
break;
case "maxPoolSize":
connectionPoolSettings = connectionPoolSettings.With(maxConnections: poolOption.Value.ToInt32());
break;
case "minPoolSize":
connectionPoolSettings = connectionPoolSettings.With(minConnections: poolOption.Value.ToInt32());
break;
case "waitQueueTimeoutMS":
connectionPoolSettings = connectionPoolSettings.With(waitQueueTimeout: TimeSpan.FromMilliseconds(poolOption.Value.ToInt32()));
break;
case "maxIdleTimeMS":
connectionSettings = connectionSettings.With(maxIdleTime: TimeSpan.FromMilliseconds(poolOption.Value.ToInt32()));
break;
case "appName":
connectionSettings = connectionSettings.With(applicationName: poolOption.Value.AsString);
break;
case "maxConnecting":
connectionPoolSettings = connectionPoolSettings.With(maxConnecting: poolOption.Value.ToInt32());
break;
default:
throw new ArgumentException($"Unknown pool option {poolOption.Name}.");
}
}
}
}
public void ShouldAcquireFromPoolIfAvailable()
{
var connectionPoolSettings = new ConnectionPoolSettings(2, Config.Infinite);
var pool = new ConnectionPool(MockedConnection, settings: connectionPoolSettings);
for (var i = 0; i < 4; i++)
{
var conn = pool.Acquire();
pool.NumberOfAvailableConnections.Should().Be(0);
conn.Dispose();
pool.NumberOfAvailableConnections.Should().Be(1);
}
pool.NumberOfAvailableConnections.Should().Be(1);
}
internal RoutingDriver(
Uri seedServer,
IAuthToken authToken,
EncryptionManager encryptionManager,
ConnectionPoolSettings poolSettings,
ILogger logger)
{
Throw.ArgumentNullException.IfNull(seedServer, nameof(seedServer));
Throw.ArgumentNullException.IfNull(authToken, nameof(authToken));
Throw.ArgumentNullException.IfNull(encryptionManager, nameof(encryptionManager));
Throw.ArgumentNullException.IfNull(poolSettings, nameof(poolSettings));
Uri = seedServer;
_logger = logger;
_loadBalancer = new RoundRobinLoadBalancer(seedServer, authToken, encryptionManager, poolSettings, _logger);
}
public RoundRobinLoadBalancer(
Uri seedServer,
IAuthToken authToken,
EncryptionManager encryptionManager,
ConnectionPoolSettings poolSettings,
ILogger logger)
{
_clusterConnectionPool = new ClusterConnectionPool(
seedServer, authToken, encryptionManager,
poolSettings, logger, CreateClusterPooledConnectionErrorHandler);
_stopwatch = new Stopwatch();
_clusterView = new RoundRobinClusterView(seedServer, _stopwatch);
_logger = logger;
}
public void ShouldEnsureInitialRouter()
{
var uri = new Uri("bolt://123:456");
var uris = new HashSet <Uri> {
uri
};
var connFactory = new Mock <IPooledConnectionFactory>().Object;
var poolSettings = new ConnectionPoolSettings(Config.Default);
var routingSetting = new RoutingSettings(uri, new Dictionary <string, string>(), Config.Default);
var pool = new ClusterConnectionPool(uris, connFactory, routingSetting, poolSettings, null);
pool.ToString().Should().Contain(
"bolt://123:456/");
pool.ToString().Should().Contain(
"_idleConnections: {[]}, _inUseConnections: {[]}");
}
