private Cluster(IEnumerable <IPAddress> contactPoints, Configuration configuration)
{
this._contactPoints = contactPoints;
this._configuration = configuration;
this._metadata = new Metadata(configuration.Policies.ReconnectionPolicy);
var controlpolicies = new Cassandra.Policies(
//new ControlConnectionLoadBalancingPolicy(_configuration.Policies.LoadBalancingPolicy),
_configuration.Policies.LoadBalancingPolicy,
new ExponentialReconnectionPolicy(2 * 1000, 5 * 60 * 1000),
Cassandra.Policies.DefaultRetryPolicy);
foreach (var ep in _contactPoints)
{
Metadata.AddHost(ep);
}
var poolingOptions = new PoolingOptions()
.SetCoreConnectionsPerHost(HostDistance.Local, 0)
.SetMaxConnectionsPerHost(HostDistance.Local, 1)
.SetMinSimultaneousRequestsPerConnectionTreshold(HostDistance.Local, 0)
.SetMaxSimultaneousRequestsPerConnectionTreshold(HostDistance.Local, 127)
;
var controlConnection = new ControlConnection(this, new List <IPAddress>(), controlpolicies,
new ProtocolOptions(_configuration.ProtocolOptions.Port, configuration.ProtocolOptions.SslOptions),
poolingOptions, _configuration.SocketOptions,
new ClientOptions(
true,
_configuration.ClientOptions.QueryAbortTimeout, null),
_configuration.AuthProvider,
_configuration.AuthInfoProvider);
_metadata.SetupControllConnection(controlConnection);
}
/// <summary>
/// Initiates a schema agreement check.
/// <para/>
/// Schema changes need to be propagated to all nodes in the cluster.
/// Once they have settled on a common version, we say that they are in agreement.
/// <para/>
/// This method does not perform retries so
/// <see cref="ProtocolOptions.MaxSchemaAgreementWaitSeconds"/> does not apply.
/// </summary>
/// <returns>True if schema agreement was successful and false if it was not successful.</returns>
public async Task <bool> CheckSchemaAgreementAsync()
{
if (Hosts.Count == 1)
{
// If there is just one node, the schema is up to date in all nodes :)
return(true);
}
try
{
var queries = new[]
{
ControlConnection.QueryAsync(SelectSchemaVersionLocal),
ControlConnection.QueryAsync(SelectSchemaVersionPeers)
};
await Task.WhenAll(queries).ConfigureAwait(false);
return(CheckSchemaVersionResults(queries[0].Result, queries[1].Result));
}
catch (Exception ex)
{
Logger.Error("Error while checking schema agreement.", ex);
}
return(false);
}
/// <summary>
/// Shutdown this cluster instance. This closes all connections from all the
/// sessions of this <code>* Cluster</code> instance and reclaim all resources
/// used by it. <p> This method has no effect if the cluster was already shutdown.</p>
/// </summary>
public void Shutdown()
{
List <Session> conccpy;
lock (_connectedSessions)
{
conccpy = new List <Session>(_connectedSessions);
_connectedSessions = new List <Session>();
}
foreach (var ses in conccpy)
{
ses.Dispose();
}
lock (_controlConnectionGuard)
{
if (_controlConnection != null)
{
string cluster_name = this.Metadata.GetClusterName();
try
{
Monitor.Exit(_controlConnectionGuard);
_controlConnection.Dispose();
}
finally
{
Monitor.Enter(_controlConnectionGuard);
_controlConnection = null;
_logger.Info("Cluster [" + cluster_name + "] has been shut down.");
}
}
}
}
/// <summary>
/// Refresh the partition map for all tables.
/// </summary>
internal async Task RefreshPartitionMap()
{
if (!Configuration.Policies.LoadBalancingPolicy.RequiresPartitionMap)
{
return;
}
var addressToHosts = new Dictionary <IPAddress, Host>();
foreach (var host in AllHosts())
{
addressToHosts.Add(host.Address.Address, host);
}
var rows = await ControlConnection.QueryAsync(SelectPartitions);
var splitsSource = new Dictionary <string, List <PartitionMetadata> >();
foreach (var row in rows)
{
var keyspace = row.GetValue <string>("keyspace_name");
var tableName = row.GetValue <string>("table_name");
var fullTableName = keyspace + "." + tableName;
var replicas = row.GetValue <IDictionary <IPAddress, string> >("replica_addresses");
var hosts = new List <Host>(replicas.Count);
foreach (var entry in replicas)
{
Host host;
if (!addressToHosts.TryGetValue(entry.Key, out host))
{
continue;
}
var role = entry.Value;
if (role == "LEADER")
{
hosts.Insert(0, host);
}
else if (role == "READ_REPLICA" || role == "FOLLOWER")
{
hosts.Add(host);
}
}
var startKey = BytesToHashCode(row.GetValue <byte[]>("start_key"));
var endKey = BytesToHashCode(row.GetValue <byte[]>("end_key"));
List <PartitionMetadata> partitions;
if (!splitsSource.TryGetValue(fullTableName, out partitions))
{
partitions = new List <PartitionMetadata>();
splitsSource.Add(fullTableName, partitions);
}
partitions.Add(new PartitionMetadata(startKey, endKey, hosts));
}
var splits = new Dictionary <string, TableSplitMetadata>();
foreach (var entry in splitsSource)
{
splits.Add(entry.Key, new TableSplitMetadata(entry.Value));
}
TableSplitMetadata = splits;
}
/// <summary>
/// Initializes once (Thread-safe) the control connection and metadata associated with the Cluster instance
/// </summary>
private void Init()
{
if (_initialized)
{
//It was already initialized
return;
}
lock (_initLock)
{
if (_initialized)
{
//It was initialized when waiting on the lock
return;
}
if (_initException != null)
{
//There was an exception that is not possible to recover from
throw _initException;
}
var protocolVersion = (byte)MaxProtocolVersion;
if (Configuration.ProtocolOptions.MaxProtocolVersion != null &&
Configuration.ProtocolOptions.MaxProtocolVersion < MaxProtocolVersion
)
{
protocolVersion = Configuration.ProtocolOptions.MaxProtocolVersion.Value;
}
//create the buffer pool with 16KB for small buffers and 256Kb for large buffers.
Configuration.BufferPool = new RecyclableMemoryStreamManager(16 * 1024, 256 * 1024, ProtocolOptions.MaximumFrameLength);
_controlConnection = new ControlConnection(protocolVersion, Configuration, _metadata);
_metadata.ControlConnection = _controlConnection;
try
{
_controlConnection.Init();
_serializer = _controlConnection.Serializer;
//Initialize policies
Configuration.Policies.LoadBalancingPolicy.Initialize(this);
Configuration.Policies.SpeculativeExecutionPolicy.Initialize(this);
}
catch (NoHostAvailableException)
{
//No host available now, maybe later it can recover from
throw;
}
catch (Exception ex)
{
//There was an error that the driver is not able to recover from
//Store the exception for the following times
_initException = ex;
//Throw the actual exception for the first time
throw;
}
Configuration.Timer = new HashedWheelTimer();
_logger.Info("Cluster Connected using binary protocol version: [" + _serializer.ProtocolVersion + "]");
_initialized = true;
_metadata.Hosts.Added += OnHostAdded;
_metadata.Hosts.Removed += OnHostRemoved;
}
}
internal KeyspaceMetadata(ControlConnection cc, string name, bool durableWrites, string strategyClass,
IDictionary<string, int> replicationOptions)
{
_cc = cc;
Name = name;
DurableWrites = durableWrites;
StrategyClass = strategyClass;
Replication = replicationOptions;
}
internal KeyspaceMetadata(ControlConnection cc, string name, bool durableWrites, string strategyClass,
ReadOnlyDictionary <string, int> replicationOptions)
{
_cc = cc;
Name = name;
DurableWrites = durableWrites;
StrategyClass = strategyClass;
Replication = replicationOptions;
}
/// <summary>
/// Initializes once (Thread-safe) the control connection and metadata associated with the Cluster instance
/// </summary>
private void Init()
{
if (_initialized)
{
//It was already initialized
return;
}
lock (_initLock)
{
if (_initialized)
{
//It was initialized when waiting on the lock
return;
}
if (_initException != null)
{
//There was an exception that is not possible to recover from
throw _initException;
}
_protocolVersion = (byte)MaxProtocolVersion;
if (Configuration.ProtocolOptions.MaxProtocolVersion != null &&
Configuration.ProtocolOptions.MaxProtocolVersion < MaxProtocolVersion
)
{
_protocolVersion = Configuration.ProtocolOptions.MaxProtocolVersion.Value;
}
_controlConnection = new ControlConnection(_protocolVersion, Configuration, _metadata);
_metadata.ControlConnection = _controlConnection;
try
{
_controlConnection.Init();
_protocolVersion = _controlConnection.ProtocolVersion;
//Initialize policies
Configuration.Policies.LoadBalancingPolicy.Initialize(this);
Configuration.Policies.SpeculativeExecutionPolicy.Initialize(this);
}
catch (NoHostAvailableException)
{
//No host available now, maybe later it can recover from
throw;
}
catch (Exception ex)
{
//There was an error that the driver is not able to recover from
//Store the exception for the following times
_initException = ex;
//Throw the actual exception for the first time
throw;
}
Configuration.Timer = new HashedWheelTimer();
_logger.Info("Cluster Connected using binary protocol version: [" + _protocolVersion + "]");
_initialized = true;
_metadata.Hosts.Added += OnHostAdded;
_metadata.Hosts.Removed += OnHostRemoved;
}
}
/// <summary>
/// Creates a new session on this cluster and sets a keyspace to use.
/// </summary>
/// <param name="keyspace"> The name of the keyspace to use for the created <code>Session</code>. </param>
/// <returns>a new session on this cluster set to keyspace:
/// <code>keyspaceName</code>. </returns>
public Session Connect(string keyspace)
{
bool controlConnectionCreated = false;
lock (_controlConnectionGuard)
{
if (_controlConnection == null)
{
controlConnectionCreated = true;
var controlpolicies = new Cassandra.Policies(
_configuration.Policies.LoadBalancingPolicy,
new ExponentialReconnectionPolicy(2 * 1000, 5 * 60 * 1000),
Cassandra.Policies.DefaultRetryPolicy);
_hosts = new Hosts(_configuration.Policies.ReconnectionPolicy);
foreach (var ep in _contactPoints)
{
_hosts.AddIfNotExistsOrBringUpIfDown(ep);
}
var poolingOptions = new PoolingOptions().SetCoreConnectionsPerHost(HostDistance.Local, 1);
_controlConnection = new ControlConnection(this, new List <IPAddress>(), controlpolicies,
_configuration.ProtocolOptions,
poolingOptions, _configuration.SocketOptions,
new ClientOptions(
_configuration.ClientOptions.WithoutRowSetBuffering,
_configuration.ClientOptions.QueryAbortTimeout, null,
_configuration.ClientOptions.AsyncCallAbortTimeout),
_configuration.AuthInfoProvider,
_configuration.MetricsEnabled);
_metadata = new Metadata(_hosts, _controlConnection);
_controlConnection.Init();
}
}
var scs = new Session(this, _contactPoints, _configuration.Policies,
_configuration.ProtocolOptions,
_configuration.PoolingOptions, _configuration.SocketOptions,
_configuration.ClientOptions,
_configuration.AuthInfoProvider, _configuration.MetricsEnabled, keyspace, _hosts);
scs.Init();
lock (_connectedSessions)
_connectedSessions.Add(scs);
_logger.Info("Session connected!");
if (controlConnectionCreated)
{
RefreshSchema();
}
return(scs);
}
/// <summary>
/// Retrieves the keyspaces, stores the information in the internal state and rebuilds the token map
/// </summary>
internal void RefreshKeyspaces(bool retry)
{
Logger.Info("Retrieving keyspaces metadata");
//Use the control connection to get the keyspace
var rs = ControlConnection.Query(SelectKeyspaces, retry);
//parse the info
var keyspaces = rs.Select(ParseKeyspaceRow).ToDictionary(ks => ks.Name);
//Assign to local state
_keyspaces = new ConcurrentDictionary <string, KeyspaceMetadata>(keyspaces);
RebuildTokenMap();
}
internal KeyspaceMetadata(ControlConnection cc, string name, bool durableWrites, string strategyClass,
IDictionary<string, int> replicationOptions)
{
_cc = cc;
Name = name;
DurableWrites = durableWrites;
StrategyClass = strategyClass;
if (strategyClass != null && strategyClass.StartsWith("org.apache.cassandra.locator."))
{
StrategyClass = strategyClass.Replace("org.apache.cassandra.locator.", "");
}
Replication = replicationOptions;
}
internal KeyspaceMetadata(ControlConnection cc, string name, bool durableWrites, string strategyClass,
IDictionary <string, int> replicationOptions)
{
_cc = cc;
Name = name;
DurableWrites = durableWrites;
StrategyClass = strategyClass;
if (strategyClass != null && strategyClass.StartsWith("org.apache.cassandra.locator."))
{
StrategyClass = strategyClass.Replace("org.apache.cassandra.locator.", "");
}
Replication = replicationOptions;
}
private Cluster(IEnumerable <object> contactPoints, Configuration configuration)
{
Configuration = configuration;
_metadata = new Metadata(configuration);
TaskHelper.WaitToComplete(AddHosts(contactPoints));
var protocolVersion = _maxProtocolVersion;
if (Configuration.ProtocolOptions.MaxProtocolVersionValue != null &&
Configuration.ProtocolOptions.MaxProtocolVersionValue.Value.IsSupported())
{
protocolVersion = Configuration.ProtocolOptions.MaxProtocolVersionValue.Value;
}
_controlConnection = new ControlConnection(protocolVersion, Configuration, _metadata);
_metadata.ControlConnection = _controlConnection;
_serializer = _controlConnection.Serializer;
}
internal void RefreshSingleKeyspace(bool added, string name)
{
Logger.Verbose("Updating keyspace metadata: " + name);
var row = ControlConnection.Query(String.Format(SelectSingleKeyspace, name), true).FirstOrDefault();
if (row == null)
{
return;
}
var ksMetadata = ParseKeyspaceRow(row);
_keyspaces.AddOrUpdate(name, ksMetadata, (k, v) => ksMetadata);
var eventKind = added ? SchemaChangedEventArgs.Kind.Created : SchemaChangedEventArgs.Kind.Updated;
RebuildTokenMap();
FireSchemaChangedEvent(eventKind, name, null, this);
}
/// <summary>
/// Waits until that the schema version in all nodes is the same or the waiting time passed.
/// This method blocks the calling thread.
/// </summary>
internal void WaitForSchemaAgreement(Connection connection)
{
if (Hosts.Count == 1)
{
//If there is just one node, the schema is up to date in all nodes :)
return;
}
var start = DateTime.Now;
var waitSeconds = _config.ProtocolOptions.MaxSchemaAgreementWaitSeconds;
Logger.Info("Waiting for schema agreement");
try
{
var totalVersions = 0;
while (DateTime.Now.Subtract(start).TotalSeconds < waitSeconds)
{
var schemaVersionLocalQuery = new QueryRequest(connection.ProtocolVersion, SelectSchemaVersionLocal, false, QueryProtocolOptions.Default);
var schemaVersionPeersQuery = new QueryRequest(connection.ProtocolVersion, SelectSchemaVersionPeers, false, QueryProtocolOptions.Default);
var queries = new [] { connection.Send(schemaVersionLocalQuery), connection.Send(schemaVersionPeersQuery) };
// ReSharper disable once CoVariantArrayConversion
Task.WaitAll(queries, _config.ClientOptions.QueryAbortTimeout);
var versions = new HashSet <Guid>
{
ControlConnection.GetRowSet(queries[0].Result).First().GetValue <Guid>("schema_version")
};
var peerVersions = ControlConnection.GetRowSet(queries[1].Result).Select(r => r.GetValue <Guid>("schema_version"));
foreach (var v in peerVersions)
{
versions.Add(v);
}
totalVersions = versions.Count;
if (versions.Count == 1)
{
return;
}
Thread.Sleep(500);
}
Logger.Info(String.Format("Waited for schema agreement, still {0} schema versions in the cluster.", totalVersions));
}
catch (Exception ex)
{
//Exceptions are not fatal
Logger.Error("There was an exception while trying to retrieve schema versions", ex);
}
}
private Cluster(IEnumerable <IPEndPoint> contactPoints, Configuration configuration)
{
Configuration = configuration;
_metadata = new Metadata(configuration);
foreach (var ep in contactPoints)
{
_metadata.AddHost(ep);
}
var protocolVersion = _maxProtocolVersion;
if (Configuration.ProtocolOptions.MaxProtocolVersionValue != null &&
Configuration.ProtocolOptions.MaxProtocolVersionValue.Value.IsSupported())
{
protocolVersion = Configuration.ProtocolOptions.MaxProtocolVersionValue.Value;
}
_controlConnection = new ControlConnection(protocolVersion, Configuration, _metadata);
_metadata.ControlConnection = _controlConnection;
_serializer = _controlConnection.Serializer;
}
private Cluster(IEnumerable <IPEndPoint> contactPoints, Configuration configuration)
{
_configuration = configuration;
_metadata = new Metadata(configuration.Policies.ReconnectionPolicy);
var controlpolicies = new Policies(
_configuration.Policies.LoadBalancingPolicy,
new ExponentialReconnectionPolicy(2 * 1000, 5 * 60 * 1000),
Policies.DefaultRetryPolicy);
foreach (IPEndPoint ep in contactPoints)
{
Metadata.AddHost(ep);
}
//Use 1 connection per host
//The connection will be reused, it wont create a connection per host.
var controlPoolingOptions = new PoolingOptions()
.SetCoreConnectionsPerHost(HostDistance.Local, 1)
.SetMaxConnectionsPerHost(HostDistance.Local, 1)
.SetMinSimultaneousRequestsPerConnectionTreshold(HostDistance.Local, 0)
.SetMaxSimultaneousRequestsPerConnectionTreshold(HostDistance.Local, 127);
var controlConnection = new ControlConnection(
this,
controlpolicies,
new ProtocolOptions(_configuration.ProtocolOptions.Port, configuration.ProtocolOptions.SslOptions),
controlPoolingOptions,
_configuration.SocketOptions,
new ClientOptions(true, _configuration.ClientOptions.QueryAbortTimeout, null),
_configuration.AuthProvider,
_configuration.AuthInfoProvider,
_configuration.AddressTranslator);
_metadata.SetupControlConnection(controlConnection);
_binaryProtocolVersion = controlConnection.ProtocolVersion;
if (controlConnection.ProtocolVersion > MaxProtocolVersion)
{
_binaryProtocolVersion = MaxProtocolVersion;
}
_logger.Info("Binary protocol version: [" + _binaryProtocolVersion + "]");
}
private Cluster(IEnumerable <IPAddress> contactPoints, Configuration configuration)
{
_contactPoints = contactPoints;
_configuration = configuration;
_metadata = new Metadata(configuration.Policies.ReconnectionPolicy);
var controlpolicies = new Policies(
//new ControlConnectionLoadBalancingPolicy(_configuration.Policies.LoadBalancingPolicy),
_configuration.Policies.LoadBalancingPolicy,
new ExponentialReconnectionPolicy(2 * 1000, 5 * 60 * 1000),
Policies.DefaultRetryPolicy);
foreach (IPAddress ep in _contactPoints)
{
Metadata.AddHost(ep);
}
PoolingOptions poolingOptions = new PoolingOptions()
.SetCoreConnectionsPerHost(HostDistance.Local, 0)
.SetMaxConnectionsPerHost(HostDistance.Local, 1)
.SetMinSimultaneousRequestsPerConnectionTreshold(HostDistance.Local, 0)
.SetMaxSimultaneousRequestsPerConnectionTreshold(HostDistance.Local, 127)
;
var controlConnection = new ControlConnection(this, new List <IPAddress>(), controlpolicies,
new ProtocolOptions(_configuration.ProtocolOptions.Port,
configuration.ProtocolOptions.SslOptions),
poolingOptions, _configuration.SocketOptions,
new ClientOptions(
true,
_configuration.ClientOptions.QueryAbortTimeout, null),
_configuration.AuthProvider,
_configuration.AuthInfoProvider,
2 //lets start from protocol version 2
);
_metadata.SetupControllConnection(controlConnection);
_binaryProtocolVersion = controlConnection.BinaryProtocolVersion;
_logger.Info("Binary protocol version: [" + _binaryProtocolVersion + "]");
}
private Cluster(IEnumerable<IPAddress> contactPoints, Configuration configuration)
{
_contactPoints = contactPoints;
_configuration = configuration;
_metadata = new Metadata(configuration.Policies.ReconnectionPolicy);
var controlpolicies = new Policies(
_configuration.Policies.LoadBalancingPolicy,
new ExponentialReconnectionPolicy(2*1000, 5*60*1000),
Policies.DefaultRetryPolicy);
foreach (IPAddress ep in _contactPoints)
Metadata.AddHost(ep);
//Use 1 connection per host
//The connection will be reused, it wont create a connection per host.
var controlPoolingOptions = new PoolingOptions()
.SetCoreConnectionsPerHost(HostDistance.Local, 1)
.SetMaxConnectionsPerHost(HostDistance.Local, 1)
.SetMinSimultaneousRequestsPerConnectionTreshold(HostDistance.Local, 0)
.SetMaxSimultaneousRequestsPerConnectionTreshold(HostDistance.Local, 127);
var controlConnection = new ControlConnection
(this,
new List<IPAddress>(),
controlpolicies,
new ProtocolOptions(_configuration.ProtocolOptions.Port, configuration.ProtocolOptions.SslOptions),
controlPoolingOptions,
_configuration.SocketOptions,
new ClientOptions(true, _configuration.ClientOptions.QueryAbortTimeout, null),
_configuration.AuthProvider,
_configuration.AuthInfoProvider
);
_metadata.SetupControllConnection(controlConnection);
_binaryProtocolVersion = controlConnection.ProtocolVersion;
_logger.Info("Binary protocol version: [" + _binaryProtocolVersion + "]");
}
/// <summary>
/// Updates the keyspace and token information
/// </summary>
public async Task <bool> RefreshSchemaAsync(string keyspace = null, string table = null)
{
if (keyspace == null)
{
await ControlConnection.ScheduleAllKeyspacesRefreshAsync(true).ConfigureAwait(false);
return(true);
}
await ControlConnection.ScheduleKeyspaceRefreshAsync(keyspace, true).ConfigureAwait(false);
_keyspaces.TryGetValue(keyspace, out var ks);
if (ks == null)
{
return(false);
}
if (table != null)
{
ks.ClearTableMetadata(table);
}
return(true);
}
/// <summary>
/// Creates a new session on this cluster and sets a keyspace to use.
/// </summary>
/// <param name="keyspace"> The name of the keyspace to use for the created <code>Session</code>. </param>
/// <returns>a new session on this cluster set to keyspace:
/// <code>keyspaceName</code>. </returns>
public Session Connect(string keyspace)
{
bool controlConnectionCreated = false;
lock (_controlConnectionGuard)
{
if (_controlConnection == null)
{
controlConnectionCreated = true;
var controlpolicies = new Cassandra.Policies(
_configuration.Policies.LoadBalancingPolicy,
new ExponentialReconnectionPolicy(2 * 1000, 5 * 60 * 1000),
Cassandra.Policies.DefaultRetryPolicy);
_hosts = new Hosts(_configuration.Policies.ReconnectionPolicy);
foreach (var ep in _contactPoints)
_hosts.AddIfNotExistsOrBringUpIfDown(ep);
var poolingOptions = new PoolingOptions().SetCoreConnectionsPerHost(HostDistance.Local, 1);
_controlConnection = new ControlConnection(this, new List<IPAddress>(), controlpolicies,
_configuration.ProtocolOptions,
poolingOptions, _configuration.SocketOptions,
new ClientOptions(
_configuration.ClientOptions.WithoutRowSetBuffering,
_configuration.ClientOptions.QueryAbortTimeout, null,
_configuration.ClientOptions.AsyncCallAbortTimeout),
_configuration.AuthInfoProvider,
_configuration.MetricsEnabled);
_metadata = new Metadata(_hosts, _controlConnection);
_controlConnection.Init();
}
}
var scs = new Session(this, _contactPoints, _configuration.Policies,
_configuration.ProtocolOptions,
_configuration.PoolingOptions, _configuration.SocketOptions,
_configuration.ClientOptions,
_configuration.AuthInfoProvider, _configuration.MetricsEnabled, keyspace, _hosts);
scs.Init();
lock (_connectedSessions)
_connectedSessions.Add(scs);
_logger.Info("Session connected!");
if (controlConnectionCreated)
RefreshSchema();
return scs;
}
internal Metadata(Hosts hosts, ControlConnection controlConnection)
{
this._hosts = hosts;
this._controlConnection = controlConnection;
}
internal Session(Cluster cluster,
IEnumerable<IPAddress> clusterEndpoints,
Policies policies,
ProtocolOptions protocolOptions,
PoolingOptions poolingOptions,
SocketOptions socketOptions,
ClientOptions clientOptions,
IAuthInfoProvider authProvider,
bool metricsEnabled,
string keyspace,
Hosts hosts,ControlConnection controlConnection=null)
{
this._cluster = cluster;
this._protocolOptions = protocolOptions;
this._poolingOptions = poolingOptions;
this._socketOptions = socketOptions;
this._clientOptions = clientOptions;
this._authProvider = authProvider;
this._metricsEnabled = metricsEnabled;
this._policies = policies ?? Policies.DefaultPolicies;
_hosts = hosts ;
this._controlConnection = controlConnection;
foreach (var ep in clusterEndpoints)
_hosts.AddIfNotExistsOrBringUpIfDown(ep, this._policies.ReconnectionPolicy);
this._policies.LoadBalancingPolicy.Initialize(_cluster);
_keyspace = keyspace ?? clientOptions.DefaultKeyspace;
}
internal void SetupControllConnection(ControlConnection controlConnection)
{
this._controlConnection = controlConnection;
_controlConnection.Init();
}
internal void SetupControllConnection(ControlConnection controlConnection)
{
this._controlConnection = controlConnection;
_controlConnection.Init();
}
private void _controlConnection_CCEvent(object sender, ControlConnection.CCEventArgs e)
{
List<Session> conccpy;
lock (_connectedSessions)
conccpy = new List<Session>(_connectedSessions);
foreach (var session in conccpy)
{
if (e.What == ControlConnection.CCEventArgs.Kind.Add)
session.OnAddHost(e.IPAddress);
if (e.What == ControlConnection.CCEventArgs.Kind.Remove)
session.OnRemovedHost(e.IPAddress);
if (e.What == ControlConnection.CCEventArgs.Kind.Down)
session.OnDownHost(e.IPAddress);
}
}
private Cluster(IEnumerable<IPAddress> contactPoints, Configuration configuration)
{
this._contactPoints = contactPoints;
this._configuration = configuration;
this._metadata = new Metadata(configuration.Policies.ReconnectionPolicy);
var controlpolicies = new Cassandra.Policies(
_configuration.Policies.LoadBalancingPolicy,
new ExponentialReconnectionPolicy(2 * 1000, 5 * 60 * 1000),
Cassandra.Policies.DefaultRetryPolicy);
foreach (var ep in _contactPoints)
Metadata.AddHost(ep);
var poolingOptions = new PoolingOptions().SetCoreConnectionsPerHost(HostDistance.Local, 1);
var controlConnection = new ControlConnection(this, new List<IPAddress>(), controlpolicies,
new ProtocolOptions(_configuration.ProtocolOptions.Port),
poolingOptions, _configuration.SocketOptions,
new ClientOptions(
true,
_configuration.ClientOptions.QueryAbortTimeout, null,
_configuration.ClientOptions.AsyncCallAbortTimeout),
_configuration.AuthInfoProvider);
_metadata.SetupControllConnection(controlConnection);
}
private void ControlConnection_CCEvent(object sender, ControlConnection.CCEventArgs e)
{
if (e.What == CCEventArgs.Kind.Add)
_session.OnAddHost(e.IPAddress);
if (e.What == CCEventArgs.Kind.Remove)
_session.OnRemovedHost(e.IPAddress);
if (e.What == CCEventArgs.Kind.Down)
_session.OnDownHost(e.IPAddress);
}
/// <summary>
/// Initializes once (Thread-safe) the control connection and metadata associated with the Cluster instance
/// </summary>
private void Init()
{
if (_initialized)
{
//It was already initialized
return;
}
lock (_initLock)
{
if (_initialized)
{
//It was initialized when waiting on the lock
return;
}
if (_initException != null)
{
//There was an exception that is not possible to recover from
throw _initException;
}
_protocolVersion = (byte) MaxProtocolVersion;
if (Configuration.ProtocolOptions.MaxProtocolVersion != null &&
Configuration.ProtocolOptions.MaxProtocolVersion < MaxProtocolVersion
)
{
_protocolVersion = Configuration.ProtocolOptions.MaxProtocolVersion.Value;
}
_controlConnection = new ControlConnection(_protocolVersion, Configuration, _metadata);
_metadata.ControlConnection = _controlConnection;
try
{
_controlConnection.Init();
_protocolVersion = _controlConnection.ProtocolVersion;
//Initialize policies
Configuration.Policies.LoadBalancingPolicy.Initialize(this);
Configuration.Policies.SpeculativeExecutionPolicy.Initialize(this);
}
catch (NoHostAvailableException)
{
//No host available now, maybe later it can recover from
throw;
}
catch (Exception ex)
{
//There was an error that the driver is not able to recover from
//Store the exception for the following times
_initException = ex;
//Throw the actual exception for the first time
throw;
}
Configuration.Timer = new HashedWheelTimer();
_logger.Info("Cluster Connected using binary protocol version: [" + _protocolVersion + "]");
_initialized = true;
_metadata.Hosts.Added += OnHostAdded;
_metadata.Hosts.Removed += OnHostRemoved;
}
}
internal Metadata(Hosts hosts, ControlConnection controlConnection)
{
this._hosts = hosts;
this._controlConnection = controlConnection;
}
/// <summary>
/// Shutdown this cluster instance. This closes all connections from all the
/// sessions of this <code>* Cluster</code> instance and reclaim all resources
/// used by it. <p> This method has no effect if the cluster was already shutdown.</p>
/// </summary>
public void Shutdown()
{
List<Session> conccpy;
lock (_connectedSessions)
{
conccpy = new List<Session>(_connectedSessions);
_connectedSessions = new List<Session>();
}
foreach (var ses in conccpy)
{
ses.Dispose();
}
lock (_controlConnectionGuard)
{
if (_controlConnection != null)
{
string cluster_name = this.Metadata.GetClusterName();
try
{
Monitor.Exit(_controlConnectionGuard);
_controlConnection.Dispose();
}
finally
{
Monitor.Enter(_controlConnectionGuard);
_controlConnection = null;
_logger.Info("Cluster [" + cluster_name + "] has been shut down.");
}
}
}
}
/// <summary>
/// Initializes once (Thread-safe) the control connection and metadata associated with the Cluster instance
/// </summary>
private void Init()
{
if (_initialized)
{
//It was already initialized
return;
}
lock (_initLock)
{
if (_initialized)
{
//It was initialized when waiting on the lock
return;
}
if (_initException != null)
{
//There was an exception that is not possible to recover from
throw _initException;
}
var protocolVersion = (byte) MaxProtocolVersion;
if (Configuration.ProtocolOptions.MaxProtocolVersion != null &&
Configuration.ProtocolOptions.MaxProtocolVersion < MaxProtocolVersion
)
{
protocolVersion = Configuration.ProtocolOptions.MaxProtocolVersion.Value;
}
//create the buffer pool with 16KB for small buffers and 256Kb for large buffers.
Configuration.BufferPool = new RecyclableMemoryStreamManager(16 * 1024, 256 * 1024, ProtocolOptions.MaximumFrameLength);
_controlConnection = new ControlConnection(protocolVersion, Configuration, _metadata);
_metadata.ControlConnection = _controlConnection;
try
{
_controlConnection.Init();
_serializer = _controlConnection.Serializer;
//Initialize policies
Configuration.Policies.LoadBalancingPolicy.Initialize(this);
Configuration.Policies.SpeculativeExecutionPolicy.Initialize(this);
}
catch (NoHostAvailableException)
{
//No host available now, maybe later it can recover from
throw;
}
catch (Exception ex)
{
//There was an error that the driver is not able to recover from
//Store the exception for the following times
_initException = ex;
//Throw the actual exception for the first time
throw;
}
Configuration.Timer = new HashedWheelTimer();
_logger.Info("Cluster Connected using binary protocol version: [" + _serializer.ProtocolVersion + "]");
_initialized = true;
_metadata.Hosts.Added += OnHostAdded;
_metadata.Hosts.Removed += OnHostRemoved;
}
}
