public void TokenMap_Build_NetworkTopology_Multiple_Racks_Skipping_Hosts_Test()
{
const string strategy = ReplicationStrategies.NetworkTopologyStrategy;
var hosts = new[]
{
// DC1 racks has contiguous tokens
// DC2 racks are properly organized
TestHelper.CreateHost("192.168.0.0", "dc1", "dc1_rack1", new HashSet <string> {
"0"
}),
TestHelper.CreateHost("192.168.0.1", "dc2", "dc2_rack1", new HashSet <string> {
"1"
}),
TestHelper.CreateHost("192.168.0.2", "dc1", "dc1_rack1", new HashSet <string> {
"2"
}),
TestHelper.CreateHost("192.168.0.3", "dc2", "dc2_rack2", new HashSet <string> {
"3"
}),
TestHelper.CreateHost("192.168.0.4", "dc1", "dc1_rack2", new HashSet <string> {
"4"
}),
TestHelper.CreateHost("192.168.0.5", "dc2", "dc2_rack1", new HashSet <string> {
"5"
}),
TestHelper.CreateHost("192.168.0.6", "dc1", "dc1_rack2", new HashSet <string> {
"6"
}),
TestHelper.CreateHost("192.168.0.7", "dc2", "dc2_rack2", new HashSet <string> {
"7"
})
};
var ks = new KeyspaceMetadata(null, "ks1", true, strategy, new Dictionary <string, int>
{
{ "dc1", 3 },
{ "dc2", 2 }
});
var map = TokenMap.Build("Murmur3Partitioner", hosts, new[] { ks });
var values = new[]
{
Tuple.Create(0, new byte[] { 0, 1, 3, 4, 2 }),
Tuple.Create(1, new byte[] { 1, 2, 3, 4, 6 }),
Tuple.Create(4, new byte[] { 4, 5, 7, 0, 6 })
};
foreach (var v in values)
{
var replicas = map.GetReplicas("ks1", new M3PToken(v.Item1));
CollectionAssert.AreEqual(v.Item2, replicas.Select(TestHelper.GetLastAddressByte));
}
}
public void CreateKeyspaceWithPropertiesTest(string strategy_class)
{
CCMCluster = CCMBridge.CCMCluster.Create(2, Cluster.Builder());
try
{
Session = CCMCluster.Session;
Cluster = CCMCluster.Cluster;
Randomm rndm = new Randomm(DateTime.Now.Millisecond);
bool durable_writes = rndm.NextBoolean();
int?replication_factor = null;
int?data_centers_count = null;
Dictionary <string, int> datacenters_replication_factors = null;
if (strategy_class == ReplicationStrategies.SimpleStrategy)
{
replication_factor = rndm.Next(1, 21);
Session.CreateKeyspaceIfNotExists(Keyspace, ReplicationStrategies.CreateSimpleStrategyReplicationProperty((int)replication_factor), durable_writes);
Session.ChangeKeyspace(Keyspace);
}
else
if (strategy_class == ReplicationStrategies.NetworkTopologyStrategy)
{
data_centers_count = rndm.Next(1, 11);
datacenters_replication_factors = new Dictionary <string, int>((int)data_centers_count);
for (int i = 0; i < data_centers_count; i++)
{
datacenters_replication_factors.Add("dc" + i.ToString(), rndm.Next(1, 21));
}
Session.CreateKeyspaceIfNotExists(Keyspace, ReplicationStrategies.CreateNetworkTopologyStrategyReplicationProperty(datacenters_replication_factors), durable_writes);
}
KeyspaceMetadata ksmd = Cluster.Metadata.GetKeyspace(Keyspace);
Assert.Equal(strategy_class, ksmd.StrategyClass);
Assert.Equal(durable_writes, ksmd.DurableWrites);
if (replication_factor != null)
{
Assert.Equal(replication_factor, ksmd.Replication["replication_factor"]);
}
if (datacenters_replication_factors != null)
{
Assert.True(datacenters_replication_factors.SequenceEqual(ksmd.Replication));
}
}
finally
{
CCMCluster.Discard();
}
}
public void Ctor_Should_InitializeStrategyWithNull_When_NullReplicationOptionsAndStrategyClassArePassed()
{
var sut = new KeyspaceMetadata(
null,
"name",
false,
null,
null,
new ReplicationStrategyFactory(),
null,
true);
Assert.IsNull(sut.Strategy);
}
public void Ctor_Should_StrategyBeNull_When_UnrecognizedStrategyClass()
{
var ks = new KeyspaceMetadata(
null,
"ks2",
true,
"random",
new Dictionary <string, string> {
{ "replication_factor", "2" }
},
new ReplicationStrategyFactory(),
null);
Assert.IsNull(ks.Strategy);
Assert.AreEqual("random", ks.StrategyClass);
}
public void Ctor_Should_ParseSimpleStrategyClass_When_ShortClassName()
{
var ks = new KeyspaceMetadata(
null,
"ks2",
true,
"SimpleStrategy",
new Dictionary <string, string> {
{ "replication_factor", "2" }
},
new ReplicationStrategyFactory(),
null);
Assert.IsNotNull(ks.Strategy);
Assert.AreEqual(ReplicationStrategies.SimpleStrategy, ks.StrategyClass);
}
public void Ctor_Should_ParseNetworkTopologyStrategyClass_When_ShortClassName()
{
var ks = new KeyspaceMetadata(
null,
"ks2",
true,
"NetworkTopologyStrategy",
new Dictionary <string, string> {
{ "dc1", "2" }, { "dc2", "1" }
},
new ReplicationStrategyFactory(),
null);
Assert.IsNotNull(ks.Strategy);
Assert.AreEqual(ReplicationStrategies.NetworkTopologyStrategy, ks.StrategyClass);
}
private void CreateCS(KeyspaceMetadata keySpace, DataCollectionMetadata tableDef)
{
var columnDescriptions = new List <Utils.ColumnDescription>();
var className = Utils.Utils.CSharpifyName(tableDef.Name);
this.swaggerRoot.Definitions.Add(className, new Schema());
Utils.Utils.WriteLineGreen($" Starting table {tableDef.Name}, class {className}");
var properties = new List <string> {
""
};
foreach (var tableColumn in tableDef.TableColumns)
{
this.isFrozen = false;
Utils.Utils.WriteLineGreen($" Table {tableDef.Name}, class {className}, column {tableColumn.Name}");
var csharpTypeName = this.GetCSharpTypeName(tableColumn);
if (csharpTypeName != null)
{
AddProperty(tableDef, columnDescriptions, properties, tableColumn, csharpTypeName);
}
else
{
Utils.Utils.WriteLineGreen($" Table {tableDef.Name}, class {className}, column {tableColumn.Name}: DON'T KNOW HOW TO HANDLE TYPE {tableColumn.TypeCode}");
}
}
PopulateIsIndexField(columnDescriptions, tableDef);
this.CreateCSFile(
className,
properties,
"using Cassandra.Mapping.Attributes;",
$@"[Table(""{tableDef.Name}"", Keyspace = ""{keySpace.Name}"" )]");
this.typeDescriptions.Add(
new Utils.TypeDescription
{
CassandraTableName = tableDef.Name,
CSharpName = className,
ColumnDescriptions = columnDescriptions
});
}
public void CheckSimpleStrategyKeyspace()
{
ITestCluster testCluster = TestClusterManager.GetNonShareableTestCluster(DefaultNodeCount);
var session = testCluster.Session;
bool durableWrites = Randomm.Instance.NextBoolean();
string keyspaceName = TestUtils.GetUniqueKeyspaceName();
string strategyClass = ReplicationStrategies.SimpleStrategy;
int replicationFactor = Randomm.Instance.Next(1, 21);
session.CreateKeyspace(keyspaceName,
ReplicationStrategies.CreateSimpleStrategyReplicationProperty(replicationFactor),
durableWrites);
session.ChangeKeyspace(keyspaceName);
KeyspaceMetadata ksmd = testCluster.Cluster.Metadata.GetKeyspace(keyspaceName);
Assert.AreEqual(strategyClass, ksmd.StrategyClass);
Assert.AreEqual(durableWrites, ksmd.DurableWrites);
Assert.AreEqual(replicationFactor, ksmd.Replication["replication_factor"]);
}
public void checkKSMetadata()
{
var clusterInfo = TestUtils.CcmSetup(2);
try
{
Session = clusterInfo.Session;
Cluster = clusterInfo.Cluster;
Session.CreateKeyspaceIfNotExists(Keyspace);
Session.ChangeKeyspace(Keyspace);
string keyspacename = "keyspace" + Guid.NewGuid().ToString("N").ToLower();
bool durableWrites = false;
string strgyClass = "SimpleStrategy";
short rplctnFactor = 1;
Session.WaitForSchemaAgreement(
Session.Execute(
string.Format(@"CREATE KEYSPACE {0}
WITH replication = {{ 'class' : '{1}', 'replication_factor' : {2} }}
AND durable_writes={3};"
, keyspacename, strgyClass, rplctnFactor, durableWrites))
);
Session.ChangeKeyspace(keyspacename);
for (int i = 0; i < 10; i++)
{
checkPureMetadata("table" + Guid.NewGuid().ToString("N"), keyspacename);
}
KeyspaceMetadata ksmd = Cluster.Metadata.GetKeyspace(keyspacename);
Assert.True(ksmd.DurableWrites == durableWrites);
Assert.True(ksmd.Replication.Where(opt => opt.Key == "replication_factor").First().Value == rplctnFactor);
Assert.True(ksmd.StrategyClass == strgyClass);
}
finally
{
TestUtils.CcmRemove(clusterInfo);
}
}
public void TokenMap_Build_Should_Memorize_Tokens_Per_Replication_Test()
{
const string strategy = ReplicationStrategies.NetworkTopologyStrategy;
var hosts = new[]
{
//0 and 100 are adjacent
TestHelper.CreateHost("192.168.0.1", "dc1", "dc1_rack1", new HashSet <string> {
"0", "100", "1000"
}),
TestHelper.CreateHost("192.168.0.2", "dc1", "dc1_rack2", new HashSet <string> {
"200", "2000", "20000"
}),
TestHelper.CreateHost("192.168.0.3", "dc1", "dc1_rack1", new HashSet <string> {
"300", "3000", "30000"
}),
TestHelper.CreateHost("192.168.0.4", "dc2", "dc2_rack1", new HashSet <string> {
"400", "4000", "40000"
}),
TestHelper.CreateHost("192.168.0.5", "dc2", "dc2_rack2", new HashSet <string> {
"500", "5000", "50000"
})
};
var ks1 = new KeyspaceMetadata(null, "ks1", true, strategy, new Dictionary <string, int> {
{ "dc1", 2 }, { "dc2", 1 }
});
var ks2 = new KeyspaceMetadata(null, "ks2", true, strategy, new Dictionary <string, int> {
{ "dc1", 2 }, { "dc2", 1 }
});
var ks3 = new KeyspaceMetadata(null, "ks3", true, strategy, new Dictionary <string, int> {
{ "dc1", 2 }
});
var map = TokenMap.Build("Murmur3Partitioner", hosts, new[] { ks1, ks2, ks3 });
var tokens1 = map.GetByKeyspace("ks1");
var tokens2 = map.GetByKeyspace("ks2");
var tokens3 = map.GetByKeyspace("ks3");
Assert.AreSame(tokens1, tokens2);
Assert.AreNotSame(tokens1, tokens3);
}
public void TokenMap_Build_NetworkTopology_Quickly_Leave_When_Dc_Not_Found()
{
const string strategy = ReplicationStrategies.NetworkTopologyStrategy;
var hosts = new Host[100];
for (var i = 0; i < hosts.Length; i++)
{
hosts[i] = TestHelper.CreateHost("192.168.0." + i, "dc" + (i % 2), "rack1", new HashSet <string>());
}
for (var i = 0; i < 256 * hosts.Length; i++)
{
var tokens = (HashSet <string>)hosts[i % hosts.Length].Tokens;
tokens.Add(i.ToString());
}
var ks = new KeyspaceMetadata(null, "ks1", true, strategy, new Dictionary <string, int>
{
{ "dc1", 3 },
{ "dc2", 2 },
{ "dc3", 1 }
});
TokenMap.Build("Murmur3Partitioner", hosts, new[] { ks });
}
/// <summary>
/// Initialize a Keyspace by name in association with the specified cluster.
/// </summary>
internal Keyspace(string name, MetaCluster metaCluster)
{
if (metaCluster == null)
{
MetaCluster = ManagerCql.DefaultCluster;
}
else
{
MetaCluster = metaCluster;
}
// initialize cache collections
Tables = new Shared <Dictionary <string, Table> >(new Dictionary <string, Table>());
Statements = new Shared <Dictionary <int, PreparedStatement> >(new Dictionary <int, PreparedStatement>());
TableMetadata = new Shared <Dictionary <string, TableMetadata> >(new Dictionary <string, TableMetadata>());
// initialize the batch related fields
_batch = new ArrayRig <Statement>();
_batchLock = new Lock();
// decrease the batch timeout if debugging
#if DEBUG
BatchTimeout = 10000;
#endif
// create the act used to execute batch statements
Act executeBatch = new Act(() => ExecuteBatch());
_batchTimer = new Timer(BatchInterval, executeBatch, false);
_onExecuted = new ArrayRig <IAction>();
// setup the auto update watch
if (_autoUpdateTime > 0)
{
_autoUpdateWatch = new Watch(_autoUpdateTime, true, OnAutoUpdate);
}
try {
// connect to the cluster
_session = MetaCluster.Cluster.Connect();
} catch (Exception ex) {
// log the error
Log.Error("Problem getting Keyspace '" + name + "' metadata from the Cluster.", ex);
return;
}
// initialize a Mapper instance for use by this Keyspace
Mapper = new Mapper(_session);
// get the metadata associated with this Keyspace
Metadata = MetaCluster.Cluster.Metadata.GetKeyspace(name);
// if the Keyspace doesn't exist
if (Metadata == null)
{
// create the Keyspace
if (MetaCluster.DataCenters == null)
{
_session.CreateKeyspace(name,
ReplicationStrategies.CreateSimpleStrategyReplicationProperty(1));
}
else
{
_session.CreateKeyspace(name,
ReplicationStrategies.CreateNetworkTopologyStrategyReplicationProperty(MetaCluster.DataCenters));
}
// get the metadata
Metadata = MetaCluster.Cluster.Metadata.GetKeyspace(name);
}
// add the Keyspace to the DataCluster
MetaCluster.AddKeyspace(this);
// make the target Keyspace of the Session to this Keyspace
_session.ChangeKeyspace(Metadata.Name);
TableMetadata.Take();
foreach (var tableMetadata in Metadata.GetTablesMetadata())
{
TableMetadata.Item.Add(tableMetadata.Name, tableMetadata);
}
TableMetadata.Release();
}
public void Ctor_Should_InitializeStrategyClassWithNull_When_NonNullReplicationOptionsArePassedButNullStrategyClassIsPassed()
{
var sut = new KeyspaceMetadata(null, "name", true, null, new ConcurrentDictionary <string, string>(), true);
Assert.IsNull(sut.StrategyClass);
}
public void Ctor_Should_InitializeStrategyClassWithNonNull_When_NullReplicationOptionsArePassedButNonNullStrategyClassIsPassed()
{
var sut = new KeyspaceMetadata(null, "name", true, "SimpleStrategy", null, true);
Assert.IsNotNull(sut.StrategyClass);
}
public void TokenMap_Build_NetworkTopology_Adjacent_Ranges_Test()
{
const string strategy = ReplicationStrategies.NetworkTopologyStrategy;
var hosts = new[]
{
//0 and 100 are adjacent
TestHelper.CreateHost("192.168.0.1", "dc1", "rack1", new HashSet<string> {"0", "100", "1000"}),
TestHelper.CreateHost("192.168.0.2", "dc1", "rack1", new HashSet<string> {"200", "2000", "20000"}),
TestHelper.CreateHost("192.168.0.3", "dc1", "rack1", new HashSet<string> {"300", "3000", "30000"})
};
var ks = new KeyspaceMetadata(null, "ks1", true, strategy, new Dictionary<string, int> { { "dc1", 2 } });
var map = TokenMap.Build("Murmur3Partitioner", hosts, new[] { ks });
var replicas = map.GetReplicas("ks1", new M3PToken(0));
Assert.AreEqual(2, replicas.Count);
//It should contain the first host and the second, even though the first host contains adjacent
CollectionAssert.AreEqual(new byte[] { 1, 2 }, replicas.Select(TestHelper.GetLastAddressByte));
}
