public RiakOnTheFlyConnection(
IRiakNodeConfiguration nodeConfig,
IRiakAuthenticationConfiguration authConfig,
IRiakConnectionFactory connFactory)
{
this.nodeConfig = nodeConfig;
this.authConfig = authConfig;
this.connFactory = connFactory;
}
public RiakCluster(IRiakClusterConfiguration clusterConfiguration, IRiakConnectionFactory connectionFactory)
{
_nodePollTime = clusterConfiguration.NodePollTime;
_nodes = clusterConfiguration.RiakNodes.Select(rn => new RiakNode(rn, connectionFactory)).Cast <IRiakNode>().ToList();
_loadBalancer = new RoundRobinStrategy();
_loadBalancer.Initialise(_nodes);
_offlineNodes = new ConcurrentQueue <IRiakNode>();
_defaultRetryCount = clusterConfiguration.DefaultRetryCount;
RetryWaitTime = clusterConfiguration.DefaultRetryWaitTime;
Task.Factory.StartNew(NodeMonitor);
}
public RiakCluster(IRiakClusterConfiguration clusterConfiguration, IRiakConnectionFactory connectionFactory)
{
_nodePollTime = clusterConfiguration.NodePollTime;
_nodes = clusterConfiguration.RiakNodes.Select(rn => new RiakNode(rn, connectionFactory)).Cast <IRiakNode>().ToList();
_loadBalancer = new RoundRobinStrategy();
_loadBalancer.Initialise(_nodes);
_offlineNodes = new ConcurrentQueue <IRiakNode>();
_defaultRetryCount = clusterConfiguration.DefaultRetryCount;
RetryWaitTime = clusterConfiguration.DefaultRetryWaitTime;
// node monitor is now asynchronous, just triggered by timer!
_nodePollTimer = new Timer(state => NodeMonitorCycle(), null, _nodePollTime, Timeout.Infinite);
}
public RiakNode(IRiakNodeConfiguration nodeConfiguration, IRiakConnectionFactory connectionFactory)
{
// assume that if the node has a pool size of 0 then the intent is to have the connections
// made on the fly
if (nodeConfiguration.PoolSize == 0)
{
_connections = new RiakOnTheFlyConnection(nodeConfiguration, connectionFactory);
}
else
{
_connections = new RiakConnectionPool(nodeConfiguration, connectionFactory);
}
}
public RiakConnectionPool(IRiakNodeConfiguration nodeConfig, IRiakConnectionFactory connFactory)
{
var poolSize = nodeConfig.PoolSize;
_allResources = new List <IRiakConnection>();
_resources = new ConcurrentStack <IRiakConnection>();
for (var i = 0; i < poolSize; ++i)
{
var conn = connFactory.CreateConnection(nodeConfig);
_allResources.Add(conn);
_resources.Push(conn);
}
}
public RiakConnectionPool(
IRiakNodeConfiguration nodeConfig,
IRiakAuthenticationConfiguration authConfig,
IRiakConnectionFactory connFactory)
{
int poolSize = nodeConfig.PoolSize;
for (var i = 0; i < poolSize; ++i)
{
var conn = connFactory.CreateConnection(nodeConfig, authConfig);
allResources.Add(conn);
resources.Push(conn);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RiakCluster"/> class.
/// </summary>
/// <param name="clusterConfig">The <see cref="IRiakClusterConfiguration"/> to use for this RiakCluster.</param>
/// <param name="connectionFactory">The <see cref="IRiakConnectionFactory"/> instance to use for this RiakCluster.</param>
/// <exception cref="ArgumentNullException">If <paramref name="clusterConfig" /> contains no node information.</exception>
public RiakCluster(IRiakClusterConfiguration clusterConfig, IRiakConnectionFactory connectionFactory)
{
nodePollTime = clusterConfig.NodePollTime;
defaultRetryCount = clusterConfig.DefaultRetryCount;
RetryWaitTime = clusterConfig.DefaultRetryWaitTime;
nodes = clusterConfig.RiakNodes.Select(rn =>
new RiakNode(rn, clusterConfig.Authentication, connectionFactory)).Cast <IRiakNode>().ToList();
loadBalancer = new RoundRobinStrategy();
loadBalancer.Initialise(nodes);
offlineNodes = new ConcurrentQueue <IRiakNode>();
ct = cts.Token;
monitorTask = Task.Factory.StartNew(NodeMonitor, ct);
}
public RiakNode(
IRiakNodeConfiguration nodeConfig,
IRiakAuthenticationConfiguration authConfig,
IRiakConnectionFactory connectionFactory)
{
externalLoadBalancer = nodeConfig.ExternalLoadBalancer;
// assume that if the node has a pool size of 0 then the intent is to have the connections
// made on the fly
if (nodeConfig.PoolSize == 0)
{
connections = new RiakOnTheFlyConnection(nodeConfig, authConfig, connectionFactory);
}
else
{
connections = new RiakConnectionPool(nodeConfig, authConfig, connectionFactory);
}
}
public RiakNode(IRiakNodeConfiguration nodeConfiguration, IRiakConnectionFactory connectionFactory)
{
_connections = new RiakConnectionPool(nodeConfiguration, connectionFactory);
}
public RiakOnTheFlyConnection(IRiakNodeConfiguration nodeConfig, IRiakConnectionFactory connFactory)
{
_nodeConfig = nodeConfig;
_connFactory = connFactory;
}
public RiakExternalLoadBalancer(IRiakExternalLoadBalancerConfiguration lbConfiguration, IRiakConnectionFactory connectionFactory)
{
_lbConfiguration = lbConfiguration;
_node = new RiakNode(_lbConfiguration.Target, connectionFactory);
}
