public HostConnectionPool(Host host, HostDistance hostDistance, Configuration configuration)
{
Host = host;
Host.Down += OnHostDown;
HostDistance = hostDistance;
Configuration = configuration;
}
public HostConnectionPool(Host host, HostDistance hostDistance, byte protocolVersion, Configuration configuration)
{
this.Host = host;
this.HostDistance = hostDistance;
this.ProtocolVersion = protocolVersion;
this.Configuration = configuration;
}
public long NextExecution(Host lastQueried)
{
if (_executions++ < _maxSpeculativeExecutions)
{
return _delay;
}
return 0L;
}
public HostConnectionPool(Host host, HostDistance distance, Configuration config)
{
_host = host;
_host.Down += OnHostDown;
_host.Up += OnHostUp;
_distance = distance;
_config = config;
_timer = config.Timer;
}
/// <summary>
/// Returns the distance as determined by the child policy.
/// </summary>
public HostDistance Distance(Host host)
{
var lastPreferredHost = _lastPreferredHost;
if (lastPreferredHost != null && host == lastPreferredHost)
{
// Set the last preferred host as local.
// It's somewhat "hacky" but ensures that the pool for the graph analytics host has the appropriate size
return HostDistance.Local;
}
return _childPolicy.Distance(host);
}
public HostConnectionPool(Host host, HostDistance distance, Configuration config, Serializer serializer)
{
_host = host;
_host.CheckedAsDown += OnHostCheckedAsDown;
_host.Down += OnHostDown;
_host.Up += OnHostUp;
_host.Remove += OnHostRemoved;
_distance = distance;
_config = config;
_serializer = serializer;
_timer = config.Timer;
}
/// <summary>
/// Return the HostDistance for the provided host. <p> This policy consider nodes
/// in the local datacenter as <code>Local</code>. For each remote datacenter, it
/// considers a configurable number of hosts as <code>Remote</code> and the rest
/// is <code>Ignored</code>. </p><p> To configure how many host in each remote
/// datacenter is considered <code>Remote</code>, see
/// <link>#DCAwareRoundRobinPolicy(String, int)</link>.</p>
/// </summary>
/// <param name="host"> the host of which to return the distance of. </param>
/// <returns>the HostDistance to <code>host</code>.</returns>
public HostDistance Distance(Host host)
{
string dc = DC(host);
if (dc.Equals(_localDc))
return HostDistance.Local;
int ix = 0;
foreach (var h in _cluster.Metadata.AllHosts())
{
if (h == host)
return ix < _usedHostsPerRemoteDc ? HostDistance.Ignored : HostDistance.Remote;
else if (dc.Equals(DC(h)))
ix++;
}
return HostDistance.Ignored;
}
private void OnHostDown(Host h, long reconnectionDelay)
{
if (HostsEvent != null)
{
HostsEvent(this, new HostsEventArgs { Address = h.Address, What = HostsEventArgs.Kind.Down });
}
}
private void OnHostDown(Host h, DateTimeOffset nextUpTime)
{
if (HostsEvent != null)
{
HostsEvent(this, new HostsEventArgs { Address = h.Address, What = HostsEventArgs.Kind.Down });
}
}
/// <summary>
/// Tries to create the a connection to the cluster
/// </summary>
/// <exception cref="NoHostAvailableException" />
/// <exception cref="DriverInternalError" />
private void Connect(bool firstTime)
{
var triedHosts = new Dictionary<IPEndPoint, Exception>();
IEnumerable<Host> hostIterator = Metadata.Hosts;
if (!firstTime)
{
_logger.Info("Trying to reconnect the ControlConnection");
//Use the load balancing policy to determine which host to use
hostIterator = _config.Policies.LoadBalancingPolicy.NewQueryPlan(null, null);
}
foreach (var host in hostIterator)
{
var address = host.Address;
var c = new Connection(ProtocolVersion, address, _config);
try
{
c.Init();
_connection = c;
_host = host;
return;
}
catch (UnsupportedProtocolVersionException)
{
//Use the protocol version used to parse the response message
var nextVersion = c.ProtocolVersion;
if (nextVersion >= ProtocolVersion)
{
//Processor could reorder instructions in such way that the connection protocol version is not up to date.
nextVersion = (byte)(ProtocolVersion - 1);
}
_logger.Info(String.Format("Unsupported protocol version {0}, trying with version {1}", ProtocolVersion, nextVersion));
ProtocolVersion = nextVersion;
c.Dispose();
if (ProtocolVersion < 1)
{
throw new DriverInternalError("Invalid protocol version");
}
//Retry using the new protocol version
Connect(firstTime);
return;
}
catch (Exception ex)
{
//There was a socket exception or an authentication exception
triedHosts.Add(host.Address, ex);
c.Dispose();
}
}
throw new NoHostAvailableException(triedHosts);
}
private void OnHostDown(Host h, DateTimeOffset nextUpTime)
{
h.Down -= OnHostDown;
_logger.Warning("Host " + h.Address + " used by the ControlConnection DOWN");
Task.Factory.StartNew(() => Refresh(true), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
}
private void OnHostDown(Host h, DateTimeOffset nextTimeUp)
{
//Dispose all current connections
//Connection allows multiple calls to Dispose
var currentPool = _connections;
if (currentPool != null)
{
foreach (var c in currentPool)
{
c.Dispose();
}
}
}
private void OnHostUp(Host host)
{
_isShuttingDown = false;
SetReconnectionTimeout(null);
//The host is back up, we can start creating the pool (if applies)
MaybeCreateFirstConnection();
}
/// <summary>
/// Return the HostDistance for the provided host.
/// </summary>
/// <param name="host"> the host of which to return the distance of. </param>
///
/// <returns>the HostDistance to <code>host</code> as returned by the wrapped
/// policy.</returns>
public HostDistance Distance(Host host)
{
return _childPolicy.Distance(host);
}
private Task<bool> IterateAndConnect(IEnumerator<Host> hostsEnumerator, Dictionary<IPEndPoint, Exception> triedHosts)
{
var available = hostsEnumerator.MoveNext();
if (!available)
{
return TaskHelper.FromException<bool>(new NoHostAvailableException(triedHosts));
}
var host = hostsEnumerator.Current;
var c = new Connection(_serializer, host.Address, _config);
return ((Task) c
.Open())
.ContinueWith(t =>
{
if (t.Status == TaskStatus.RanToCompletion)
{
_connection = c;
_host = host;
_logger.Info("Connection established to {0}", c.Address);
return TaskHelper.ToTask(true);
}
if (t.IsFaulted && t.Exception != null)
{
var ex = t.Exception.InnerException;
if (ex is UnsupportedProtocolVersionException)
{
//Use the protocol version used to parse the response message
var nextVersion = _serializer.ProtocolVersion;
_logger.Info(string.Format("{0}, trying with version {1}", ex.Message, nextVersion));
c.Dispose();
if (ProtocolVersion < 1)
{
throw new DriverInternalError("Invalid protocol version");
}
//Retry using the new protocol version
return Connect(true);
}
//There was a socket exception or an authentication exception
triedHosts.Add(host.Address, ex);
c.Dispose();
return IterateAndConnect(hostsEnumerator, triedHosts);
}
throw new TaskCanceledException("The ControlConnection could not be connected.");
}, TaskContinuationOptions.ExecuteSynchronously)
.Unwrap();
}
private void OnCoreHostAdded(Host h)
{
if (HostAdded != null)
{
HostAdded(h);
}
}
private string GetDatacenter(Host host)
{
var dc = host.Datacenter;
return dc ?? _localDc;
}
public HostDistance Distance(Host host)
{
return _loadBalancingPolicy.Distance(host);
}
internal static void SetCassandraVersion(Host host, Row row)
{
try
{
var releaseVersion = row.GetValue<string>("release_version");
if (releaseVersion != null)
{
host.CassandraVersion = Version.Parse(releaseVersion.Split('-')[0]);
}
}
catch (Exception ex)
{
_logger.Error("There was an error while trying to retrieve the Cassandra version", ex);
}
}
private void OnHostDown(Host h, long reconnectionDelay)
{
h.Down -= OnHostDown;
_logger.Warning("Host {0} used by the ControlConnection DOWN", h.Address);
Task.Factory.StartNew(() => Reconnect(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
}
private void OnHostUp(Host h)
{
if (HostsEvent != null)
{
HostsEvent(h, new HostsEventArgs { Address = h.Address, What = HostsEventArgs.Kind.Up });
}
}
private void OnHostDown(Host h, long delay)
{
Shutdown();
}
private void OnCoreHostRemoved(Host h)
{
if (HostRemoved != null)
{
HostRemoved(h);
}
}
public long NextExecution(Host lastQueried)
{
return 0L;
}
/// <summary>
/// Return the HostDistance for the provided host. <p> This policy consider nodes
/// in the local datacenter as <c>Local</c>. For each remote datacenter, it
/// considers a configurable number of hosts as <c>Remote</c> and the rest
/// is <c>Ignored</c>. </p><p> To configure how many host in each remote
/// datacenter is considered <c>Remote</c>.</p>
/// </summary>
/// <param name="host"> the host of which to return the distance of. </param>
/// <returns>the HostDistance to <c>host</c>.</returns>
public HostDistance Distance(Host host)
{
var dc = GetDatacenter(host);
if (dc == _localDc)
{
return HostDistance.Local;
}
return HostDistance.Remote;
}
/// <summary>
/// Return the HostDistance for the provided host. <p> This policy consider nodes
/// in the local datacenter as <c>Local</c>. For each remote datacenter, it
/// considers a configurable number of hosts as <c>Remote</c> and the rest
/// is <c>Ignored</c>. </p><p> To configure how many host in each remote
/// datacenter is considered <c>Remote</c>, see
/// <link>#DCAwareRoundRobinPolicy(String, int)</link>.</p>
/// </summary>
/// <param name="host"> the host of which to return the distance of. </param>
/// <returns>the HostDistance to <c>host</c>.</returns>
public HostDistance Distance(Host host)
{
string dc = DC(host);
if (dc.Equals(_localDc))
return HostDistance.Local;
int ix = 0;
foreach (var h in _cluster.AllHosts())
{
if (h.Address.Equals(host.Address))
{
if (ix < _usedHostsPerRemoteDc)
return HostDistance.Remote;
else
return HostDistance.Ignored;
}
else if (dc.Equals(DC(h)))
ix++;
}
return HostDistance.Ignored;
}
public bool TryGet(IPAddress endpoint, out Host host)
{
return _hosts.TryGetValue(endpoint, out host);
}
private string DC(Host host)
{
string dc = host.Datacenter;
return dc ?? this._localDc;
}
/// <summary>
/// Gets or creates the connection pool for a given host
/// </summary>
internal HostConnectionPool GetOrCreateConnectionPool(Host host, HostDistance distance)
{
var hostPool = _connectionPool.GetOrAdd(host.Address, address =>
new HostConnectionPool(host, distance, Configuration, _serializer));
return hostPool;
}
/// <summary>
/// Return the HostDistance for the provided host. <p> This policy consider all
/// nodes as local. This is generally the right thing to do in a single
/// datacenter deployment. If you use multiple datacenter, see
/// <link>DCAwareRoundRobinPolicy</link> instead.</p>
/// </summary>
/// <param name="host"> the host of which to return the distance of. </param>
/// <returns>the HostDistance to <c>host</c>.</returns>
public HostDistance Distance(Host host)
{
return HostDistance.Local;
}
