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(); }
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; } }
/// <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; } }