public void TokenAware_TargetPartition_NoHops()
{
// Setup
PolicyTestTools policyTestTools = new PolicyTestTools();
ITestCluster testCluster = TestClusterManager.CreateNew(3);
testCluster.Builder = Cluster.Builder().WithLoadBalancingPolicy(new TokenAwarePolicy(new RoundRobinPolicy()));
testCluster.InitClient();
// Test
policyTestTools.TableName = TestUtils.GetUniqueTableName();
policyTestTools.CreateSchema(testCluster.Session, 1);
var traces = new List <QueryTrace>();
for (var i = -10; i < 10; i++)
{
var partitionKey = BitConverter.GetBytes(i).Reverse().ToArray();
var statement = new SimpleStatement(String.Format("INSERT INTO " + policyTestTools.TableName + " (k, i) VALUES ({0}, {0})", i))
.SetRoutingKey(new RoutingKey()
{
RawRoutingKey = partitionKey
})
.EnableTracing();
var rs = testCluster.Session.Execute(statement);
traces.Add(rs.Info.QueryTrace);
}
//Check that there weren't any hops
foreach (var t in traces)
{
//The coordinator must be the only one executing the query
Assert.True(t.Events.All(e => e.Source.ToString() == t.Coordinator.ToString()), "There were trace events from another host for coordinator " + t.Coordinator);
}
}
public void Should_Remove_Decommissioned_Node()
{
_testCluster = TestClusterManager.CreateNew(2);
using (var cluster = Cluster.Builder().AddContactPoint(_testCluster.InitialContactPoint).Build())
{
var session = cluster.Connect();
Assert.AreEqual(2, cluster.AllHosts().Count);
_testCluster.DecommissionNode(2);
Trace.TraceInformation("Node decommissioned");
Thread.Sleep(10000);
var decommisionedNode = _testCluster.ClusterIpPrefix + 2;
Assert.False(TestHelper.TryConnect(decommisionedNode), "Removed node should not accept connections");
//New node should be part of the metadata
Assert.AreEqual(1, cluster.AllHosts().Count);
var queried = false;
for (var i = 0; i < 10; i++)
{
var rs = session.Execute("SELECT key FROM system.local");
if (rs.Info.QueriedHost.Address.ToString() == decommisionedNode)
{
queried = true;
break;
}
}
Assert.False(queried, "Removed node should be queried");
}
}
public virtual void OneTimeSetUp()
{
if (_reuse && _reusableInstance != null && ReferenceEquals(_reusableInstance, TestClusterManager.LastInstance))
{
Trace.WriteLine("Reusing single node ccm instance");
TestCluster = _reusableInstance;
}
else
{
TestCluster = TestClusterManager.CreateNew(AmountOfNodes);
if (_reuse)
{
_reusableInstance = TestCluster;
}
else
{
_reusableInstance = null;
}
}
if (CreateSession)
{
CreateCommonSession();
if (SetupQueries != null)
{
ExecuteSetupQueries();
}
}
}
public void Reconnection_Attempts_Are_Made_In_The_Background()
{
var testCluster = TestClusterManager.CreateNew(2);
using (var cluster = Cluster.Builder()
.AddContactPoint(testCluster.InitialContactPoint)
.WithPoolingOptions(
new PoolingOptions()
.SetCoreConnectionsPerHost(HostDistance.Local, 2)
.SetHeartBeatInterval(0))
.WithReconnectionPolicy(new ConstantReconnectionPolicy(2000))
.Build())
{
var session = (Session)cluster.Connect();
TestHelper.Invoke(() => session.Execute("SELECT * FROM system.local"), 10);
var host = cluster.AllHosts().First(h => TestHelper.GetLastAddressByte(h) == 2);
// Check that the control connection is connected to another host
Assert.AreNotEqual(cluster.Metadata.ControlConnection.Address, host.Address);
Assert.True(host.IsUp);
Trace.TraceInformation("Setting host #2 as down");
host.SetDown();
Assert.False(host.IsUp);
Trace.TraceInformation("Waiting for 5 seconds");
Thread.Sleep(5000);
Assert.True(host.IsUp);
}
}
public void PreparedStatement_Is_Usable_After_Node_Restart_When_Connecting_Providing_A_Keyspace()
{
var testCluster = TestClusterManager.CreateNew();
using (var cluster = Cluster.Builder().AddContactPoint(testCluster.InitialContactPoint)
.WithReconnectionPolicy(new ConstantReconnectionPolicy(500)).Build())
{
// Connect using a keyspace
var session = cluster.Connect("system");
var ps = session.Prepare("SELECT key FROM local");
var host = cluster.AllHosts().First();
var row = session.Execute(ps.Bind()).First();
Assert.NotNull(row.GetValue <string>("key"));
// Stop the node
testCluster.Stop(1);
TestHelper.WaitUntil(() => !host.IsUp, 500, 40);
Assert.False(host.IsUp);
// Restart the node
testCluster.Start(1);
TestHelper.WaitUntil(() => host.IsUp, 500, 40);
Assert.True(host.IsUp);
// The same prepared statement should be valid
row = session.Execute(ps.Bind()).First();
Assert.NotNull(row.GetValue <string>("key"));
}
}
public void TokenMap_Should_RebuildTokenMap_When_NodeIsBootstrapped(bool metadataSync)
{
TestCluster = TestClusterManager.CreateNew(2, new TestClusterOptions {
UseVNodes = true
});
var keyspaceName = TestUtils.GetUniqueKeyspaceName().ToLower();
ClusterObj = Cluster.Builder()
.AddContactPoint(TestCluster.InitialContactPoint)
.WithMetadataSyncOptions(new MetadataSyncOptions().SetMetadataSyncEnabled(metadataSync))
.Build();
var session = ClusterObj.Connect();
var createKeyspaceCql = $"CREATE KEYSPACE {keyspaceName} WITH replication = {{'class': 'SimpleStrategy', 'replication_factor' : 3}}";
session.Execute(createKeyspaceCql);
TestUtils.WaitForSchemaAgreement(ClusterObj);
session.ChangeKeyspace(keyspaceName);
var replicas = ClusterObj.Metadata.GetReplicas(keyspaceName, Encoding.UTF8.GetBytes("123"));
Assert.AreEqual(metadataSync ? 2 : 1, replicas.Count);
Assert.AreEqual(2, ClusterObj.Metadata.Hosts.Count);
var oldTokenMap = ClusterObj.Metadata.TokenToReplicasMap;
this.TestCluster.BootstrapNode(3);
TestHelper.RetryAssert(() =>
{
Assert.AreEqual(3, ClusterObj.Metadata.Hosts.Count);
replicas = ClusterObj.Metadata.GetReplicas(keyspaceName, Encoding.UTF8.GetBytes("123"));
Assert.AreEqual(metadataSync ? 3 : 1, replicas.Count);
Assert.IsFalse(object.ReferenceEquals(ClusterObj.Metadata.TokenToReplicasMap, oldTokenMap));
}, 100, 150);
}
public void SetupFixture()
{
if (TestClusterManager.CheckCassandraVersion(false, Version.Parse("2.2"), Comparison.LessThan))
{
Assert.Ignore("Requires Cassandra version >= 2.2");
return;
}
Diagnostics.CassandraTraceSwitch.Level = TraceLevel.Info;
_testCluster = TestClusterManager.CreateNew(1, new TestClusterOptions
{
CassandraYaml = new[]
{
"batch_size_warn_threshold_in_kb:5",
"batch_size_fail_threshold_in_kb:50"
},
//Using a mirroring handler, the server will reply providing the same payload that was sent
JvmArgs = new[] { "-Dcassandra.custom_query_handler_class=org.apache.cassandra.cql3.CustomPayloadMirroringQueryHandler" }
});
_testCluster.InitClient();
Session = _testCluster.Session;
Session.Execute(string.Format(TestUtils.CreateKeyspaceSimpleFormat, Keyspace, 1));
Session.Execute(string.Format(TestUtils.CreateTableSimpleFormat, Table));
}
public void Should_Add_And_Query_Newly_Bootstrapped_Node()
{
_testCluster = TestClusterManager.CreateNew();
using (var cluster = Cluster.Builder().AddContactPoint(_testCluster.InitialContactPoint).Build())
{
var session = cluster.Connect();
Assert.AreEqual(1, cluster.AllHosts().Count);
_testCluster.BootstrapNode(2);
var queried = false;
Trace.TraceInformation("Node bootstrapped");
Thread.Sleep(10000);
var newNodeAddress = _testCluster.ClusterIpPrefix + 2;
Assert.True(TestHelper.TryConnect(newNodeAddress), "New node does not accept connections");
//New node should be part of the metadata
Assert.AreEqual(2, cluster.AllHosts().Count);
for (var i = 0; i < 10; i++)
{
var rs = session.Execute("SELECT key FROM system.local");
if (rs.Info.QueriedHost.Address.ToString() == newNodeAddress)
{
queried = true;
break;
}
}
Assert.True(queried, "Newly bootstrapped node should be queried");
}
}
public async Task Should_Remove_Decommissioned_Node(bool asyncConnect)
{
_testCluster = TestClusterManager.CreateNew(2);
var cluster = Cluster.Builder().AddContactPoint(_testCluster.InitialContactPoint).Build();
await Connect(cluster, asyncConnect, session =>
{
Assert.AreEqual(2, cluster.AllHosts().Count);
_testCluster.DecommissionNode(2);
Trace.TraceInformation("Node decommissioned");
Thread.Sleep(10000);
var decommisionedNode = _testCluster.ClusterIpPrefix + 2;
Assert.False(TestUtils.IsNodeReachable(IPAddress.Parse(decommisionedNode)));
//New node should be part of the metadata
Assert.AreEqual(1, cluster.AllHosts().Count);
var queried = false;
for (var i = 0; i < 10; i++)
{
var rs = session.Execute("SELECT key FROM system.local");
if (rs.Info.QueriedHost.Address.ToString() == decommisionedNode)
{
queried = true;
break;
}
}
Assert.False(queried, "Removed node should be queried");
}).ConfigureAwait(false);
}
public void Should_Not_Leak_Connections_Test()
{
var testCluster = TestClusterManager.CreateNew();
var socketOptions = new SocketOptions().SetReadTimeoutMillis(1).SetConnectTimeoutMillis(1);
var builder = Cluster.Builder()
.AddContactPoint(testCluster.InitialContactPoint)
.WithSocketOptions(socketOptions);
testCluster.PauseNode(1);
const int length = 1000;
using (var cluster = builder.Build())
{
decimal initialLength = GC.GetTotalMemory(true);
for (var i = 0; i < length; i++)
{
var ex = Assert.Throws <NoHostAvailableException>(() => cluster.Connect());
Assert.AreEqual(1, ex.Errors.Count);
}
GC.Collect();
Thread.Sleep(1000);
testCluster.ResumeNode(1);
Assert.Less(GC.GetTotalMemory(true) / initialLength, 1.3M,
"Should not exceed a 30% (1.3) more than was previously allocated");
}
}
public void TokenAware_TargetWrongPartition_HopsOccur()
{
// Setup
PolicyTestTools policyTestTools = new PolicyTestTools();
ITestCluster testCluster = TestClusterManager.CreateNew(3);
testCluster.Builder = Cluster.Builder().WithLoadBalancingPolicy(new TokenAwarePolicy(new RoundRobinPolicy()));
testCluster.InitClient();
var session = testCluster.Session;
policyTestTools.TableName = TestUtils.GetUniqueTableName();
policyTestTools.CreateSchema(session, 1);
var traces = new List <QueryTrace>();
for (var i = 1; i < 10; i++)
{
//The partition key is wrongly calculated
var statement = new SimpleStatement(String.Format("INSERT INTO " + policyTestTools.TableName + " (k, i) VALUES ({0}, {0})", i))
.SetRoutingKey(new RoutingKey()
{
RawRoutingKey = new byte[] { 0, 0, 0, 0 }
})
.EnableTracing();
var rs = session.Execute(statement);
traces.Add(rs.Info.QueryTrace);
}
//Check that there were hops
var hopsPerQuery = traces.Select(t => t.Events.Any(e => e.Source.ToString() == t.Coordinator.ToString()));
Assert.True(hopsPerQuery.Any(v => v));
}
public void ExceptionsOnPartialTrust()
{
var testCluster = TestClusterManager.CreateNew();
var appDomain = CreatePartialTrustDomain();
appDomain.DoCallBack(() => PreserveStackTraceOnConnectAndAssert(testCluster.InitialContactPoint));
}
public async Task Should_Add_And_Query_Newly_Bootstrapped_Node(bool asyncConnect)
{
_testCluster = TestClusterManager.CreateNew();
var cluster = Cluster.Builder().AddContactPoint(_testCluster.InitialContactPoint).Build();
await Connect(cluster, asyncConnect, session =>
{
Assert.AreEqual(1, cluster.AllHosts().Count);
_testCluster.BootstrapNode(2);
var queried = false;
Trace.TraceInformation("Node bootstrapped");
Thread.Sleep(10000);
var newNodeAddress = _testCluster.ClusterIpPrefix + 2;
Assert.True(TestUtils.IsNodeReachable(IPAddress.Parse(newNodeAddress)));
//New node should be part of the metadata
Assert.AreEqual(2, cluster.AllHosts().Count);
for (var i = 0; i < 10; i++)
{
var rs = session.Execute("SELECT key FROM system.local");
if (rs.Info.QueriedHost.Address.ToString() == newNodeAddress)
{
queried = true;
break;
}
}
Assert.True(queried, "Newly bootstrapped node should be queried");
});
}
public void TokenAware_BindInt_NoHops()
{
// Setup
PolicyTestTools policyTestTools = new PolicyTestTools();
ITestCluster testCluster = TestClusterManager.CreateNew(3);
testCluster.Builder = Cluster.Builder().WithLoadBalancingPolicy(new TokenAwarePolicy(new RoundRobinPolicy()));
testCluster.InitClient();
// Test
var session = testCluster.Session;
policyTestTools.TableName = TestUtils.GetUniqueTableName();
policyTestTools.CreateSchema(session, 1);
var traces = new List <QueryTrace>();
var pstmt = session.Prepare("INSERT INTO " + policyTestTools.TableName + " (k, i) VALUES (?, ?)");
for (var i = (int)short.MinValue; i < short.MinValue + 40; i++)
{
var statement = pstmt
.Bind(i, i)
.EnableTracing();
var rs = session.Execute(statement);
traces.Add(rs.Info.QueryTrace);
}
//Check that there weren't any hops
foreach (var t in traces)
{
//The coordinator must be the only one executing the query
Assert.True(t.Events.All(e => e.Source.ToString() == t.Coordinator.ToString()), "There were trace events from another host for coordinator " + t.Coordinator);
}
}
public void TokenAware_Prepared_Composite_NoHops()
{
// Setup
PolicyTestTools policyTestTools = new PolicyTestTools();
ITestCluster testCluster = TestClusterManager.CreateNew(3);
testCluster.Builder = Cluster.Builder().WithLoadBalancingPolicy(new TokenAwarePolicy(new RoundRobinPolicy()));
testCluster.InitClient();
// Test
var session = testCluster.Session;
policyTestTools.CreateSchema(session);
policyTestTools.TableName = TestUtils.GetUniqueTableName();
session.Execute(String.Format("CREATE TABLE {0} (k1 text, k2 int, i int, PRIMARY KEY ((k1, k2)))", policyTestTools.TableName));
Thread.Sleep(1000);
var ps = session.Prepare(String.Format("INSERT INTO {0} (k1, k2, i) VALUES (?, ?, ?)", policyTestTools.TableName));
var traces = new List <QueryTrace>();
for (var i = 0; i < 10; i++)
{
var statement = ps.Bind(i.ToString(), i, i).EnableTracing();
//Routing key is calculated by the driver
Assert.NotNull(statement.RoutingKey);
var rs = session.Execute(statement);
traces.Add(rs.Info.QueryTrace);
}
//Check that there weren't any hops
foreach (var t in traces)
{
//The coordinator must be the only one executing the query
Assert.True(t.Events.All(e => e.Source.ToString() == t.Coordinator.ToString()), "There were trace events from another host for coordinator " + t.Coordinator);
}
}
private ITestCluster GetTestCcmClusterForAuthTests()
{
var testCluster = TestClusterManager.CreateNew(1, null, false);
testCluster.UpdateConfig("authenticator: PasswordAuthenticator");
testCluster.Start(new[] { "-Dcassandra.superuser_setup_delay_ms=0" });
return(testCluster);
}
private ITestCluster GetTestCcmClusterForAuthTests()
{
var testCluster = TestClusterManager.CreateNew(1, null, false);
testCluster.UpdateConfig("authenticator: PasswordAuthenticator");
testCluster.Start();
return(testCluster);
}
public void OneTimeSetUp()
{
_testCluster = TestClusterManager.CreateNew(1, new TestClusterOptions
{
Workloads = new[] { "graph", "spark" }
});
Trace.TraceInformation("Waiting additional time for test Cluster to be ready");
Thread.Sleep(20000);
}
private ITestCluster GetTestCcmClusterForAuthTests()
{
return
(TestClusterManager.CreateNew(1, new TestClusterOptions
{
DseYaml = new[] { "authentication_options.default_scheme: internal", "authentication_options.enabled: true" },
CassandraYaml = new[] { "authenticator: com.datastax.bdp.cassandra.auth.DseAuthenticator" },
JvmArgs = new[] { "-Dcassandra.superuser_setup_delay_ms=0" }
}));
}
protected virtual void TestFixtureSetUp()
{
TestCluster = TestClusterManager.CreateNew(AmountOfNodes);
if (CreateSession)
{
Cluster = Cluster.Builder().AddContactPoint(TestCluster.InitialContactPoint).Build();
Session = (Session)Cluster.Connect();
Session.CreateKeyspace(KeyspaceName, null, false);
Session.ChangeKeyspace(KeyspaceName);
}
}
public void OneTimeSetUp()
{
TestClusterManager.CreateNew(1, new TestClusterOptions {
Workloads = new[] { "graph" }
});
CreateClassicGraph(TestClusterManager.InitialContactPoint, GraphTests.GraphName);
_cluster = ClusterBuilder()
.AddContactPoint(TestClusterManager.InitialContactPoint)
.WithGraphOptions(new GraphOptions().SetName(GraphTests.GraphName))
.Build();
_session = _cluster.Connect();
}
private ITestCluster GetTestCcmClusterForAuthTests()
{
var testCluster = TestClusterManager.CreateNew(1, null, false);
testCluster.UpdateConfig("authenticator:com.datastax.bdp.cassandra.auth.DseAuthenticator");
testCluster.UpdateDseConfig(
"authentication_options.enabled:true",
"authentication_options.default_scheme:internal",
"authentication_options.transitional_mode:normal");
testCluster.Start(new[] { "-Dcassandra.superuser_setup_delay_ms=0" });
return(testCluster);
}
public void Reconnection_Attempted_Multiple_Times()
{
var testCluster = TestClusterManager.CreateNew();
using (var cluster = Cluster.Builder()
.AddContactPoint(testCluster.InitialContactPoint)
.WithPoolingOptions(
new PoolingOptions()
.SetCoreConnectionsPerHost(HostDistance.Local, 2)
.SetHeartBeatInterval(0))
.WithReconnectionPolicy(new ConstantReconnectionPolicy(2000))
.Build())
{
var session = (Session)cluster.Connect();
TestHelper.Invoke(() => session.Execute("SELECT * FROM system.local"), 10);
//Another session to have multiple pools
var dummySession = cluster.Connect();
TestHelper.Invoke(() => dummySession.Execute("SELECT * FROM system.local"), 10);
var host = cluster.AllHosts().First();
var upCounter = 0;
var downCounter = 0;
cluster.Metadata.HostsEvent += (sender, e) =>
{
if (e.What == HostsEventArgs.Kind.Up)
{
Interlocked.Increment(ref upCounter);
return;
}
Interlocked.Increment(ref downCounter);
};
Assert.True(host.IsUp);
Trace.TraceInformation("Stopping node");
testCluster.Stop(1);
// Make sure the node is considered down
Assert.Throws <NoHostAvailableException>(() => session.Execute("SELECT * FROM system.local"));
Assert.False(host.IsUp);
Assert.AreEqual(1, Volatile.Read(ref downCounter));
Assert.AreEqual(0, Volatile.Read(ref upCounter));
Trace.TraceInformation("Waiting for 15 seconds");
Thread.Sleep(15000);
Assert.False(host.IsUp);
Trace.TraceInformation("Restarting node");
testCluster.Start(1);
Trace.TraceInformation("Waiting up to 20s");
var attempts = TestHelper.WaitUntil(() => host.IsUp, 1000, 20);
Trace.TraceInformation("Waited {0}s", attempts);
Assert.True(host.IsUp);
Assert.AreEqual(1, Volatile.Read(ref downCounter));
Assert.AreEqual(1, Volatile.Read(ref upCounter));
}
}
protected virtual void TestFixtureSetUp()
{
TestCluster = TestClusterManager.CreateNew(AmountOfNodes);
if (CreateSession)
{
Cluster = Cluster.Builder().AddContactPoint(TestCluster.InitialContactPoint)
.WithQueryTimeout(60000)
.WithSocketOptions(new SocketOptions().SetConnectTimeoutMillis(30000))
.Build();
Session = (Session)Cluster.Connect();
Session.CreateKeyspace(KeyspaceName, null, false);
Session.ChangeKeyspace(KeyspaceName);
}
}
public void TwoSessionsConnectedToSameDcUseSeparatePolicyInstances()
{
var builder = Cluster.Builder();
var testCluster = TestClusterManager.CreateNew();
using (var cluster1 = builder.WithConnectionString(String.Format("Contact Points={0}1", testCluster.ClusterIpPrefix)).Build())
using (var cluster2 = builder.WithConnectionString(String.Format("Contact Points={0}2", testCluster.ClusterIpPrefix)).Build())
{
var session1 = (Session)cluster1.Connect();
var session2 = (Session)cluster2.Connect();
Assert.AreNotSame(session1.Policies.LoadBalancingPolicy, session2.Policies.LoadBalancingPolicy, "Load balancing policy instances should be different");
Assert.AreNotSame(session1.Policies.ReconnectionPolicy, session2.Policies.ReconnectionPolicy, "Reconnection policy instances should be different");
Assert.AreNotSame(session1.Policies.RetryPolicy, session2.Policies.RetryPolicy, "Retry policy instances should be different");
}
}
public void Cluster_Connect_Should_Initialize_Loadbalancing_With_ControlConnection_Address_Set()
{
_testCluster = TestClusterManager.CreateNew(2);
var lbp = new TestLoadBalancingPolicy();
var builder = Cluster.Builder()
.AddContactPoint(_testCluster.InitialContactPoint)
.WithLoadBalancingPolicy(lbp);
using (var cluster = builder.Build())
{
cluster.Connect();
Assert.NotNull(lbp.ControlConnectionHost);
Assert.AreEqual(IPAddress.Parse(_testCluster.InitialContactPoint),
lbp.ControlConnectionHost.Address.Address);
}
}
public Task Cluster_Connect_Should_Initialize_Loadbalancing_With_ControlConnection_Address_Set(bool asyncConnect)
{
_testCluster = TestClusterManager.CreateNew(2);
var lbp = new TestLoadBalancingPolicy();
var cluster = Cluster.Builder()
.AddContactPoint(_testCluster.InitialContactPoint)
.WithLoadBalancingPolicy(lbp)
.Build();
return(Connect(cluster, asyncConnect, session =>
{
Assert.NotNull(lbp.ControlConnectionHost);
Assert.AreEqual(IPAddress.Parse(_testCluster.InitialContactPoint),
lbp.ControlConnectionHost.Address.Address);
}));
}
public virtual void OneTimeSetUp()
{
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;
Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
if (_reuse && _reusableInstance != null &&
ReferenceEquals(_reusableInstance, TestClusterManager.LastInstance) &&
((Options != null && Options.Equals(TestClusterManager.LastOptions)) || (Options == null && TestClusterManager.LastOptions == null)) &&
AmountOfNodes == TestClusterManager.LastAmountOfNodes)
{
Trace.WriteLine("Reusing ccm instance");
TestCluster = _reusableInstance;
}
else
{
TestCluster = TestClusterManager.CreateNew(AmountOfNodes, Options);
if (_reuse)
{
_reusableInstance = TestCluster;
}
else
{
_reusableInstance = null;
}
}
if (CreateSession)
{
Cluster = Cluster.Builder().AddContactPoint(TestCluster.InitialContactPoint)
.WithQueryTimeout(60000)
.WithSocketOptions(new SocketOptions().SetConnectTimeoutMillis(30000))
.Build();
Session = (Session)Cluster.Connect();
Session.CreateKeyspace(KeyspaceName, null, false);
Session.ChangeKeyspace(KeyspaceName);
if (SetupQueries != null)
{
foreach (var query in SetupQueries)
{
Session.Execute(query);
}
}
}
}
public async Task Cluster_Should_Honor_MaxProtocolVersion_Set(bool asyncConnect)
{
_testCluster = TestClusterManager.CreateNew(2);
// Default MaxProtocolVersion
var clusterDefault = Cluster.Builder()
.AddContactPoint(_testCluster.InitialContactPoint)
.Build();
Assert.AreEqual(Cluster.MaxProtocolVersion, clusterDefault.Configuration.ProtocolOptions.MaxProtocolVersion);
// MaxProtocolVersion set
var clusterMax = Cluster.Builder()
.AddContactPoint(_testCluster.InitialContactPoint)
.WithMaxProtocolVersion(3)
.Build();
Assert.AreEqual(3, clusterMax.Configuration.ProtocolOptions.MaxProtocolVersion);
await Connect(clusterMax, asyncConnect, session =>
{
if (CassandraVersion < Version.Parse("2.1"))
{
Assert.AreEqual(2, session.BinaryProtocolVersion);
}
else
{
Assert.AreEqual(3, session.BinaryProtocolVersion);
}
}).ConfigureAwait(false);
// Arbitary MaxProtocolVersion set, will negotiate down upon connect
var clusterNegotiate = Cluster.Builder()
.AddContactPoint(_testCluster.InitialContactPoint)
.WithMaxProtocolVersion(10)
.Build();
Assert.AreEqual(10, clusterNegotiate.Configuration.ProtocolOptions.MaxProtocolVersion);
await Connect(clusterNegotiate, asyncConnect, session =>
{
Assert.LessOrEqual(4, clusterNegotiate.Configuration.ProtocolOptions.MaxProtocolVersion);
}).ConfigureAwait(false);
// ProtocolVersion 0 does not exist
Assert.Throws <ArgumentException>(
() => Cluster.Builder().AddContactPoint("127.0.0.1").WithMaxProtocolVersion((byte)0));
}
public void TokenAware_VNodes_Test()
{
var testCluster = TestClusterManager.CreateNew(3, new TestClusterOptions {
UseVNodes = true
});
var cluster = Cluster.Builder().AddContactPoint(testCluster.InitialContactPoint).Build();
try
{
var session = cluster.Connect();
Assert.AreEqual(256, cluster.AllHosts().First().Tokens.Count());
session.Execute("CREATE KEYSPACE ks1 WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 1}");
Thread.Sleep(3000);
session.ChangeKeyspace("ks1");
session.Execute("CREATE TABLE tbl1 (id uuid primary key)");
Thread.Sleep(3000);
var ps = session.Prepare("INSERT INTO tbl1 (id) VALUES (?)");
var traces = new List <QueryTrace>();
for (var i = 0; i < 10; i++)
{
var id = Guid.NewGuid();
var bound = ps
.Bind(id)
.SetRoutingKey(new RoutingKey()
{
RawRoutingKey = TypeCodec.GuidShuffle(id.ToByteArray())
})
.EnableTracing();
var rs = session.Execute(bound);
traces.Add(rs.Info.QueryTrace);
}
//Check that there weren't any hops
foreach (var t in traces)
{
//The coordinator must be the only one executing the query
Assert.True(t.Events.All(e => e.Source.ToString() == t.Coordinator.ToString()), "There were trace events from another host for coordinator " + t.Coordinator);
}
}
finally
{
cluster.Dispose();
testCluster.Remove();
}
}