private ClusterConnectionPool(IEnumerable <Uri> initUris,
IConnectionPoolFactory poolFactory, IDriverLogger logger)
{
_logger = logger;
_poolFactory = poolFactory;
Add(initUris);
}
public Transaction(IConnection connection, ITransactionResourceHandler resourceHandler = null, IDriverLogger logger = null, Bookmark bookmark = null)
{
_connection = new TransactionConnection(this, connection);
_protocol = _connection.BoltProtocol;
_resourceHandler = resourceHandler;
_bookmark = bookmark;
_logger = logger;
}
public static Bookmark From(string bookmark, IDriverLogger logger = null)
{
if (bookmark == null)
{
return(new Bookmark(null, logger));
}
return(new Bookmark(new [] { bookmark }, logger));
}
internal static Session NewSession(IBoltProtocol protocol, IDriverLogger logger = null, IRetryLogic retryLogic = null, AccessMode mode = AccessMode.Write, string bookmark = null)
{
var mockConn = new Mock <IConnection>();
mockConn.Setup(x => x.IsOpen).Returns(true);
mockConn.Setup(x => x.BoltProtocol).Returns(protocol);
return(new Session(new TestConnectionProvider(mockConn.Object), logger, retryLogic, mode, Bookmark.From(bookmark)));
}
public AsyncRetryLogic(TimeSpan maxRetryTimeout, IDriverLogger logger)
{
_maxRetryTimeMs = maxRetryTimeout.TotalMilliseconds;
_logger = logger;
_initialRetryDelayMs = InitialRetryDelayMs;
_multiplier = RetryDelayMultiplier;
_jitterFactor = RetryDelayJitterFactor;
}
internal ChunkReader(Stream downStream, IDriverLogger logger)
{
Throw.ArgumentNullException.IfNull(downStream, nameof(downStream));
Throw.ArgumentOutOfRangeException.IfFalse(downStream.CanRead, nameof(downStream));
_downStream = downStream;
_logger = logger;
}
public RoutingTableManager(
RoutingSettings routingSettings,
IClusterConnectionPoolManager poolManager,
IDriverLogger logger) :
this(routingSettings.InitialServerAddressProvider, routingSettings.RoutingContext,
new RoutingTable(Enumerable.Empty <Uri>()), poolManager, logger)
{
}
public ClusterConnectionPool(
IEnumerable <Uri> initUris,
IPooledConnectionFactory connectionFactory,
ConnectionPoolSettings poolSettings,
IDriverLogger logger
) : this(initUris, new ConnectionPoolFactory(connectionFactory, poolSettings, logger), logger)
{
}
public PooledConnectionFactory(ConnectionSettings connectionSettings, BufferSettings bufferSettings, IDriverLogger logger)
{
Throw.ArgumentNullException.IfNull(connectionSettings, nameof(connectionSettings));
Throw.ArgumentNullException.IfNull(bufferSettings, nameof(bufferSettings));
_connectionSettings = connectionSettings;
_bufferSettings = bufferSettings;
_logger = logger;
}
private static ResponsePipeline CreatePipelineWithHandler(IDriverLogger logger)
{
var pipeline = new ResponsePipeline(logger);
var(msg, handler) = (new Mock <IRequestMessage>(), new Mock <IResponseHandler>());
pipeline.Enqueue(msg.Object, handler.Object);
return(pipeline);
}
public ConnectionPoolFactory(IPooledConnectionFactory connectionFactory, ConnectionPoolSettings poolSettings,
IDriverLogger logger)
{
Throw.ArgumentNullException.IfNull(connectionFactory, nameof(connectionFactory));
Throw.ArgumentNullException.IfNull(poolSettings, nameof(poolSettings));
_connectionFactory = connectionFactory;
_poolSettings = poolSettings;
_logger = logger;
}
// test only
internal ClusterConnectionPool(
IConnectionPoolFactory poolFactory,
ConcurrentDictionary <Uri, IConnectionPool> clusterPool,
IDriverLogger logger = null
) :
this(Enumerable.Empty <Uri>(), poolFactory, logger)
{
_pools = clusterPool;
}
public RxRetryLogic(TimeSpan maxRetryTimeout, IDriverLogger logger)
{
_maxRetryTimeout = (int)maxRetryTimeout.TotalMilliseconds;
_initialDelay = TimeSpan.FromSeconds(1).TotalMilliseconds;
_delayMultiplier = 2.0;
_delayJitter = 0.2;
_random = new Random(Guid.NewGuid().GetHashCode());
_logger = logger;
}
public Session(IConnectionProvider provider, IDriverLogger logger, IRetryLogic retryLogic = null,
AccessMode defaultMode = AccessMode.Write, Bookmark bookmark = null)
{
_logger = logger;
_connectionProvider = provider;
_retryLogic = retryLogic;
_defaultMode = defaultMode;
UpdateBookmark(bookmark);
}
internal Driver(Uri uri, IConnectionProvider connectionProvider, IRetryLogic retryLogic, IDriverLogger logger,
IMetrics metrics = null)
{
Throw.ArgumentNullException.IfNull(connectionProvider, nameof(connectionProvider));
Uri = uri;
_logger = logger;
_connectionProvider = connectionProvider;
_retryLogic = retryLogic;
_metrics = metrics;
}
public MessageReader(IChunkReader chunkReader, int defaultBufferSize, int maxBufferSize, IDriverLogger logger, IMessageFormat messageFormat)
{
Throw.ArgumentNullException.IfNull(chunkReader, nameof(chunkReader));
Throw.ArgumentNullException.IfNull(messageFormat, nameof(messageFormat));
_logger = logger;
_chunkReader = chunkReader;
_defaultBufferSize = defaultBufferSize;
_maxBufferSize = maxBufferSize;
_bufferStream = new MemoryStream(_defaultBufferSize);
_packStreamReader = messageFormat.CreateReader(_bufferStream);
}
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 static async Task <T> TryExecuteAsync <T>(IDriverLogger logger, Func <Task <T> > func, string message = null)
{
try
{
return(await func().ConfigureAwait(false));
}
catch (Exception ex)
{
logger?.Error(ex, message);
throw;
}
}
public static void TryExecute(IDriverLogger logger, Action action, string message = null)
{
try
{
action();
}
catch (Exception ex)
{
logger?.Error(ex, message);
throw;
}
}
public static T TryExecute <T>(IDriverLogger logger, Func <T> func, string message = null)
{
try
{
return(func());
}
catch (Exception ex)
{
logger?.Error(ex, message);
throw;
}
}
// for test only
internal LoadBalancer(
IClusterConnectionPool clusterConnPool,
IRoutingTableManager routingTableManager)
{
var config = Config.DefaultConfig;
_logger = config.DriverLogger;
_clusterConnectionPool = clusterConnPool;
_routingTableManager = routingTableManager;
_loadBalancingStrategy = CreateLoadBalancingStrategy(config.LoadBalancingStrategy, clusterConnPool, _logger);
}
public RoutingTableManager(
IInitialServerAddressProvider initialServerAddressProvider,
IDictionary <string, string> routingContext,
IRoutingTable routingTable,
IClusterConnectionPoolManager poolManager,
IDriverLogger logger)
{
_initialServerAddressProvider = initialServerAddressProvider;
_routingContext = routingContext;
_routingTable = routingTable;
_poolManager = poolManager;
_logger = logger;
}
public SocketConnection(Uri uri, ConnectionSettings connectionSettings, BufferSettings bufferSettings,
IConnectionListener metricsListener = null, IDriverLogger logger = null)
{
_id = $"conn-{UniqueIdGenerator.GetId()}";
_logger = new PrefixLogger(logger, FormatPrefix(_id));
_client = new SocketClient(uri, connectionSettings.SocketSettings, bufferSettings, metricsListener, _logger);
_authToken = connectionSettings.AuthToken;
_userAgent = connectionSettings.UserAgent;
Server = new ServerInfo(uri);
_responseHandler = new MessageResponseHandler(_logger);
}
public RoutingTableManager(
IInitialServerAddressProvider initialServerAddressProvider,
IDiscovery discovery,
IRoutingTable routingTable,
IClusterConnectionPoolManager poolManager,
IDriverLogger logger)
{
_initialServerAddressProvider = initialServerAddressProvider;
_discovery = discovery;
_routingTable = routingTable;
_poolManager = poolManager;
_logger = logger;
}
public TcpSocketClient(SocketSettings socketSettings, IDriverLogger logger = null)
{
Throw.ArgumentNullException.IfNull(socketSettings, nameof(socketSettings));
Throw.ArgumentNullException.IfNull(socketSettings.HostResolver, nameof(SocketSettings.HostResolver));
Throw.ArgumentNullException.IfNull(socketSettings.EncryptionManager, nameof(SocketSettings.EncryptionManager));
_logger = logger;
_resolver = socketSettings.HostResolver;
_encryptionManager = socketSettings.EncryptionManager;
_ipv6Enabled = socketSettings.Ipv6Enabled;
_connectionTimeout = socketSettings.ConnectionTimeout;
_socketKeepAliveEnabled = socketSettings.SocketKeepAliveEnabled;
}
public SocketClient(Uri uri, SocketSettings socketSettings, BufferSettings bufferSettings,
IConnectionListener connMetricsListener = null, IDriverLogger logger = null, ITcpSocketClient socketClient = null)
{
_uri = uri;
_logger = logger;
_bufferSettings = bufferSettings;
_tcpSocketClient = socketClient ?? new TcpSocketClient(socketSettings, _logger);
_connMetricsListener = connMetricsListener;
if (_connMetricsListener != null)
{
_connEvent = new SimpleTimerEvent();
}
}
public ChunkWriter(Stream downStream, int defaultBufferSize, int maxBufferSize, IDriverLogger logger, int chunkSize)
{
Throw.ArgumentNullException.IfNull(downStream, nameof(downStream));
Throw.ArgumentOutOfRangeException.IfFalse(downStream.CanWrite, nameof(downStream));
Throw.ArgumentOutOfRangeException.IfValueLessThan(chunkSize, Constants.MinChunkSize, nameof(chunkSize));
Throw.ArgumentOutOfRangeException.IfValueGreaterThan(chunkSize, Constants.MaxChunkSize, nameof(chunkSize));
_logger = logger;
_chunkSize = chunkSize;
_downStream = downStream;
_defaultBufferSize = defaultBufferSize;
_maxBufferSize = maxBufferSize;
_chunkStream = new MemoryStream(_defaultBufferSize);
}
private static ILoadBalancingStrategy CreateLoadBalancingStrategy(LoadBalancingStrategy strategy, IClusterConnectionPool pool,
IDriverLogger logger)
{
if (strategy == LoadBalancingStrategy.LeastConnected)
{
return(new LeastConnectedLoadBalancingStrategy(pool, logger));
}
else if (strategy == LoadBalancingStrategy.RoundRobin)
{
return(new RoundRobinLoadBalancingStrategy(logger));
}
else
{
throw new ArgumentException($"Unknown load balancing strategy: {strategy}");
}
}
public ClusterDiscoveryManager(IConnection connection, IDictionary <string, string> context, IDriverLogger logger)
{
_conn = connection;
_logger = logger;
if (ServerVersion.Version(_conn.Server.Version) >= ServerVersion.V3_2_0)
{
DiscoveryProcedure = new Statement($"CALL {GetRoutingTableProcedure}({{context}})",
new Dictionary <string, object> {
{ "context", context }
});
}
else
{
DiscoveryProcedure = new Statement($"CALL {GetServersProcedure}");
}
}
// for test only
internal SocketConnection(ISocketClient socketClient, IAuthToken authToken,
string userAgent, IDriverLogger logger, IServerInfo server,
IResponsePipeline responsePipeline = null)
{
Throw.ArgumentNullException.IfNull(socketClient, nameof(socketClient));
Throw.ArgumentNullException.IfNull(authToken, nameof(authToken));
Throw.ArgumentNullException.IfNull(userAgent, nameof(userAgent));
Throw.ArgumentNullException.IfNull(server, nameof(server));
_client = socketClient;
_authToken = authToken;
_userAgent = userAgent;
Server = server;
_id = $"{_idPrefix}{UniqueIdGenerator.GetId()}";
_logger = new PrefixLogger(logger, FormatPrefix(_id));
_responsePipeline = responsePipeline ?? new ResponsePipeline(logger);
}
