public void CheckNetworkTopologyStrategyKeyspace()
{
ITestCluster testCluster = TestClusterManager.GetNonShareableTestCluster(DefaultNodeCount);
var session = testCluster.Session;
string keyspaceName = TestUtils.GetUniqueKeyspaceName();
bool durableWrites = Randomm.Instance.NextBoolean();
Dictionary <string, int> datacentersReplicationFactors = null;
string strategyClass = ReplicationStrategies.NetworkTopologyStrategy;
int dataCentersCount = Randomm.Instance.Next(1, 11);
datacentersReplicationFactors = new Dictionary <string, int>((int)dataCentersCount);
for (int i = 0; i < dataCentersCount; i++)
{
datacentersReplicationFactors.Add("dc" + i, Randomm.Instance.Next(1, 21));
}
session.CreateKeyspace(keyspaceName,
ReplicationStrategies.CreateNetworkTopologyStrategyReplicationProperty(
datacentersReplicationFactors), durableWrites);
KeyspaceMetadata ksmd = testCluster.Cluster.Metadata.GetKeyspace(keyspaceName);
Assert.AreEqual(strategyClass, ksmd.StrategyClass);
Assert.AreEqual(durableWrites, ksmd.DurableWrites);
if (datacentersReplicationFactors != null)
{
Assert.True(datacentersReplicationFactors.SequenceEqual(ksmd.Replication));
}
}
private void CreateKeyspaceWithPropertiesTest(string strategyClass)
{
var clusterInfo = TestUtils.CcmSetup(2);
try
{
Session = clusterInfo.Session;
Cluster = clusterInfo.Cluster;
bool durable_writes = Randomm.Instance.NextBoolean();
int?replication_factor = null;
int?data_centers_count = null;
Dictionary <string, int> datacenters_replication_factors = null;
if (strategyClass == ReplicationStrategies.SimpleStrategy)
{
replication_factor = Randomm.Instance.Next(1, 21);
Session.CreateKeyspaceIfNotExists(Keyspace,
ReplicationStrategies.CreateSimpleStrategyReplicationProperty((int)replication_factor),
durable_writes);
Session.ChangeKeyspace(Keyspace);
}
else if (strategyClass == ReplicationStrategies.NetworkTopologyStrategy)
{
data_centers_count = Randomm.Instance.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, Randomm.Instance.Next(1, 21));
}
Session.CreateKeyspaceIfNotExists(Keyspace,
ReplicationStrategies.CreateNetworkTopologyStrategyReplicationProperty(
datacenters_replication_factors), durable_writes);
}
KeyspaceMetadata ksmd = Cluster.Metadata.GetKeyspace(Keyspace);
Assert.AreEqual(strategyClass, ksmd.StrategyClass);
Assert.AreEqual(durable_writes, ksmd.DurableWrites);
if (replication_factor != null)
{
Assert.AreEqual(replication_factor, ksmd.Replication["replication_factor"]);
}
if (datacenters_replication_factors != null)
{
Assert.True(datacenters_replication_factors.SequenceEqual(ksmd.Replication));
}
}
finally
{
TestUtils.CcmRemove(clusterInfo);
}
}
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 virtual void CreateSchema()
{
Diagnostics.CassandraTraceSwitch.Level = TraceLevel.Info;
Diagnostics.CassandraStackTraceIncluded = true;
ConfigurationMock = CreateConfigurationMock();
var strategyReplicationProperty = ReplicationStrategies.CreateNetworkTopologyStrategyReplicationProperty(new Dictionary <string, int> {
{ LocalDataCenter, 1 }
});
Cluster = _sessionManager.GetCluster(ConfigurationMock.Object);
Cluster.ConnectAndCreateDefaultKeyspaceIfNotExists(strategyReplicationProperty).Dispose();
Session = _sessionManager.GetSession(ConfigurationMock.Object);
DataContext = CreateDataContext();
DataContext.CreateTablesIfNotExist();
}
/// <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();
}