/// <inheritdoc/>
public IRiakConnection CreateConnection(IRiakNodeConfiguration nodeConfig, IRiakAuthenticationConfiguration authConfig)
{
// As pointless as this seems, it serves the purpose of decoupling the
// creation of the connections to the node itself. Also means we can
// pull it apart to test it
return(new RiakConnection(nodeConfig, authConfig));
}
public RiakConnection(IRiakNodeConfiguration nodeConfiguration)
{
_restRootUrl = @"{0}://{1}:{2}".Fmt(nodeConfiguration.RestScheme, nodeConfiguration.HostAddress, nodeConfiguration.RestPort);
_socket = new RiakPbcSocket(nodeConfiguration.HostAddress, nodeConfiguration.PbcPort, nodeConfiguration.NetworkReadTimeout,
nodeConfiguration.NetworkWriteTimeout);
_vnodeVclocks = nodeConfiguration.VnodeVclocks;
}
public IRiakConnection CreateConnection(IRiakNodeConfiguration nodeConfiguration)
{
// As pointless as this seems, it serves the purpose of decoupling the
// creation of the connections to the node itself. Also means we can
// pull it apart to test it
return new RiakConnection(nodeConfiguration);
}
public void ConfigurationLoadsDefaults()
{
var fileName = Path.GetTempFileName();
try
{
File.WriteAllText(fileName, Cfg2);
var config = RiakClusterConfiguration.LoadFromConfig("riakConfig", fileName);
Assert.IsTrue(config.UseTtbEncoding);
Assert.AreEqual(3, config.DefaultRetryCount);
Assert.AreEqual(200, (int)config.DefaultRetryWaitTime);
Assert.AreEqual(5000, (int)config.NodePollTime);
Assert.AreEqual(1, config.RiakNodes.Count());
var nodes = config.RiakNodes.ToArray();
IRiakNodeConfiguration node = nodes[0];
Assert.AreEqual("node", node.Name);
Assert.AreEqual("127.0.0.1", node.HostAddress);
Assert.AreEqual(8087, node.PbcPort);
Assert.AreEqual(30, node.PoolSize);
Assert.AreEqual(4000, (int)node.NetworkConnectTimeout);
Assert.AreEqual(4000, (int)node.NetworkReadTimeout);
Assert.AreEqual(4000, (int)node.NetworkWriteTimeout);
Assert.IsTrue(node.UseTtbEncoding);
}
finally
{
File.Delete(fileName);
}
}
public RiakOnTheFlyConnection(IRiakNodeConfiguration nodeConfig, int bufferPoolSize = 20)
{
_nodeConfig = nodeConfig;
_serverUrl = @"{0}://{1}:{2}".Fmt(nodeConfig.RestScheme, nodeConfig.HostAddress, nodeConfig.RestPort);
_pool = new SocketAwaitablePool(nodeConfig.PoolSize);
_bufferManager = new BlockingBufferManager(nodeConfig.BufferSize, bufferPoolSize);
_resources = new BlockingLimitedList<RiakPbcSocket>(bufferPoolSize);
}
public RiakOnTheFlyConnection(
IRiakNodeConfiguration nodeConfig,
IRiakAuthenticationConfiguration authConfig,
IRiakConnectionFactory connFactory)
{
this.nodeConfig = nodeConfig;
this.authConfig = authConfig;
this.connFactory = connFactory;
}
public RiakOnTheFlyConnection(IRiakNodeConfiguration nodeConfig, int bufferPoolSize = 20)
{
_nodeConfig = nodeConfig;
_serverUrl = @"{0}://{1}:{2}".Fmt(nodeConfig.RestScheme, nodeConfig.HostAddress, nodeConfig.RestPort);
_pool = new SocketAwaitablePool(nodeConfig.PoolSize);
_bufferManager = new BlockingBufferManager(nodeConfig.BufferSize, bufferPoolSize);
_resources = new BlockingLimitedList <RiakPbcSocket>(bufferPoolSize);
}
public RiakPbcSocket(IRiakNodeConfiguration nodeConfig, IRiakAuthenticationConfiguration authConfig)
{
server = nodeConfig.HostAddress;
port = nodeConfig.PbcPort;
readTimeout = nodeConfig.NetworkReadTimeout;
writeTimeout = nodeConfig.NetworkWriteTimeout;
connectTimeout = nodeConfig.NetworkConnectTimeout;
securityManager = new RiakSecurityManager(server, authConfig);
checkCertificateRevocation = authConfig.CheckCertificateRevocation;
}
public RiakNode(IRiakNodeConfiguration nodeConfiguration)
{
// 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)
{
_connectionManager = new RiakOnTheFlyConnection(nodeConfiguration);
}
else
{
_connectionManager = new RiakConnectionPool(nodeConfiguration);
}
}
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);
}
}
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 RiakNode(
IRiakNodeConfiguration nodeConfig,
IRiakAuthenticationConfiguration authConfig,
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 (nodeConfig.PoolSize == 0)
{
connections = new RiakOnTheFlyConnection(nodeConfig, authConfig, connectionFactory);
}
else
{
connections = new RiakConnectionPool(nodeConfig, authConfig, connectionFactory);
}
}
public void ConfigurationLoadsProperly()
{
int twoHundredMillis = 200;
int fourSecsAsMillis = 4000;
int fiveSecsAsMillis = 5000;
var fileName = Path.GetTempFileName();
try
{
File.WriteAllText(fileName, Cfg1);
IRiakClusterConfiguration config = RiakClusterConfiguration.LoadFromConfig("riakConfig", fileName);
Assert.IsTrue(config.UseTtbEncoding);
config.DefaultRetryCount.ShouldEqual(3);
config.DefaultRetryWaitTime.ShouldEqual((Timeout)twoHundredMillis);
config.NodePollTime.ShouldEqual((Timeout)fiveSecsAsMillis);
config.RiakNodes.Count().ShouldEqual(2);
var nodes = config.RiakNodes.ToArray();
IRiakNodeConfiguration node1 = nodes[0];
node1.Name.ShouldEqual("node1");
node1.HostAddress.ShouldEqual("host1");
node1.PbcPort.ShouldEqual(8081);
node1.PoolSize.ShouldEqual(5);
Assert.IsTrue(node1.UseTtbEncoding);
Assert.IsTrue(node1.ExternalLoadBalancer);
node1.NetworkConnectTimeout.ShouldEqual((Timeout)fourSecsAsMillis);
node1.NetworkReadTimeout.ShouldEqual((Timeout)fourSecsAsMillis);
node1.NetworkWriteTimeout.ShouldEqual((Timeout)fourSecsAsMillis);
IRiakNodeConfiguration node2 = nodes[1];
node2.Name.ShouldEqual("node2");
node2.HostAddress.ShouldEqual("host2");
node2.PbcPort.ShouldEqual(8081);
node2.PoolSize.ShouldEqual(6);
Assert.IsFalse(node2.UseTtbEncoding);
Assert.IsFalse(node2.ExternalLoadBalancer);
node2.NetworkConnectTimeout.ShouldEqual((Timeout)fiveSecsAsMillis);
node2.NetworkReadTimeout.ShouldEqual((Timeout)fiveSecsAsMillis);
node2.NetworkWriteTimeout.ShouldEqual((Timeout)fiveSecsAsMillis);
}
finally
{
File.Delete(fileName);
}
}
public RiakConnectionPool(IRiakNodeConfiguration nodeConfig)
{
_hostAddress = nodeConfig.HostAddress;
_poolSize = nodeConfig.PoolSize;
_pool = new SocketAwaitablePool(_poolSize);
_bufferSize = nodeConfig.BufferSize;
_restScheme = nodeConfig.RestScheme;
_restPort = nodeConfig.RestPort;
_pbcPort = nodeConfig.PbcPort;
_networkReadTimeout = nodeConfig.NetworkReadTimeout;
_networkWriteTimeout = nodeConfig.NetworkWriteTimeout;
_idleTimeout = nodeConfig.IdleTimeout;
_blockingBufferManager = new BlockingBufferManager(_bufferSize, _poolSize);
_serverUrl = @"{0}://{1}:{2}".Fmt(_restScheme, _hostAddress, _restPort);
Init();
}
public RiakConnectionPool(IRiakNodeConfiguration nodeConfig)
{
_hostAddress = nodeConfig.HostAddress;
_poolSize = nodeConfig.PoolSize;
_pool = new SocketAwaitablePool(_poolSize);
_bufferSize = nodeConfig.BufferSize;
_restScheme = nodeConfig.RestScheme;
_restPort = nodeConfig.RestPort;
_pbcPort = nodeConfig.PbcPort;
_networkReadTimeout = nodeConfig.NetworkReadTimeout;
_networkWriteTimeout = nodeConfig.NetworkWriteTimeout;
_idleTimeout = nodeConfig.IdleTimeout;
_blockingBufferManager = new BlockingBufferManager(_bufferSize, _poolSize);
_serverUrl = @"{0}://{1}:{2}".Fmt(_restScheme, _hostAddress, _restPort);
Init();
}
public void ConfigurationLoadsProperly()
{
int twoHundredMillis = 200;
int fourSecsAsMillis = 4000;
int fiveSecsAsMillis = 5000;
var fileName = Path.GetTempFileName();
try
{
File.WriteAllText(fileName, SampleConfig);
var config = RiakClusterConfiguration.LoadFromConfig("riakConfig", fileName);
config.DefaultRetryCount.ShouldEqual(3);
config.DefaultRetryWaitTime.ShouldEqual((Timeout)twoHundredMillis);
config.NodePollTime.ShouldEqual((Timeout)fiveSecsAsMillis);
config.RiakNodes.Count.ShouldEqual(2);
IRiakNodeConfiguration node1 = config.RiakNodes[0];
node1.Name.ShouldEqual("node1");
node1.HostAddress.ShouldEqual("host1");
node1.PbcPort.ShouldEqual(8081);
node1.PoolSize.ShouldEqual(5);
node1.NetworkConnectTimeout.ShouldEqual((Timeout)fourSecsAsMillis);
node1.NetworkReadTimeout.ShouldEqual((Timeout)fourSecsAsMillis);
node1.NetworkWriteTimeout.ShouldEqual((Timeout)fourSecsAsMillis);
IRiakNodeConfiguration node2 = config.RiakNodes[1];
node2.Name.ShouldEqual("node2");
node2.HostAddress.ShouldEqual("host2");
node2.PbcPort.ShouldEqual(8081);
node2.PoolSize.ShouldEqual(6);
node2.NetworkConnectTimeout.ShouldEqual((Timeout)fiveSecsAsMillis);
node2.NetworkReadTimeout.ShouldEqual((Timeout)fiveSecsAsMillis);
node2.NetworkWriteTimeout.ShouldEqual((Timeout)fiveSecsAsMillis);
}
finally
{
File.Delete(fileName);
}
}
public RiakConnection(IRiakNodeConfiguration nodeConfiguration, IRiakAuthenticationConfiguration authConfiguration)
{
socket = new RiakPbcSocket(nodeConfiguration, authConfiguration);
}
public RiakOnTheFlyConnection(IRiakNodeConfiguration nodeConfig, IRiakConnectionFactory connFactory)
{
_nodeConfig = nodeConfig;
_connFactory = connFactory;
}
/// <inheritdoc/>
void IRiakClusterConfiguration.AddNode(IRiakNodeConfiguration nodeConfiguration)
{
Nodes.Add((RiakNodeConfiguration)nodeConfiguration);
}
public RiakNode(IRiakNodeConfiguration nodeConfiguration, IRiakConnectionFactory connectionFactory)
{
_connections = new RiakConnectionPool(nodeConfiguration, connectionFactory);
}
/// <inheritdoc/>
void IRiakClusterConfiguration.AddNode(IRiakNodeConfiguration nodeConfiguration)
{
Nodes.Add((RiakNodeConfiguration)nodeConfiguration);
}
