public void MaybeCreateCorePool_Fail_To_Grow_To_CoreConnections_Yields_Existing()
{
var mock = new Mock <HostConnectionPool>(Host1, HostDistance.Local, GetConfig());
var testException = new Exception("Dummy exception");
var counter = 0;
mock.Setup(p => p.CreateConnection()).Returns(() => TestHelper.DelayedTask(() =>
{
var i = counter++;
if (i == 0 || i > 2)
{
throw testException;
}
return(new Connection(ProtocolVersion, GetIpEndPoint((byte)counter), GetConfig()));
}, 50 * counter));
var pool = mock.Object;
Assert.DoesNotThrow(() => TaskHelper.WaitToComplete(pool.MaybeCreateCorePool()));
//next attempts creates to create all, still fails
Thread.Sleep(100);
var connections = TaskHelper.WaitToComplete(pool.MaybeCreateCorePool());
//2 valid still
Assert.AreEqual(2, connections.Length);
}
public void MaybeCreateCorePool_Fail_To_Open_Single_Connection_Should_Yield_Valid()
{
var mock = new Mock <HostConnectionPool>(Host1, HostDistance.Local, GetConfig());
var testException = new Exception("Dummy exception");
var counter = 0;
mock.Setup(p => p.CreateConnection()).Returns(() => TestHelper.DelayedTask(() =>
{
if (counter++ == 0)
{
throw testException;
}
return(new Connection(ProtocolVersion, GetIpEndPoint((byte)counter++), GetConfig()));
}));
var pool = mock.Object;
var connections = TaskHelper.WaitToComplete(pool.MaybeCreateCorePool());
//1 or 2 valid connections still
Assert.LessOrEqual(connections.Length, 2);
//next attempts creates all
Thread.Sleep(100);
connections = TaskHelper.WaitToComplete(pool.MaybeCreateCorePool());
//The one recently created
Assert.AreEqual(1, connections.Length);
Thread.Sleep(500);
connections = TaskHelper.WaitToComplete(pool.MaybeCreateCorePool());
//Return all the pool
Assert.AreEqual(3, connections.Length);
}
public void MaybeIncreasePoolSize_Should_Increase_One_At_A_Time_Until_Core_Connections()
{
var mock = GetPoolMock();
mock.Setup(p => p.CreateConnection()).Returns(() => TestHelper.DelayedTask(CreateConnection(), 200));
var pool = mock.Object;
pool.MaybeCreateFirstConnection().Wait(1000);
Assert.AreEqual(1, pool.OpenConnections.Count());
var creatingNew = pool.MaybeIncreasePoolSize(0);
Assert.True(creatingNew);
//No connections added yet
Assert.AreEqual(1, pool.OpenConnections.Count());
Thread.Sleep(500);
Assert.AreEqual(2, pool.OpenConnections.Count());
creatingNew = pool.MaybeIncreasePoolSize(0);
Assert.True(creatingNew);
Thread.Sleep(500);
Assert.AreEqual(3, pool.OpenConnections.Count());
creatingNew = pool.MaybeIncreasePoolSize(0);
Assert.False(creatingNew);
Thread.Sleep(500);
//Still core
Assert.AreEqual(3, pool.OpenConnections.Count());
}
public void EnsureCreate_Parallel_Calls_Should_Yield_First()
{
var mock = GetPoolMock();
var lastByte = 0;
mock.Setup(p => p.DoCreateAndOpen()).Returns(() => TestHelper.DelayedTask(CreateConnection((byte)++lastByte), 100 + (lastByte > 1 ? 10000 : 0)));
var pool = mock.Object;
var creationTasks = new Task <Connection[]> [10];
var counter = -1;
var initialCreate = pool.EnsureCreate();
TestHelper.ParallelInvoke(() =>
{
creationTasks[Interlocked.Increment(ref counter)] = pool.EnsureCreate();
}, 10);
// ReSharper disable once CoVariantArrayConversion
Task.WaitAll(creationTasks);
Assert.AreEqual(1, TaskHelper.WaitToComplete(initialCreate).Length);
foreach (var t in creationTasks)
{
Assert.AreEqual(1, TaskHelper.WaitToComplete(t).Length);
}
Assert.AreEqual(1, lastByte);
}
public async Task EnsureCreate_Can_Handle_Multiple_Concurrent_Calls()
{
var mock = GetPoolMock(null, GetConfig(3, 3));
var creationCounter = 0;
var isCreating = 0;
mock.Setup(p => p.DoCreateAndOpen()).Returns(() =>
{
Interlocked.Increment(ref creationCounter);
Interlocked.Exchange(ref isCreating, 1);
return(TestHelper.DelayedTask(CreateConnection(), 50, () => Interlocked.Exchange(ref isCreating, 0)));
});
var pool = mock.Object;
pool.SetDistance(HostDistance.Local);
Assert.AreEqual(0, pool.OpenConnections);
var tasks = new Task[100];
for (var i = 0; i < 100; i++)
{
tasks[i] = Task.Run(async() => await pool.EnsureCreate());
}
await Task.WhenAll(tasks);
Assert.Greater(pool.OpenConnections, 0);
Assert.LessOrEqual(pool.OpenConnections, 3);
await TestHelper.WaitUntilAsync(() => Volatile.Read(ref creationCounter) == 3, 200, 20);
Assert.AreEqual(3, Volatile.Read(ref creationCounter));
Assert.AreEqual(0, Volatile.Read(ref isCreating));
Assert.AreEqual(3, pool.OpenConnections);
}
public void MaybeIncreasePoolSize_Should_Increase_One_At_A_Time_Until_Max_Connections()
{
var mock = GetPoolMock(null, GetConfig(1, 3));
mock.Setup(p => p.CreateConnection()).Returns(() => TestHelper.DelayedTask(CreateConnection(1, GetConfig(1, 3)), 200));
var pool = mock.Object;
pool.MaybeCreateFirstConnection().Wait(1000);
Assert.AreEqual(1, pool.OpenConnections.Count());
//inflight is low
var creatingNew = pool.MaybeIncreasePoolSize(0);
Assert.False(creatingNew);
Assert.AreEqual(1, pool.OpenConnections.Count());
Thread.Sleep(500);
Assert.AreEqual(1, pool.OpenConnections.Count());
creatingNew = pool.MaybeIncreasePoolSize(128);
Assert.True(creatingNew);
Thread.Sleep(500);
Assert.AreEqual(2, pool.OpenConnections.Count());
creatingNew = pool.MaybeIncreasePoolSize(128);
Assert.True(creatingNew);
Thread.Sleep(500);
Assert.AreEqual(3, pool.OpenConnections.Count());
creatingNew = pool.MaybeIncreasePoolSize(128);
Assert.False(creatingNew);
Thread.Sleep(500);
//Still max
Assert.AreEqual(3, pool.OpenConnections.Count());
}
public void MaybeIncreasePoolSize_Should_Increase_One_At_A_Time_Until_Max_Connections()
{
var mock = new Mock <HostConnectionPool>(Host1, HostDistance.Local, GetConfig(1, 3));
mock.Setup(p => p.CreateConnection()).Returns(() => TestHelper.DelayedTask(new Connection(ProtocolVersion, GetIpEndPoint(), GetConfig(1, 3)), 200));
var pool = mock.Object;
pool.MaybeCreateFirstConnection().Wait(1000);
Assert.AreEqual(1, pool.OpenConnections.Count());
//inflight is low
var creatingNew = pool.MaybeIncreasePoolSize(0);
Assert.False(creatingNew);
Assert.AreEqual(1, pool.OpenConnections.Count());
Thread.Sleep(500);
Assert.AreEqual(1, pool.OpenConnections.Count());
creatingNew = pool.MaybeIncreasePoolSize(128);
Assert.True(creatingNew);
Thread.Sleep(500);
Assert.AreEqual(2, pool.OpenConnections.Count());
creatingNew = pool.MaybeIncreasePoolSize(128);
Assert.True(creatingNew);
Thread.Sleep(500);
Assert.AreEqual(3, pool.OpenConnections.Count());
creatingNew = pool.MaybeIncreasePoolSize(128);
Assert.False(creatingNew);
Thread.Sleep(500);
//Still max
Assert.AreEqual(3, pool.OpenConnections.Count());
}
public async Task EnsureCreate_Should_Increase_One_At_A_Time_Until_Core_Connections()
{
var mock = GetPoolMock(null, GetConfig(3, 3));
var creationCounter = 0;
var isCreating = 0;
mock.Setup(p => p.DoCreateAndOpen()).Returns(() =>
{
Interlocked.Increment(ref creationCounter);
Interlocked.Exchange(ref isCreating, 1);
return(TestHelper.DelayedTask(CreateConnection(), 500, () => Interlocked.Exchange(ref isCreating, 0)));
});
var pool = mock.Object;
pool.SetDistance(HostDistance.Local);
await pool.EnsureCreate();
Assert.AreEqual(1, pool.OpenConnections);
Thread.Sleep(100);
//No connections added yet
Assert.AreEqual(2, Volatile.Read(ref creationCounter));
Assert.AreEqual(1, Volatile.Read(ref isCreating));
Thread.Sleep(500);
Assert.AreEqual(2, pool.OpenConnections);
Assert.AreEqual(3, Volatile.Read(ref creationCounter));
Assert.AreEqual(1, Volatile.Read(ref isCreating));
Thread.Sleep(500);
Assert.AreEqual(3, pool.OpenConnections);
Assert.AreEqual(0, Volatile.Read(ref isCreating));
Assert.AreEqual(3, Volatile.Read(ref creationCounter));
Thread.Sleep(500);
Assert.AreEqual(3, pool.OpenConnections);
Assert.AreEqual(0, Volatile.Read(ref isCreating));
Assert.AreEqual(3, Volatile.Read(ref creationCounter));
}
public void MaybeCreateCorePool_Serial_Calls_Should_Yield_First()
{
var mock = new Mock <HostConnectionPool>(Host1, HostDistance.Local, GetConfig());
var lastByte = 1;
mock.Setup(p => p.CreateConnection()).Returns(() =>
{
var c = new Connection(ProtocolVersion, GetIpEndPoint((byte)lastByte++), GetConfig());
if (lastByte == 2)
{
return(TestHelper.DelayedTask(c, 500));
}
return(TaskHelper.ToTask(c));
});
var pool = mock.Object;
var creationTasks = new Task <Connection[]> [4];
creationTasks[0] = pool.MaybeCreateCorePool();
creationTasks[1] = pool.MaybeCreateCorePool();
creationTasks[2] = pool.MaybeCreateCorePool();
creationTasks[3] = pool.MaybeCreateCorePool();
// ReSharper disable once CoVariantArrayConversion
Task.WaitAll(creationTasks);
Assert.AreEqual(1, TaskHelper.WaitToComplete(creationTasks[0]).Length);
for (var i = 1; i < creationTasks.Length; i++)
{
Assert.AreEqual(1, TaskHelper.WaitToComplete(creationTasks[i]).Length);
}
}
public async Task EnsureCreate_After_Reconnection_Attempt_Waits_Existing()
{
var mock = GetPoolMock(null, GetConfig(2, 2));
var creationCounter = 0;
var isCreating = 0;
mock.Setup(p => p.DoCreateAndOpen()).Returns(() =>
{
Interlocked.Increment(ref creationCounter);
Interlocked.Exchange(ref isCreating, 1);
return(TestHelper.DelayedTask(CreateConnection(), 300, () => Interlocked.Exchange(ref isCreating, 0)));
});
var pool = mock.Object;
pool.SetDistance(HostDistance.Local);
Assert.AreEqual(0, pool.OpenConnections);
Thread.Sleep(100);
pool.OnHostUp(null);
await pool.EnsureCreate();
Assert.AreEqual(1, pool.OpenConnections);
await TestHelper.WaitUntilAsync(() => pool.OpenConnections == 2, 200, 30);
Assert.AreEqual(2, Volatile.Read(ref creationCounter));
Assert.AreEqual(2, pool.OpenConnections);
Assert.AreEqual(0, Volatile.Read(ref isCreating));
}
public async Task OnHostUp_Recreates_Pool_In_The_Background()
{
var mock = GetPoolMock(null, GetConfig(2, 2));
var creationCounter = 0;
var isCreating = 0;
mock.Setup(p => p.DoCreateAndOpen()).Returns(() =>
{
Interlocked.Increment(ref creationCounter);
Interlocked.Exchange(ref isCreating, 1);
return(TestHelper.DelayedTask(CreateConnection(), 30, () => Interlocked.Exchange(ref isCreating, 0)));
});
var pool = mock.Object;
pool.SetDistance(HostDistance.Local);
Assert.AreEqual(0, pool.OpenConnections);
Assert.AreEqual(0, Volatile.Read(ref creationCounter));
Assert.AreEqual(0, Volatile.Read(ref isCreating));
pool.OnHostUp(null);
await TestHelper.WaitUntilAsync(() => pool.OpenConnections == 2);
Assert.AreEqual(2, pool.OpenConnections);
Assert.AreEqual(2, Volatile.Read(ref creationCounter));
Assert.AreEqual(0, Volatile.Read(ref isCreating));
}
public void EnsureCreate_Serial_Calls_Should_Yield_First()
{
var mock = GetPoolMock();
var lastByte = 1;
mock.Setup(p => p.DoCreateAndOpen()).Returns(() =>
{
var c = CreateConnection((byte)lastByte++);
if (lastByte == 2)
{
return(TestHelper.DelayedTask(c, 500));
}
return(TaskHelper.ToTask(c));
});
var pool = mock.Object;
var creationTasks = new Task <Connection[]> [4];
creationTasks[0] = pool.EnsureCreate();
creationTasks[1] = pool.EnsureCreate();
creationTasks[2] = pool.EnsureCreate();
creationTasks[3] = pool.EnsureCreate();
// ReSharper disable once CoVariantArrayConversion
Task.WaitAll(creationTasks);
Assert.AreEqual(1, TaskHelper.WaitToComplete(creationTasks[0]).Length);
for (var i = 1; i < creationTasks.Length; i++)
{
Assert.AreEqual(1, TaskHelper.WaitToComplete(creationTasks[i]).Length);
}
}
public void SchemaParser_GetQueryTrace_Should_Not_Try_More_Than_Max_Attempts()
{
var counter = 0;
var queryProviderMock = new Mock <IMetadataQueryProvider>(MockBehavior.Strict);
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.sessions"), It.IsAny <bool>()))
.Returns(() =>
{
counter++;
var sessionRow = TestHelper.CreateRow(new Dictionary <string, object>
{
{ "duration", null },
{ "request", "test query " },
{ "coordinator", IPAddress.Parse("192.168.12.13") },
{ "parameters", null },
{ "started_at", DateTimeOffset.Now }
});
return(TestHelper.DelayedTask <IEnumerable <Row> >(new[] { sessionRow }));
});
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.events"), It.IsAny <bool>()))
.Returns(() => TaskHelper.ToTask(Enumerable.Empty <Row>()));
var queryTrace = GetQueryTrace();
var parser = GetV1Instance(queryProviderMock.Object);
var timer = new HashedWheelTimer();
Assert.Throws <TraceRetrievalException>(() => TaskHelper.WaitToComplete(parser.GetQueryTrace(queryTrace, timer)));
Assert.AreEqual(counter, 5);
timer.Dispose();
}
public void SchemaParser_GetQueryTrace_When_Second_QueryAsync_Fails_Exception_Should_Propagate()
{
var sessionRow = TestHelper.CreateRow(new Dictionary <string, object>
{
{ "duration", 10 },
{ "request", "test query" },
{ "coordinator", IPAddress.Parse("192.168.12.13") },
{ "parameters", null },
{ "started_at", DateTimeOffset.Now }
});
var queryProviderMock = new Mock <IMetadataQueryProvider>(MockBehavior.Strict);
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.sessions"), It.IsAny <bool>()))
.Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { sessionRow }));
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.events"), It.IsAny <bool>()))
.Returns(() => TaskHelper.FromException <IEnumerable <Row> >(new Exception("Test exception 2")));
var queryTrace = GetQueryTrace();
var parser = GetV1Instance(queryProviderMock.Object);
var timer = new HashedWheelTimer();
var ex = Assert.Throws <Exception>(() => TaskHelper.WaitToComplete(parser.GetQueryTrace(queryTrace, timer)));
Assert.AreEqual("Test exception 2", ex.Message);
timer.Dispose();
}
public void SchemaParserV1_GetKeyspace_Should_Retrieve_And_Parse_Keyspace_With_SimpleStrategy()
{
const string ksName = "ks1";
var row = TestHelper.CreateRow(new Dictionary <string, object>
{
{ "keyspace_name", ksName },
{ "durable_writes", true },
{ "strategy_class", "Simple" },
{ "strategy_options", "{\"replication_factor\": \"4\"}" }
});
var queryProviderMock = new Mock <IMetadataQueryProvider>(MockBehavior.Strict);
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system\\.schema_keyspaces.*" + ksName), It.IsAny <bool>()))
.Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { row }));
var parser = GetV1Instance(queryProviderMock.Object);
var ks = TaskHelper.WaitToComplete(parser.GetKeyspace(ksName));
Assert.NotNull(ks);
Assert.AreEqual(ksName, ks.Name);
Assert.AreEqual(true, ks.DurableWrites);
Assert.AreEqual("Simple", ks.StrategyClass);
CollectionAssert.AreEqual(new Dictionary <string, int> {
{ "replication_factor", 4 }
}, ks.Replication);
}
public void SchemaParserV2_GetTable_Should_Propagate_Exceptions_From_Query_Provider()
{
var ksRow = TestHelper.CreateRow(new Dictionary <string, object>
{
{ "keyspace_name", "ks1" }, { "durable_writes", true }, { "replication", new Dictionary <string, string> {
{ "class", "org.apache.cassandra.locator.SimpleStrategy" }, { "replication_factor", "1" }
} },
});
var queryProviderMock = new Mock <IMetadataQueryProvider>(MockBehavior.Strict);
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system_schema\\.keyspaces.*ks1"), It.IsAny <bool>()))
.Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { ksRow }));
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system_schema\\.tables.*ks1"), It.IsAny <bool>()))
.Returns(() => TestHelper.DelayedTask(Enumerable.Empty <Row>()));
//This will cause the task to be faulted
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system_schema\\.columns.*ks1"), It.IsAny <bool>()))
.Returns(() => TaskHelper.FromException <IEnumerable <Row> >(new NoHostAvailableException(new Dictionary <IPEndPoint, Exception>())));
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system_schema\\.indexes.*ks1"), It.IsAny <bool>()))
.Returns(() => TestHelper.DelayedTask(Enumerable.Empty <Row>()));
var parser = GetV2Instance(queryProviderMock.Object);
var ks = TaskHelper.WaitToComplete(parser.GetKeyspace("ks1"));
Assert.NotNull(ks);
Assert.Throws <NoHostAvailableException>(() => ks.GetTableMetadata("tbl1"));
}
public void SchemaParserV1_GetTable_Should_Throw_ArgumentException_When_A_Table_Column_Not_Defined()
{
var tableRow = TestHelper.CreateRow(new Dictionary <string, object>
{
{ "keyspace_name", "ks_tbl_meta" },
{ "columnfamily_name", "tbl1" },
//{"bloom_filter_fp_chance", 0.01}, ---> not defined
{ "caching", "{\"keys\":\"ALL\", \"rows_per_partition\":\"NONE\"}" },
{ "cf_id", "609f53a0-038b-11e5-be48-0d419bfb85c8" },
{ "column_aliases", "[]" },
{ "comment", "" },
{ "compaction_strategy_class", "org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy" },
{ "compaction_strategy_options", "{}" },
{ "comparator", "org.apache.cassandra.db.marshal.UTF8Type" },
{ "compression_parameters", "{\"sstable_compression\":\"org.apache.cassandra.io.compress.LZ4Compressor\"}" },
{ "default_time_to_live", 0 },
{ "default_validator", "org.apache.cassandra.db.marshal.BytesType" },
{ "dropped_columns", null },
{ "gc_grace_seconds", 864000 },
{ "index_interval", null },
{ "is_dense", false },
{ "key_aliases", "[\"id\"]" },
{ "key_validator", "org.apache.cassandra.db.marshal.UUIDType" },
{ "local_read_repair_chance", 0.1 },
{ "max_compaction_threshold", 32 },
{ "max_index_interval", 2048 },
{ "memtable_flush_period_in_ms", 0 },
{ "min_compaction_threshold", 4 },
{ "min_index_interval", 128 },
{ "read_repair_chance", 0D },
{ "speculative_retry", "99.0PERCENTILE" },
{ "subcomparator", null },
{ "type", "Standard" },
{ "value_alias", null }
});
var ksRow = TestHelper.CreateRow(new Dictionary <string, object>
{
{ "keyspace_name", "ks1" }, { "durable_writes", true }, { "strategy_class", "Simple" }, { "strategy_options", "{\"replication_factor\": \"1\"}" }
});
var queryProviderMock = new Mock <IMetadataQueryProvider>(MockBehavior.Strict);
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system\\.schema_keyspaces.*ks1"), It.IsAny <bool>()))
.Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { ksRow }));
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system\\.schema_columnfamilies.*ks1"), It.IsAny <bool>()))
.Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { tableRow }));
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system\\.schema_columns.*ks1"), It.IsAny <bool>()))
.Returns(() => TestHelper.DelayedTask(Enumerable.Empty <Row>));
var parser = GetV1Instance(queryProviderMock.Object);
var ks = TaskHelper.WaitToComplete(parser.GetKeyspace("ks1"));
Assert.NotNull(ks);
var ex = Assert.Throws <ArgumentException>(() => ks.GetTableMetadata("ks_tbl_meta"));
StringAssert.Contains("bloom_filter_fp_chance", ex.Message);
}
public void TaskHelper_ContinueSync_Continues_Delayed_Tasks()
{
var t1 = TestHelper.DelayedTask(1);
var t2 = t1.ContinueSync(inValue => 2 + inValue);
t2.Wait();
Assert.AreEqual(3, t2.Result);
}
public void TaskHelper_Then_Continues_Delayed_Tasks()
{
var t1 = TestHelper.DelayedTask(1);
var t2 = t1.Then(inValue => TestHelper.DelayedTask(2 + inValue));
t2.Wait();
Assert.AreEqual(3, t2.Result);
}
public void TaskHelper_Then_Continues_Completed_Tasks()
{
var completedTask = Completed <bool>();
var t2 = completedTask.Then(_ => TestHelper.DelayedTask(true));
t2.Wait();
Assert.True(t2.Result);
}
public async Task ConsiderResizingPool_Should_Increase_One_At_A_Time_Until_Max_Connections()
{
var mock = GetPoolMock(null, GetConfig(1, 3));
var creationCounter = 0;
var isCreating = 0;
mock.Setup(p => p.DoCreateAndOpen()).Returns(() =>
{
Interlocked.Increment(ref creationCounter);
Interlocked.Exchange(ref isCreating, 1);
return(TestHelper.DelayedTask(CreateConnection(), 50, () => Interlocked.Exchange(ref isCreating, 0)));
});
var pool = mock.Object;
pool.SetDistance(HostDistance.Local);
await pool.EnsureCreate();
// Low in-flight
pool.ConsiderResizingPool(20);
Assert.AreEqual(1, Volatile.Read(ref creationCounter));
Assert.AreEqual(0, Volatile.Read(ref isCreating));
// Above threshold
pool.ConsiderResizingPool(1501);
Assert.AreEqual(2, Volatile.Read(ref creationCounter));
Assert.AreEqual(1, Volatile.Read(ref isCreating));
// Wait for the creation
await Task.Delay(100);
Assert.AreEqual(2, Volatile.Read(ref creationCounter));
Assert.AreEqual(0, Volatile.Read(ref isCreating));
// Wait for the connection pool to allow further connections
await Task.Delay(2100);
// Below threshold
pool.ConsiderResizingPool(20);
Assert.AreEqual(2, Volatile.Read(ref creationCounter));
Assert.AreEqual(0, Volatile.Read(ref isCreating));
// Above threshold
pool.ConsiderResizingPool(1700);
Assert.AreEqual(3, Volatile.Read(ref creationCounter));
Assert.AreEqual(1, Volatile.Read(ref isCreating));
// Wait for the creation
await Task.Delay(100);
Assert.AreEqual(3, Volatile.Read(ref creationCounter));
Assert.AreEqual(0, Volatile.Read(ref isCreating));
// Wait for the connection pool to allow further connections
await Task.Delay(2100);
Assert.AreEqual(3, Volatile.Read(ref creationCounter));
Assert.AreEqual(0, Volatile.Read(ref isCreating));
// Reached max: above threshold
pool.ConsiderResizingPool(1700);
// Still max
Assert.AreEqual(3, Volatile.Read(ref creationCounter));
Assert.AreEqual(0, Volatile.Read(ref isCreating));
}
public void TaskHelper_Then_Propagates_Exceptions()
{
var tcs = new TaskCompletionSource <bool>();
var t2 = tcs.Task.Then(_ => TestHelper.DelayedTask(true));
tcs.SetException(new InvalidQueryException("Dummy exception"));
var ex = Assert.Throws <AggregateException>(() => t2.Wait());
Assert.IsInstanceOf <InvalidQueryException>(ex.InnerException);
Assert.AreEqual("Dummy exception", ex.InnerException.Message);
}
public void ScheduleReconnection_Should_Reconnect_In_The_Background()
{
var mock = GetPoolMock(null, GetConfig(1, 1, new ConstantReconnectionPolicy(50)));
mock.Setup(p => p.DoCreateAndOpen()).Returns(() => TestHelper.DelayedTask(CreateConnection(), 20));
var pool = mock.Object;
Assert.AreEqual(0, pool.OpenConnections);
pool.ScheduleReconnection();
Thread.Sleep(200);
Assert.AreEqual(1, pool.OpenConnections);
}
public void AttemptReconnection_Should_Reconnect_In_The_Background()
{
var mock = GetPoolMock();
mock.Setup(p => p.CreateConnection()).Returns(() => TestHelper.DelayedTask(CreateConnection(), 20));
var pool = mock.Object;
Assert.AreEqual(0, pool.OpenConnections.Count());
pool.AttemptReconnection();
Thread.Sleep(100);
Assert.AreEqual(1, pool.OpenConnections.Count());
}
public void AttemptReconnection_Should_Reconnect_In_The_Background()
{
var mock = new Mock <HostConnectionPool>(Host1, HostDistance.Local, GetConfig());
mock.Setup(p => p.CreateConnection()).Returns(() => TestHelper.DelayedTask(new Connection(ProtocolVersion, GetIpEndPoint(), GetConfig()), 20));
var pool = mock.Object;
Assert.AreEqual(0, pool.OpenConnections.Count());
pool.AttemptReconnection();
Thread.Sleep(100);
Assert.AreEqual(1, pool.OpenConnections.Count());
}
public void Dispose_Should_Cancel_Reconnection_Attempts()
{
var mock = GetPoolMock();
mock.Setup(p => p.CreateConnection()).Returns(() => TestHelper.DelayedTask(CreateConnection(), 200));
var pool = mock.Object;
Assert.AreEqual(0, pool.OpenConnections.Count());
pool.AttemptReconnection();
pool.Dispose();
Thread.Sleep(500);
Assert.AreEqual(0, pool.OpenConnections.Count());
}
public void SchemaParserV1_GetTable_Should_Parse_1_2_Table_With_Partition_And_Clustering_Keys()
{
var tableRow = TestHelper.CreateRow(new Dictionary <string, object>
{
{ "keyspace_name", "ks_tbl_meta" }, { "columnfamily_name", "tbl1" }, { "bloom_filter_fp_chance", 0.01 }, { "caching", "KEYS_ONLY" },
{ "column_aliases", "[\"zck\"]" }, { "comment", "" }, { "compaction_strategy_class", "org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy" }, { "compaction_strategy_options", "{}" },
{ "comparator", "org.apache.cassandra.db.marshal.CompositeType(org.apache.cassandra.db.marshal.TimeUUIDType,org.apache.cassandra.db.marshal.UTF8Type)" }, { "compression_parameters", "{\"sstable_compression\":\"org.apache.cassandra.io.compress.SnappyCompressor\"}" }, { "default_validator", "org.apache.cassandra.db.marshal.BytesType" }, { "gc_grace_seconds", 864000 }, { "id", null }, { "key_alias", null },
{ "key_aliases", "[\"pk1\",\"apk2\"]" }, { "key_validator", "org.apache.cassandra.db.marshal.CompositeType(org.apache.cassandra.db.marshal.UUIDType,org.apache.cassandra.db.marshal.UTF8Type)" }, { "local_read_repair_chance", 0D }, { "max_compaction_threshold", 32 }, { "min_compaction_threshold", 4 }, { "populate_io_cache_on_flush", false }, { "read_repair_chance", 0.1 }, { "replicate_on_write", true }, { "subcomparator", null }, { "type", "Standard" }, { "value_alias", null }
});
var columnRows = new []
{
new Dictionary <string, object> {
{ "keyspace_name", "ks_tbl_meta" }, { "columnfamily_name", "tbl1" }, { "column_name", "val2" }, { "component_index", 1 }, { "index_name", null }, { "index_options", null }, { "index_type", null }, { "validator", "org.apache.cassandra.db.marshal.BytesType" }
},
new Dictionary <string, object> {
{ "keyspace_name", "ks_tbl_meta" }, { "columnfamily_name", "tbl1" }, { "column_name", "valz1" }, { "component_index", 1 }, { "index_name", null }, { "index_options", null }, { "index_type", null }, { "validator", "org.apache.cassandra.db.marshal.Int32Type" }
}
}.Select(TestHelper.CreateRow);
var ksRow = TestHelper.CreateRow(new Dictionary <string, object>
{
{ "keyspace_name", "ks1" },
{ "durable_writes", true },
{ "strategy_class", "Simple" },
{ "strategy_options", "{\"replication_factor\": \"1\"}" }
});
var queryProviderMock = new Mock <IMetadataQueryProvider>(MockBehavior.Strict);
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system\\.schema_keyspaces.*ks1"), It.IsAny <bool>()))
.Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { ksRow }));
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system\\.schema_columnfamilies.*ks1"), It.IsAny <bool>()))
.Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { tableRow }));
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system\\.schema_columns.*ks1"), It.IsAny <bool>()))
.Returns(() => TestHelper.DelayedTask(columnRows));
var parser = GetV1Instance(queryProviderMock.Object);
var ks = TaskHelper.WaitToComplete(parser.GetKeyspace("ks1"));
Assert.NotNull(ks);
var table = ks.GetTableMetadata("ks_tbl_meta");
Assert.False(table.Options.IsCompactStorage);
Assert.NotNull(table.Options.Caching);
Assert.AreEqual(5, table.TableColumns.Length);
CollectionAssert.AreEqual(new[] { "pk1", "apk2" }, table.PartitionKeys.Select(c => c.Name));
CollectionAssert.AreEqual(new[] { "zck" }, table.ClusteringKeys.Select(c => c.Item1.Name));
CollectionAssert.AreEqual(new[] { SortOrder.Ascending }, table.ClusteringKeys.Select(c => c.Item2));
}
public void MaybeCreateCorePool_Fail_To_Open_All_Connections_Should_Fault_Task()
{
var mock = new Mock <HostConnectionPool>(Host1, HostDistance.Local, GetConfig());
var testException = new Exception("Dummy exception");
mock.Setup(p => p.CreateConnection()).Returns(() => TestHelper.DelayedTask <Connection>(() =>
{
throw testException;
}));
var pool = mock.Object;
var task = pool.MaybeCreateCorePool();
var ex = Assert.Throws <Exception>(() => TaskHelper.WaitToComplete(task));
Assert.AreEqual(testException, ex);
}
public void EnsureCreate_Fail_To_Open_All_Connections_Should_Fault_Task()
{
var mock = GetPoolMock();
var testException = new Exception("Dummy exception");
mock.Setup(p => p.DoCreateAndOpen()).Returns(() => TestHelper.DelayedTask <Connection>(() =>
{
throw testException;
}));
var pool = mock.Object;
var task = pool.EnsureCreate();
var ex = Assert.Throws <Exception>(() => TaskHelper.WaitToComplete(task));
Assert.AreEqual(testException, ex);
}
public void MaybeCreateFirstConnection_Should_Yield_The_First_Connection_Opened()
{
var mock = GetPoolMock();
var lastByte = 1;
//use different addresses for same hosts to differentiate connections: for test only
//different connections to same hosts should use the same address
mock.Setup(p => p.DoCreateAndOpen()).Returns(() => TestHelper.DelayedTask(CreateConnection((byte)lastByte++), 200 - lastByte * 50));
var pool = mock.Object;
var creation = pool.EnsureCreate();
creation.Wait();
Assert.AreEqual(1, creation.Result.Length);
//yield the third connection first
CollectionAssert.AreEqual(new[] { GetIpEndPoint() }, creation.Result.Select(c => c.Address));
}
