private Pool <IThriftConnection> CreateFiercePool(ICassandraClusterSettings settings, IPEndPoint nodeEndpoint, string keyspaceName)
{
var result = new Pool <IThriftConnection>(pool => CreateThriftConnection(nodeEndpoint, keyspaceName, settings.FierceTimeout), logger);
logger.Debug("Pool for node with endpoint {0} for keyspace '{1}'[Fierce] was created.", nodeEndpoint, keyspaceName);
return(result);
}
private Pool <IThriftConnection> GetDataConnectionPool(ICassandraClusterSettings settings, IPEndPoint nodeEndpoint, string keyspaceName)
{
var result = CreateConnectionPool(settings, nodeEndpoint, keyspaceName, settings.Timeout);
logger.Debug("Pool for node with endpoint {0} for keyspace '{1}' was created.", nodeEndpoint, keyspaceName);
return(result);
}
public CassandraCluster(ICassandraClusterSettings settings, ILog logger)
{
this.logger = logger.ForContext("CassandraThriftClient");
dataCommandsConnectionPool = CreateDataConnectionPool(settings);
fierceCommandsConnectionPool = CreateFierceConnectionPool(settings);
commandExecutor = new SimpleCommandExecutor(dataCommandsConnectionPool, settings, logger);
fierceCommandExecutor = new FierceCommandExecutor(fierceCommandsConnectionPool, settings);
clusterSettings = settings;
}
private Pool <IThriftConnection> CreateConnectionPool(ICassandraClusterSettings settings, IPEndPoint nodeEndpoint, string keyspaceName, int timeout)
{
var connectionPoolMetrics = CommandMetricsFactory.GetConnectionPoolMetrics(settings, nodeEndpoint.Address.ToString().Replace('.', '_'), keyspaceName);
return(new Pool <IThriftConnection>(
pool => CreateThriftConnection(nodeEndpoint, keyspaceName, timeout, settings.Credentials),
connectionPoolMetrics,
logger));
}
public ColumnFamilyConnectionImplementation(string keyspaceName,
string columnFamilyName,
ICassandraClusterSettings cassandraClusterSettings,
ICommandExecutor <ISimpleCommand> commandExecutor,
ICommandExecutor <IFierceCommand> fierceCommandExecutor)
{
this.keyspaceName = keyspaceName;
this.columnFamilyName = columnFamilyName;
this.cassandraClusterSettings = cassandraClusterSettings;
this.commandExecutor = commandExecutor;
this.fierceCommandExecutor = fierceCommandExecutor;
readConsistencyLevel = cassandraClusterSettings.ReadConsistencyLevel.ToThriftConsistencyLevel();
writeConsistencyLevel = cassandraClusterSettings.WriteConsistencyLevel.ToThriftConsistencyLevel();
connectionParameters = new CassandraConnectionParameters(cassandraClusterSettings);
}
public FierceCommandExecutor([NotNull] IPoolSet <IThriftConnection, string> connectionPool, [NotNull] ICassandraClusterSettings settings)
: base(connectionPool, settings)
{
}
protected CommandExecutorBase([NotNull] IThriftConnectionReplicaSetPool connectionPool, [NotNull] ICassandraClusterSettings settings)
{
this.connectionPool = connectionPool;
this.settings = settings;
}
public static ISimpleCommandMetrics GetMetrics([NotNull] this ISimpleCommand command, [NotNull] ICassandraClusterSettings settings)
{
return(!settings.EnableMetrics
? (ISimpleCommandMetrics)NoOpMetrics.Instance
: new SimpleCommandMetrics(GetMetricsContext(command, "Simple"), FormatSinglePartitionKey(command)));
}
public static IFierceCommandMetrics GetMetrics([NotNull] this IFierceCommand command, [NotNull] ICassandraClusterSettings settings)
{
return(!settings.EnableMetrics
? (IFierceCommandMetrics)NoOpMetrics.Instance
: new FierceCommandMetrics(GetMetricsContext(command, "Fierce")));
}
public SimpleCommandExecutor([NotNull] IPoolSet <IThriftConnection, string> connectionPool, [NotNull] ICassandraClusterSettings settings, ILog logger)
: base(connectionPool, settings)
{
if (settings.Attempts <= 0)
{
throw new InvalidOperationException(string.Format("settings.Attempts <= 0 for: {0}", settings));
}
this.logger = logger;
}
public static IConnectionPoolMetrics GetConnectionPoolMetrics([NotNull] ICassandraClusterSettings settings, [NotNull] string host, [NotNull] string keyspaceName)
{
return(!settings.EnableMetrics
? (IConnectionPoolMetrics)NoOpMetrics.Instance
: new ConnectionPoolMetrics(GetMetricsContext(command: null, "ConnectionPool").Context(keyspaceName).Context(host)));
}
public CassandraConnectionParameters(ICassandraClusterSettings cassandraClusterSettings)
{
this.cassandraClusterSettings = cassandraClusterSettings;
}
private ReplicaSetPool <IThriftConnection, string, IPEndPoint> CreateFierceConnectionPool(ICassandraClusterSettings settings)
{
var result = ReplicaSetPool.Create <IThriftConnection, string, IPEndPoint>(
new[] { settings.EndpointForFierceCommands },
(key, replicaKey) => CreateFiercePool(settings, replicaKey, key),
c => ((ThriftConnectionInPoolWrapper)c).ReplicaKey,
c => ((ThriftConnectionInPoolWrapper)c).KeyspaceName,
settings.ConnectionIdleTimeout,
PoolSettings.CreateDefault(),
logger);
return(result);
}
private ReplicaSetPool <IThriftConnection, string, IPEndPoint> CreateDataConnectionPool(ICassandraClusterSettings settings)
{
var replicaSetPool = ReplicaSetPool.Create <IThriftConnection, string, IPEndPoint>(
settings.Endpoints,
(key, replicaKey) => GetDataConnectionPool(settings, replicaKey, key),
c => ((ThriftConnectionInPoolWrapper)c).ReplicaKey,
c => ((ThriftConnectionInPoolWrapper)c).KeyspaceName,
settings.ConnectionIdleTimeout,
PoolSettings.CreateDefault(),
logger);
return(replicaSetPool);
}