/// <summary>
///
/// </summary>
/// <param name="builder"></param>
internal Connection(Server server, ConnectionBuilder builder)
{
Created = DateTime.Now;
Server = server;
var socket = new TSocket(server.Host, server.Port, server.Timeout * 1000);
switch(builder.ConnectionType)
{
case ConnectionType.Simple:
_transport = socket;
break;
case ConnectionType.Buffered:
_transport = new TBufferedTransport(socket, builder.BufferSize);
break;
case ConnectionType.Framed:
_transport = new TFramedTransport(socket);
break;
}
_protocol = new TBinaryProtocol(_transport);
_client = new Cassandra.Client(_protocol);
}
private static IConnectionProvider CreateProvider(ConnectionBuilder builder)
{
if (builder.Pooling)
return new PooledConnectionProvider(builder);
else
return new NormalConnectionProvider(builder);
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
public PooledConnectionProvider(ConnectionBuilder builder)
: base(builder)
{
PoolSize = builder.PoolSize;
Lifetime = builder.Lifetime;
_maintenanceTimer = new Timer(o => Cleanup(), null, 30000L, 30000L);
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
public NormalConnectionProvider(ConnectionBuilder builder)
: base(builder)
{
if (builder.Servers.Count > 1 && builder.Timeout == 0)
throw new CassandraException("You must specify a timeout when using multiple servers.");
Timeout = builder.Timeout;
}
public void TestMultipleServersWithHostAndMixedPorts()
{
var servers = new ConnectionBuilder("Server=host:123,host2,host3:789;Connection Timeout=5").Servers;
Assert.Equal(3, servers.Count);
foreach (var server in servers)
{
Assert.Equal(5, server.Timeout);
}
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
public PooledConnectionProvider(ConnectionBuilder builder)
: base(builder)
{
MinPoolSize = builder.MinPoolSize;
MaxPoolSize = builder.MaxPoolSize;
ConnectionLifetime = builder.ConnectionLifetime;
_maintenanceTimer = new Timer(o => Cleanup(), null, 30000L, 30000L);
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
public NormalConnectionProvider(ConnectionBuilder builder)
: base(builder)
{
if (builder.Servers.Count > 1 && builder.Timeout == 0)
{
throw new CassandraException("You must specify a timeout when using multiple servers.");
}
Timeout = builder.Timeout;
}
private static IConnectionProvider CreateProvider(ConnectionBuilder builder)
{
if (builder.Pooling)
{
return(new PooledConnectionProvider(builder));
}
else
{
return(new NormalConnectionProvider(builder));
}
}
public void PooledConnectionProvider()
{
// arrange
var expected = typeof(PooledConnectionProvider);
var connectionString = "Keyspace=" + ConfigurationManager.AppSettings["TestKeySpace"] + ";Pooling=True";
// act
var result = new ConnectionBuilder(connectionString);
var actual = ConnectionProviderFactory.Get(result).GetType();
// assert
Assert.Equal(expected, actual);
}
public void PooledConnectionProvider()
{
// arrange
var expected = typeof(PooledConnectionProvider);
var connectionString = "Keyspace=Testing;Pooled=True";
// act
var result = new ConnectionBuilder(connectionString);
var actual = ConnectionProviderFactory.Get(result).GetType();
// assert
Assert.AreEqual(expected, actual);
}
public void PooledConnectionProvider()
{
// arrange
var expected = typeof(PooledConnectionProvider);
var connectionString = "Keyspace=Testing;Pooling=True";
// act
var result = new ConnectionBuilder(connectionString);
var actual = ConnectionProviderFactory.Get(result).GetType();
// assert
Assert.AreEqual(expected, actual);
}
public void PooledConnectionProvider()
{
// arrange
var expected = typeof(PooledConnectionProvider);
var connectionString = "Keyspace=" + ConfigurationManager.AppSettings["TestKeySpace"] + ";Pooling=True";
// act
var result = new ConnectionBuilder(connectionString);
var actual = ConnectionProviderFactory.Get(result).GetType();
// assert
Assert.Equal(expected, actual);
}
public static IConnectionProvider Get(ConnectionBuilder connectionBuilder)
{
lock(Lock)
{
IConnectionProvider provider;
if (!Providers.TryGetValue(connectionBuilder.ConnectionString, out provider))
{
provider = CreateProvider(connectionBuilder);
Providers.Add(connectionBuilder.ConnectionString, provider);
}
return provider;
}
}
public static IConnectionProvider Get(ConnectionBuilder connectionBuilder)
{
using (TimedLock.Lock(_lock))
{
IConnectionProvider provider;
if (!_providers.TryGetValue(connectionBuilder.ConnectionString, out provider))
{
provider = CreateProvider(connectionBuilder);
_providers.Add(connectionBuilder.ConnectionString, provider);
}
return provider;
}
}
public static IConnectionProvider Get(ConnectionBuilder connectionBuilder)
{
lock (_lock)
{
IConnectionProvider provider;
if (!_providers.TryGetValue(connectionBuilder.ConnectionString, out provider))
{
provider = CreateProvider(connectionBuilder);
_providers.Add(connectionBuilder.ConnectionString, provider);
}
return(provider);
}
}
public void Fails_Over()
{
// arrange
var expectedHost = "127.0.0.1";
var expectedPort = Server.DefaultPort;
// act
var result = new ConnectionBuilder(FailoverConnectionString);
var provider = ConnectionProviderFactory.Get(result);
var conn = provider.Open();
var actualHost = conn.Server.Host;
var actualPort = conn.Server.Port;
// assert
Assert.AreEqual(expectedHost, actualHost);
Assert.AreEqual(expectedPort, actualPort);
}
public void Fails_Over()
{
// arrange
var expectedHost = "127.0.0.1";
var expectedPort = Server.DefaultPort;
// act
var result = new ConnectionBuilder(FailoverConnectionString);
var provider = ConnectionProviderFactory.Get(result);
var conn = provider.Open();
var actualHost = conn.Server.Host;
var actualPort = conn.Server.Port;
// assert
Assert.AreEqual(expectedHost, actualHost);
Assert.AreEqual(expectedPort, actualPort);
}
public CassandraDatabaseSetup(bool reset = false, string cqlVersion = CqlVersion.Edge)
{
ConnectionBuilder = new ConnectionBuilder(keyspace: Keyspace, server: Server, cqlVersion: cqlVersion);
DB = new CassandraContext(ConnectionBuilder);
var exists = DB.KeyspaceExists(Keyspace);
Family = DB.GetColumnFamily<AsciiType>("Standard");
SuperFamily = DB.GetColumnFamily<AsciiType, AsciiType>("Super");
UserFamily = DB.GetColumnFamily("Users");
CounterFamily = DB.GetColumnFamily("Counters");
if (exists && !reset)
return;
ResetDatabase();
}
public void Fails_Over()
{
// arrange
var expectedHost = ConfigurationManager.AppSettings["TestServer"];
var expectedPort = Convert.ToInt16(ConfigurationManager.AppSettings["TestPort"]);
// act
var result = new ConnectionBuilder(_failoverConnectionString);
var provider = ConnectionProviderFactory.Get(result);
var conn = provider.Open();
var actualHost = conn.Server.Host;
var actualPort = conn.Server.Port;
// assert
Assert.Equal(expectedHost, actualHost);
Assert.Equal(expectedPort, actualPort);
}
public void Fails_Over()
{
// arrange
var expectedHost = ConfigurationManager.AppSettings["TestServer"];
var expectedPort = Convert.ToInt16(ConfigurationManager.AppSettings["TestPort"]);
// act
var result = new ConnectionBuilder(_failoverConnectionString);
var provider = ConnectionProviderFactory.Get(result);
var conn = provider.Open();
var actualHost = conn.Server.Host;
var actualPort = conn.Server.Port;
// assert
Assert.Equal(expectedHost, actualHost);
Assert.Equal(expectedPort, actualPort);
}
public void NormalServerHostnamesTest()
{
// arrange
IList<Server> expected = new List<Server>();
expected.Add(new Server("test-host-1"));
expected.Add(new Server("test-host-2"));
expected.Add(new Server("test-host-3"));
string connectionString = string.Format("Keyspace={0};Server={1},{2},{3};Pooling=True", ConfigurationManager.AppSettings["TestKeySpace"], expected[0].Host, expected[1].Host, expected[2].Host);
// act
IList<Server> actual = new ConnectionBuilder(connectionString).Servers;
// assert
Assert.Equal(expected.Count, actual.Count);
for (int i = 0; i < expected.Count; i++)
{
Server e = expected[i];
Server a = actual[i];
Assert.Equal(e.Host, a.Host);
}
}
public void NormalServerHostnamesTest()
{
// arrange
IList <Server> expected = new List <Server>();
expected.Add(new Server("test-host-1"));
expected.Add(new Server("test-host-2"));
expected.Add(new Server("test-host-3"));
string connectionString = string.Format("Keyspace={0};Server={1},{2},{3};Pooling=True", ConfigurationManager.AppSettings["TestKeySpace"], expected[0].Host, expected[1].Host, expected[2].Host);
// act
IList <Server> actual = new ConnectionBuilder(connectionString).Servers;
// assert
Assert.Equal(expected.Count, actual.Count);
for (int i = 0; i < expected.Count; i++)
{
Server e = expected[i];
Server a = actual[i];
Assert.Equal(e.Host, a.Host);
}
}
public void Save()
{
string pw = Password;
if (!Password.IsNullOrWhitespace())
Password = ConntectionInfo.Encrypt(Password);
var builder = new ConnectionBuilder(
keyspace: Keyspace,
host: Host,
port: Port,
connectionTimeout: Timeout,
username: Username,
password: Password);
ConntectionInfo.DriverData.SetElementValue(CassandraConnectionInfoKey, builder.ConnectionString);
Password = pw;
}
public static CassandraConnectionInfo Load(IConnectionInfo connectionInfo)
{
XElement xe = connectionInfo.DriverData.Element(CassandraConnectionInfoKey);
if (xe != null)
{
var connectionString = xe.Value;
var builder = new ConnectionBuilder(connectionString);
var info = new CassandraConnectionInfo();
info.ConntectionInfo = connectionInfo;
info.Keyspace = builder.Keyspace;
info.Host = builder.Servers[0].Host;
info.Port = builder.Servers[0].Port;
info.Timeout = builder.Servers[0].Timeout;
info.Username = builder.Username;
info.Password = builder.Password;
return info;
}
return null;
}
public void Save()
{
var builder = new ConnectionBuilder(
keyspace: Keyspace,
host: Host,
port: Port,
connectionTimeout: Timeout,
username: Username,
password: Password);
ConntectionInfo.DriverData.SetElementValue(CassandraConnectionInfoKey, builder.ConnectionString);
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
protected ConnectionProvider(ConnectionBuilder builder)
{
Builder = builder;
Servers = new RoundRobinServerManager(builder);
}
public RoundRobinServerManager(ConnectionBuilder builder)
{
_servers = new List <Server>(builder.Servers);
_serverQueue = new Queue <Server>(_servers);
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
protected ConnectionProvider(ConnectionBuilder builder)
{
Builder = builder;
Servers = new RoundRobinServerManager(builder);
}
public void LeadingAndTralingSpacesOnKeyTest()
{
// arrange
string expectedKeyspace = ConfigurationManager.AppSettings["TestKeySpace"];
IList<Server> expected = new List<Server>();
expected.Add(new Server("test-host-1"));
expected.Add(new Server("test-host-2"));
expected.Add(new Server("test-host-3"));
string connectionString = string.Format(" Keyspace ={0}; Server ={1},{2},{3}; Pooling =True", ConfigurationManager.AppSettings["TestKeySpace"], expected[0].Host, expected[1].Host, expected[2].Host);
// act
ConnectionBuilder result = new ConnectionBuilder(connectionString);
IList<Server> actual = result.Servers;
string actualKeyspace = result.Keyspace;
// assert
Assert.True(result.Pooling);
Assert.Equal(expectedKeyspace, actualKeyspace);
Assert.Equal(expected.Count, actual.Count);
for (int i = 0; i < expected.Count; i++)
{
Server e = expected[i];
Server a = actual[i];
Assert.Equal(e.Host, a.Host);
}
}
public RoundRobinServerManager(ConnectionBuilder builder)
{
_servers = new List<Server>(builder.Servers);
_serverQueue = new Queue<Server>(_servers);
_blackListed = new HashSet<Server>();
}
