private static void SetupKeyspace()
{
if (!CassandraSession.KeyspaceExists(server, keyspaceName))
{
CassandraSession.AddKeyspace(server, new KsDef {
Name = keyspaceName,
Replication_factor = 1,
Strategy_class = "org.apache.cassandra.locator.SimpleStrategy",
Cf_defs = new List <CfDef>()
});
}
var keyspace = new CassandraKeyspace(keyspaceName);
if (!keyspace.ColumnFamilyExists(server, "Posts"))
{
keyspace.AddColumnFamily(server, new CfDef {
Name = "Posts",
Keyspace = keyspaceName,
Column_type = "Super",
Comparator_type = "UTF8Type",
Subcomparator_type = "UTF8Type",
Comment = "Used for blog posts."
});
}
}
public async Task CassandraKeyspaceCreateAndUpdate()
{
var keyspace = await CreateCassandraKeyspace(null);
Assert.AreEqual(_keyspaceName, keyspace.Data.Resource.Id);
// Seems bug in swagger definition
//Assert.AreEqual(TestThroughput1, keyspace.Data.Options.Throughput);
bool ifExists = await CassandraKeyspaceCollection.ExistsAsync(_keyspaceName);
Assert.True(ifExists);
// NOT WORKING API
//ThroughputSettingsData throughtput = await keyspace.GetMongoDBCollectionThroughputAsync();
CassandraKeyspace keyspace2 = await CassandraKeyspaceCollection.GetAsync(_keyspaceName);
Assert.AreEqual(_keyspaceName, keyspace2.Data.Resource.Id);
//Assert.AreEqual(TestThroughput1, keyspace2.Data.Options.Throughput);
VerifyCassandraKeyspaces(keyspace, keyspace2);
// TODO: use original tags see defect: https://github.com/Azure/autorest.csharp/issues/1590
CassandraKeyspaceCreateUpdateData updateOptions = new CassandraKeyspaceCreateUpdateData(AzureLocation.WestUS, keyspace.Data.Resource)
{
Options = new CreateUpdateOptions {
Throughput = TestThroughput2
}
};
keyspace = (await CassandraKeyspaceCollection.CreateOrUpdateAsync(WaitUntil.Completed, _keyspaceName, updateOptions)).Value;
Assert.AreEqual(_keyspaceName, keyspace.Data.Resource.Id);
keyspace2 = await CassandraKeyspaceCollection.GetAsync(_keyspaceName);
VerifyCassandraKeyspaces(keyspace, keyspace2);
}
private static void SetupKeyspace()
{
using (var db = new CassandraContext(keyspace: KeyspaceName, server: Server))
{
if (db.KeyspaceExists(KeyspaceName))
{
db.DropKeyspace(KeyspaceName);
}
var keyspace = new CassandraKeyspace(new CassandraKeyspaceSchema
{
Name = KeyspaceName,
}, db);
keyspace.TryCreateSelf();
// create super column family using API
keyspace.TryCreateColumnFamily(new CassandraColumnFamilySchema
{
FamilyName = "razgovor",
FamilyType = ColumnType.Super,
KeyValueType = CassandraType.AsciiType,
SuperColumnNameType = CassandraType.AsciiType,
ColumnNameType = CassandraType.UTF8Type,
DefaultColumnValueType = CassandraType.UTF8Type
});
db.ExecuteNonQuery(@"CREATE TABLE poraka(
naslov text,
sodrzina text,
PRIMARY KEY(naslov)
);");
}
}
private void btnDatabaseInit_Click(object sender, EventArgs e)
{
using (var db = new CassandraContext(keyspace: KeyspaceName, server: Server))
{
if (db.KeyspaceExists(KeyspaceName))
{
db.DropKeyspace(KeyspaceName);
}
var keyspace = new CassandraKeyspace(new CassandraKeyspaceSchema
{
Name = KeyspaceName,
}, db);
keyspace.TryCreateSelf();
String CQL = @"CREATE TABLE razgovori(kluc text, direction text, caller ascii, called text, start text, duration text,
amount float, amount_ddv float, godina int, mesec int,
PRIMARY KEY(godina,mesec,caller,start,called,direction)
);";
db.ExecuteNonQuery(CQL);
//CQL = "CREATE INDEX ON razgovori(godina);";
//db.ExecuteNonQuery(CQL);
CQL = @"CREATE TABLE phonebook(kluc text, name text, surname text, number text, phone_type text,
PRIMARY KEY(surname,name,number)
);";
db.ExecuteNonQuery(CQL);
CQL = "CREATE INDEX ON phonebook(name);";
db.ExecuteNonQuery(CQL);
}
}
public async Task CassandraKeyspaceCreateUpdateTests()
{
var responseIsDatabaseNameExists = await CosmosDBManagementClient.DatabaseAccounts.CheckNameExistsAsync(databaseAccountName);
Assert.AreEqual(true, responseIsDatabaseNameExists.Value);
Assert.AreEqual(200, responseIsDatabaseNameExists.GetRawResponse().Status);
CassandraKeyspaceCreateUpdateParameters cassandraKeyspaceCreateUpdateParameters = new CassandraKeyspaceCreateUpdateParameters(new CassandraKeyspaceResource(keyspaceName), new CreateUpdateOptions(sampleThroughput, new AutoscaleSettings()));
var cassandraKeyspaceResponse1 = await WaitForCompletionAsync(await CosmosDBManagementClient.CassandraResources.StartCreateUpdateCassandraKeyspaceAsync(resourceGroupName, databaseAccountName, keyspaceName, cassandraKeyspaceCreateUpdateParameters));
CassandraKeyspace cassandraKeyspace1 = cassandraKeyspaceResponse1.Value;
Assert.NotNull(cassandraKeyspace1);
Assert.AreEqual(keyspaceName, cassandraKeyspace1.Name);
var cassandraKeyspaceResponse2 = await CosmosDBManagementClient.CassandraResources.GetCassandraKeyspaceAsync(resourceGroupName, databaseAccountName, keyspaceName);
CassandraKeyspace cassandraKeyspace2 = cassandraKeyspaceResponse2.Value;
Assert.NotNull(cassandraKeyspace2);
Assert.AreEqual(keyspaceName, cassandraKeyspace2.Name);
VerifyEqualCassandraDatabases(cassandraKeyspace1, cassandraKeyspace2);
var throughputResponse = CosmosDBManagementClient.CassandraResources.GetCassandraKeyspaceThroughputAsync(resourceGroupName, databaseAccountName, keyspaceName);
ThroughputSettingsData ThroughputSettingsData = throughputResponse.ConfigureAwait(false).GetAwaiter().GetResult();
Assert.NotNull(throughputSettings);
Assert.NotNull(throughputSettings.Name);
Assert.AreEqual(throughputSettings.Resource.Throughput, sampleThroughput);
Assert.AreEqual(cassandraKeyspacesThroughputType, throughputSettings.Type);
CassandraKeyspaceCreateUpdateParameters cassandraKeyspaceCreateUpdateParameters2 = new CassandraKeyspaceCreateUpdateParameters(new CassandraKeyspaceResource(keyspaceName), new CreateUpdateOptions(sampleThroughput2, new AutoscaleSettings()));
var cassandraKeyspaceResponse3 = await WaitForCompletionAsync(await CosmosDBManagementClient.CassandraResources.StartCreateUpdateCassandraKeyspaceAsync(resourceGroupName, databaseAccountName, keyspaceName, cassandraKeyspaceCreateUpdateParameters2));
CassandraKeyspace cassandraKeyspace3 = cassandraKeyspaceResponse3.Value;
Assert.NotNull(cassandraKeyspace3);
Assert.AreEqual(keyspaceName, cassandraKeyspace3.Name);
var cassandraKeyspaceResponse4 = await CosmosDBManagementClient.CassandraResources.GetCassandraKeyspaceAsync(resourceGroupName, databaseAccountName, keyspaceName);
CassandraKeyspace cassandraKeyspace4 = cassandraKeyspaceResponse4.Value;
Assert.NotNull(cassandraKeyspace4);
Assert.AreEqual(keyspaceName, cassandraKeyspace4.Name);
VerifyEqualCassandraDatabases(cassandraKeyspace3, cassandraKeyspace4);
var throughputResponse2 = CosmosDBManagementClient.CassandraResources.GetCassandraKeyspaceThroughputAsync(resourceGroupName, databaseAccountName, keyspaceName);
ThroughputSettingsData throughputSettings2 = throughputResponse2.ConfigureAwait(false).GetAwaiter().GetResult();
Assert.NotNull(throughputSettings2);
Assert.NotNull(throughputSettings2.Name);
Assert.AreEqual(throughputSettings2.Resource.Throughput, sampleThroughput2);
Assert.AreEqual(cassandraKeyspacesThroughputType, throughputSettings2.Type);
}
public async Task TearDown()
{
CassandraKeyspace keyspace = await CassandraKeyspaceCollection.GetIfExistsAsync(_keyspaceName);
if (keyspace != null)
{
await keyspace.DeleteAsync(WaitUntil.Completed);
}
}
public async Task CassandraKeyspaceListTests()
{
List <CassandraKeyspace> cassandraKeyspaces = await CosmosDBManagementClient.CassandraResources.ListCassandraKeyspacesAsync(resourceGroupName, databaseAccountName).ToEnumerableAsync();
Assert.NotNull(cassandraKeyspaces);
Assert.AreEqual(cassandraKeyspaces.Count, 1);
CassandraKeyspace cassandraKeyspace = await(CosmosDBManagementClient.CassandraResources.GetCassandraKeyspaceAsync(resourceGroupName, databaseAccountName, keyspaceName));
VerifyEqualCassandraDatabases(cassandraKeyspaces[0], cassandraKeyspace);
}
private static void SetupKeyspace()
{
if (CassandraSession.KeyspaceExists(server, keyspaceName))
{
CassandraSession.DropKeyspace(server, keyspaceName);
}
var keyspace = new CassandraKeyspace(keyspaceName);
keyspace.TryCreateSelf(server);
keyspace.TryCreateColumnFamily <UTF8Type>(server, "Posts");
keyspace.TryCreateColumnFamily <LongType>(server, "Tags");
keyspace.TryCreateColumnFamily <TimeUUIDType, UTF8Type>(server, "Comments");
}
private void VerifyCassandraKeyspaces(CassandraKeyspace expectedValue, CassandraKeyspace actualValue)
{
Assert.AreEqual(expectedValue.Id, actualValue.Id);
Assert.AreEqual(expectedValue.Data.Name, actualValue.Data.Name);
Assert.AreEqual(expectedValue.Data.Location, actualValue.Data.Location);
Assert.AreEqual(expectedValue.Data.Tags, actualValue.Data.Tags);
Assert.AreEqual(expectedValue.Data.ResourceType, actualValue.Data.ResourceType);
Assert.AreEqual(expectedValue.Data.Options, actualValue.Data.Options);
Assert.AreEqual(expectedValue.Data.Resource.Id, actualValue.Data.Resource.Id);
Assert.AreEqual(expectedValue.Data.Resource.Rid, actualValue.Data.Resource.Rid);
Assert.AreEqual(expectedValue.Data.Resource.Ts, actualValue.Data.Resource.Ts);
Assert.AreEqual(expectedValue.Data.Resource.Etag, actualValue.Data.Resource.Etag);
}
private static void SetupKeyspace()
{
using (var db = new CassandraContext(keyspace: KeyspaceName, server: Server))
{
if (db.KeyspaceExists(KeyspaceName))
{
db.DropKeyspace(KeyspaceName);
}
var keyspace = new CassandraKeyspace(new CassandraKeyspaceSchema
{
Name = KeyspaceName,
}, db);
keyspace.TryCreateSelf();
// create column family using CQL
db.ExecuteNonQuery(@"
CREATE COLUMNFAMILY Posts (
KEY ascii PRIMARY KEY,
Title text,
Body text,
Author text,
PostedOn timestamp
);" );
// create column family using API
keyspace.TryCreateColumnFamily(new CassandraColumnFamilySchema
{
FamilyName = "Tags",
KeyValueType = CassandraType.AsciiType,
ColumnNameType = CassandraType.Int32Type,
DefaultColumnValueType = CassandraType.UTF8Type
});
// create super column family using API
keyspace.TryCreateColumnFamily(new CassandraColumnFamilySchema
{
FamilyName = "Comments",
FamilyType = ColumnType.Super,
KeyValueType = CassandraType.AsciiType,
SuperColumnNameType = CassandraType.DateType,
ColumnNameType = CassandraType.UTF8Type,
DefaultColumnValueType = CassandraType.UTF8Type
});
}
}
private static void SetupKeyspace()
{
using (var db = new CassandraContext(keyspace: KeyspaceName, server: Server))
{
if (db.KeyspaceExists(KeyspaceName))
db.DropKeyspace(KeyspaceName);
var keyspace = new CassandraKeyspace(new CassandraKeyspaceSchema
{
Name = KeyspaceName,
}, db);
keyspace.TryCreateSelf();
// create column family using CQL
db.ExecuteNonQuery(@"
CREATE COLUMNFAMILY Posts (
KEY ascii PRIMARY KEY,
Title text,
Body text,
Author text,
PostedOn timestamp
);");
// create column family using API
keyspace.TryCreateColumnFamily(new CassandraColumnFamilySchema
{
FamilyName = "Tags",
KeyValueType = CassandraType.AsciiType,
ColumnNameType = CassandraType.Int32Type,
DefaultColumnValueType = CassandraType.UTF8Type
});
// create super column family using API
keyspace.TryCreateColumnFamily(new CassandraColumnFamilySchema
{
FamilyName = "Comments",
FamilyType = ColumnType.Super,
KeyValueType = CassandraType.AsciiType,
SuperColumnNameType = CassandraType.DateType,
ColumnNameType = CassandraType.UTF8Type,
DefaultColumnValueType = CassandraType.UTF8Type
});
}
}
/// <summary>
/// Second part of the integration test.
/// </summary>
/// <remarks>
/// Due to some issues running 2 Cassandra containers, one after the other,
/// in the same test context, we merge the integration tests to only use one container.
/// My guess, a possible Cassandra driver issue.
/// </remarks>
public static void Run_all_Cassandra_integration_tests_work(CassandraFixture dbContainer)
{
// Arrange
var cnn = dbContainer.CreateDbConnection();
var wcnn = new WrappedConnection(cnn).AssertDatabaseServerType(DBMS.Cassandra);
var db = DatabaseHelperFactory.GetDatabaseHelper(DBMS.Cassandra, wcnn);
string keyspaceName = "my_keyspace_2";
Schema keyspace = new CassandraKeyspace(keyspaceName, CassandraKeyspace.CreateSimpleStrategy(1), wcnn);
// Assert
keyspace.AssertIsNotExists();
keyspace.AssertCreation();
keyspace.AssertExists();
keyspace.AssertIsEmpty();
//Lock & Unlock
//..Applicaiton level: return true if the cluster lock keyspace/table is not present
Assert.True(db.TryAcquireApplicationLock());
wcnn.ExecuteNonQuery("create keyspace cluster_lock with replication = { 'class' : 'SimpleStrategy','replication_factor' : '1' }; ");
Assert.True(db.TryAcquireApplicationLock()); //Still true, table is missing
wcnn.ExecuteNonQuery("create table cluster_lock.lock (locked int, primary key(locked))");
Assert.True(db.TryAcquireApplicationLock()); //Still true, lock is not present
wcnn.ExecuteNonQuery("insert into cluster_lock.lock (locked) values (1) using TTL 3600");
Assert.False(db.TryAcquireApplicationLock());
wcnn.ExecuteNonQuery("drop keyspace cluster_lock");
Assert.True(db.TryAcquireApplicationLock());
Assert.True(db.ReleaseApplicationLock());
Assert.True(db.ReleaseApplicationLock());
db.AssertMetadataTableCreation(keyspaceName, "evolve_change_log")
.AssertMetadataTableLockEx() //..Table level: lock implemented with LWT on evolve metadata table
.AssertSchemaIsDroppableWhenNewSchemaFound(keyspaceName)
.AssertVersionedMigrationSave()
//.AssertVersionedMigrationChecksumUpdate()
.AssertRepeatableMigrationSave();
keyspace.AssertIsNotEmpty();
keyspace.Erase();
keyspace.AssertIsEmpty();
keyspace.Drop();
keyspace.AssertIsNotExists();
db.AssertCloseConnection();
}
public void Init()
{
_context = new CassandraContext(keyspace: DummiesKeySpace, host: "localhost");
if (!_context.KeyspaceExists(DummiesKeySpace))
{
var keyspace = new CassandraKeyspace(new CassandraKeyspaceSchema
{
Name = DummiesKeySpace,
}, _context);
keyspace.TryCreateSelf();
_context.ExecuteQuery(
@"
CREATE COLUMNFAMILY Dummies (
KEY ascii PRIMARY KEY,
Blob blob
);");
_context.SaveChanges();
}
_dummies = _context.GetColumnFamily("Dummies");
}
public CassandraRepository()
{
Keyspace = new CassandraKeyspace(KeyspaceName);
Database = new CassandraContext(keyspace: KeyspaceName, server: Server);
}
private static void Main(string[] args)
{
var keyspaceName = "Blog";
var server = new Server("localhost");
if (!CassandraSession.KeyspaceExists(server, keyspaceName))
CassandraSession.AddKeyspace(server, new KsDef {
Name = keyspaceName,
Replication_factor = 1,
Strategy_class = "org.apache.cassandra.locator.SimpleStrategy",
Cf_defs = new List<CfDef>()
});
var keyspace = new CassandraKeyspace(keyspaceName);
if (!keyspace.ColumnFamilyExists(server, "Posts"))
keyspace.AddColumnFamily(server, new CfDef {
Name = "Posts",
Keyspace = keyspaceName,
Column_type = "Super",
Comparator_type = "UTF8Type",
Subcomparator_type = "UTF8Type",
Comment = "Used for blog posts."
});
if (!keyspace.ColumnFamilyExists(server, "Comments"))
keyspace.AddColumnFamily(server, new CfDef {
Name = "Comments",
Keyspace = keyspaceName,
Column_type = "Super",
Comparator_type = "TimeUUIDType",
Subcomparator_type = "UTF8Type",
Comment = "Used for blog post comments."
});
using (var db = new CassandraContext(keyspace: keyspaceName, server: server))
{
var family = db.GetColumnFamily<UTF8Type, UTF8Type>("Posts");
// create post
dynamic post = family.CreateRecord(key: "first-blog-post");
// create post details
dynamic postDetails = post.CreateSuperColumn();
postDetails.Title = "My First Cassandra Post";
postDetails.Body = "Blah. Blah. Blah. about my first post on how great Cassandra is to work with.";
postDetails.Author = "Nick Berardi";
postDetails.PostedOn = DateTimeOffset.Now;
// create post tags
dynamic tags = post.CreateSuperColumn();
tags[0] = "Cassandra";
tags[1] = ".NET";
tags[2] = "Database";
tags[3] = "NoSQL";
// add properties to post
post.Details = postDetails;
post.Tags = tags;
// attach the post to the database
Console.WriteLine("attaching record");
db.Attach(post);
// save the changes
Console.WriteLine("saving changes");
db.SaveChanges();
// get the post back from the database
Console.WriteLine("getting 'first-blog-post'");
dynamic getPost = family.Get("first-blog-post").FirstOrDefault();
// show details
dynamic getPostDetails = getPost.Details;
Console.WriteLine(
String.Format("=={0} by {1}==\n{2}",
getPostDetails.Title,
getPostDetails.Author,
getPostDetails.Body
));
// show tags
Console.Write("tags:");
foreach (var tag in getPost.Tags)
Console.Write(String.Format("{0}:{1},", tag.ColumnName, tag.ColumnValue));
Console.WriteLine();
// get the comments family
var commentsFamily = db.GetColumnFamily<TimeUUIDType, UTF8Type>("Comments");
dynamic postComments = commentsFamily.CreateRecord(key: "first-blog-post");
// lets attach it to the database before we add the comments
db.Attach(postComments);
// add 5 comments
for (int i = 0; i < 5; i++)
{
dynamic comment = postComments.CreateSuperColumn();
comment.Name = i + " Nick Berardi";
comment.Email = i + " [email protected]";
comment.Website = i + " www.coderjournal.com";
comment.Comment = i + " Wow fluent cassandra is really great and easy to use.";
postComments[GuidGenerator.GenerateTimeBasedGuid()] = comment;
Console.WriteLine("Comment " + i + " Done");
Thread.Sleep(TimeSpan.FromSeconds(5));
}
// save the comments
db.SaveChanges();
DateTime lastDate = DateTime.Now;
for (int page = 0; page < 2; page++)
{
// lets back the date off by a millisecond so we don't get paging overlaps
lastDate = lastDate.AddMilliseconds(-1D);
Console.WriteLine("Showing page " + page + " starting at " + lastDate.ToLocalTime());
var comments = commentsFamily.Get("first-blog-post")
.Reverse()
.Fetch(lastDate)
.Take(3)
.FirstOrDefault();
foreach (dynamic comment in comments)
{
var dateTime = GuidGenerator.GetDateTime((Guid)comment.ColumnName);
Console.WriteLine(String.Format("{0:T} : {1} ({2} - {3})",
dateTime.ToLocalTime(),
comment.Name,
comment.Email,
comment.Website
));
lastDate = dateTime;
}
}
}
Console.Read();
}
public void Run_all_Cassandra_integration_tests_work()
{
// Open a connection to Cassandra
var cnn = new CqlConnection($"Contact Points=127.0.0.1;Port={_cassandraFixture.Cassandra.HostPort};Cluster Name={_cassandraFixture.Cassandra.ClusterName}");
cnn.Open();
Assert.True(cnn.State == ConnectionState.Open, "Cannot open a connection to Cassandra.");
// Initiate a connection to the database
var wcnn = new WrappedConnection(cnn);
// Validate DBMS.Cassandra
Assert.Equal(DBMS.Cassandra, wcnn.GetDatabaseServerType());
// Init the DatabaseHelper
var db = DatabaseHelperFactory.GetDatabaseHelper(DBMS.Cassandra, wcnn);
// Create schema
string metadataKeyspaceName = "my_metadata_keyspace";
Schema metadataSchema = new CassandraKeyspace(metadataKeyspaceName, CassandraKeyspace.CreateSimpleStrategy(1), wcnn);
Assert.False(metadataSchema.IsExists(), $"The schema [{metadataKeyspaceName}] should not already exist.");
Assert.True(metadataSchema.Create(), $"Creation of the schema [{metadataKeyspaceName}] failed.");
Assert.True(metadataSchema.IsExists(), $"The schema [{metadataKeyspaceName}] should be created.");
Assert.True(metadataSchema.IsEmpty(), $"The schema [{metadataKeyspaceName}] should be empty.");
var s = db.GetSchema("my_metadata_keyspace");
// Get MetadataTable
string metadataTableName = "change_log";
var metadata = db.GetMetadataTable(metadataKeyspaceName, metadataTableName);
// Create MetadataTable
Assert.False(metadata.IsExists(), "MetadataTable sould not already exist.");
Assert.True(metadata.CreateIfNotExists(), "MetadataTable creation failed.");
Assert.True(metadata.IsExists(), "MetadataTable sould exist.");
Assert.False(metadata.CreateIfNotExists(), "MetadataTable already exists. Creation should return false.");
Assert.True(metadata.GetAllMigrationMetadata().Count() == 0, "No migration metadata should be found.");
// Lock MetadataTable
metadata.Lock();
// Save NewSchema metadata
metadata.Save(MetadataType.NewSchema, "0", "New schema created.", metadataKeyspaceName);
Assert.True(metadata.CanDropSchema(metadataKeyspaceName), $"[{metadataKeyspaceName}] should be droppable.");
Assert.False(metadata.CanEraseSchema(metadataKeyspaceName), $"[{metadataKeyspaceName}] should not be erasable.");
// Add metadata migration
var migrationScript = new FileMigrationScript(TestContext.EmptyMigrationScriptPath, "1_3_2", "Migration_description");
metadata.SaveMigration(migrationScript, true);
var migrationMetadata = metadata.GetAllMigrationMetadata().FirstOrDefault();
Assert.True(migrationMetadata != null, "One migration metadata should be found.");
Assert.True(migrationMetadata.Version == migrationScript.Version, "Metadata version is not the same.");
Assert.True(migrationMetadata.Checksum == migrationScript.CalculateChecksum(), "Metadata checksum is not the same.");
Assert.True(migrationMetadata.Description == migrationScript.Description, "Metadata descritpion is not the same.");
Assert.True(migrationMetadata.Name == migrationScript.Name, "Metadata name is not the same.");
Assert.True(migrationMetadata.Success == true, "Metadata success is not true.");
Assert.True(migrationMetadata.Id != 0, "Metadata id is not set.");
Assert.True(migrationMetadata.InstalledOn.Date == DateTime.UtcNow.Date, $"Installed date is {migrationMetadata.InstalledOn.Date} whereas UtcNow is {DateTime.UtcNow.Date}.");
// Update checksum
metadata.UpdateChecksum(migrationMetadata.Id, "Hi !");
Assert.Equal("Hi !", metadata.GetAllMigrationMetadata().First().Checksum);
// Assert metadata schema is not empty
Assert.False(metadataSchema.IsEmpty(), $"[{metadataKeyspaceName}] should not be empty.");
// Erase schema
metadataSchema.Erase();
Assert.True(metadataSchema.IsEmpty(), $"The schema [{metadataKeyspaceName}] should be empty.");
Assert.True(metadataSchema.IsExists(), $"The schema [{metadataKeyspaceName}] should exist.");
// Drop schema
metadataSchema.Drop();
Assert.False(metadataSchema.IsExists(), $"The schema [{metadataKeyspaceName}] should not exist.");
}
public CassandraRepository()
{
Keyspace = new CassandraKeyspace(KeyspaceName);
Database = new CassandraContext(keyspace: KeyspaceName, server: Server);
}
/// <summary>
/// Second part of the integration test.
/// </summary>
/// <remarks>
/// Due to some issues running 2 Cassandra containers, one after the other,
/// in the same test context, we merge the integration tests to only use one container.
/// My guess, a possible Cassandra driver issue.
/// </remarks>
public static void Run_all_Cassandra_integration_tests_work(CassandraFixture cassandraContainer)
{
// Open a connection to Cassandra
var cnn = cassandraContainer.CreateDbConnection();
cnn.Open();
Assert.True(cnn.State == ConnectionState.Open, "Cannot open a connection to Cassandra.");
// Initiate a connection to the database
var wcnn = new WrappedConnection(cnn);
// Validate DBMS.Cassandra
Assert.Equal(DBMS.Cassandra, wcnn.GetDatabaseServerType());
// Init the DatabaseHelper
var db = DatabaseHelperFactory.GetDatabaseHelper(DBMS.Cassandra, wcnn);
// Create schema
string metadataKeyspaceName = "my_keyspace_2";
Schema metadataSchema = new CassandraKeyspace(metadataKeyspaceName, CassandraKeyspace.CreateSimpleStrategy(1), wcnn);
Assert.False(metadataSchema.IsExists(), $"The schema [{metadataKeyspaceName}] should not already exist.");
Assert.True(metadataSchema.Create(), $"Creation of the schema [{metadataKeyspaceName}] failed.");
Assert.True(metadataSchema.IsExists(), $"The schema [{metadataKeyspaceName}] should be created.");
Assert.True(metadataSchema.IsEmpty(), $"The schema [{metadataKeyspaceName}] should be empty.");
var s = db.GetSchema(metadataKeyspaceName);
// Get MetadataTable
string metadataTableName = "evolve_change_log";
var metadata = db.GetMetadataTable(metadataKeyspaceName, metadataTableName);
// Create MetadataTable
Assert.False(metadata.IsExists(), "MetadataTable sould not already exist.");
Assert.True(metadata.CreateIfNotExists(), "MetadataTable creation failed.");
Assert.True(metadata.IsExists(), "MetadataTable sould exist.");
Assert.False(metadata.CreateIfNotExists(), "MetadataTable already exists. Creation should return false.");
Assert.True(metadata.GetAllMigrationMetadata().Count() == 0, "No migration metadata should be found.");
//Lock & Unlock
//..Applicaiton level: return true if the cluster lock keyspace/table is not present
Assert.True(db.TryAcquireApplicationLock());
wcnn.ExecuteNonQuery("create keyspace cluster_lock with replication = { 'class' : 'SimpleStrategy','replication_factor' : '1' }; ");
Assert.True(db.TryAcquireApplicationLock()); //Still true, table is missing
wcnn.ExecuteNonQuery("create table cluster_lock.lock (locked int, primary key(locked))");
Assert.True(db.TryAcquireApplicationLock()); //Still true, lock is not present
wcnn.ExecuteNonQuery("insert into cluster_lock.lock (locked) values (1) using TTL 3600");
Assert.False(db.TryAcquireApplicationLock());
wcnn.ExecuteNonQuery("drop keyspace cluster_lock");
Assert.True(db.TryAcquireApplicationLock());
Assert.True(db.ReleaseApplicationLock());
Assert.True(db.ReleaseApplicationLock());
//..Table level: lock implemented with LWT on evolve metadata table
Assert.True(metadata.TryLock());
Assert.False(metadata.TryLock());
Assert.True(metadata.ReleaseLock());
Assert.False(metadata.ReleaseLock());
// Save NewSchema metadata
metadata.Save(MetadataType.NewSchema, "0", "New schema created.", metadataKeyspaceName);
Assert.True(metadata.CanDropSchema(metadataKeyspaceName), $"[{metadataKeyspaceName}] should be droppable.");
Assert.False(metadata.CanEraseSchema(metadataKeyspaceName), $"[{metadataKeyspaceName}] should not be erasable.");
// Add metadata migration
var migrationScript = new FileMigrationScript(TestContext.Cassandra.EmptyMigrationScriptPath, "1_3_2", "Migration_description");
metadata.SaveMigration(migrationScript, true);
var migrationMetadata = metadata.GetAllMigrationMetadata().FirstOrDefault();
Assert.True(migrationMetadata != null, "One migration metadata should be found.");
Assert.True(migrationMetadata.Version == migrationScript.Version, "Metadata version is not the same.");
Assert.True(migrationMetadata.Checksum == migrationScript.CalculateChecksum(), "Metadata checksum is not the same.");
Assert.True(migrationMetadata.Description == migrationScript.Description, "Metadata descritpion is not the same.");
Assert.True(migrationMetadata.Name == migrationScript.Name, "Metadata name is not the same.");
Assert.True(migrationMetadata.Success == true, "Metadata success is not true.");
Assert.True(migrationMetadata.Id != 0, "Metadata id is not set.");
Assert.True(migrationMetadata.InstalledOn.Date == DateTime.UtcNow.Date, $"Installed date is {migrationMetadata.InstalledOn.Date} whereas UtcNow is {DateTime.UtcNow.Date}.");
// Update checksum
metadata.UpdateChecksum(migrationMetadata.Id, "Hi !");
Assert.Equal("Hi !", metadata.GetAllMigrationMetadata().First().Checksum);
// Assert metadata schema is not empty
Assert.False(metadataSchema.IsEmpty(), $"[{metadataKeyspaceName}] should not be empty.");
// Erase schema
metadataSchema.Erase();
Assert.True(metadataSchema.IsEmpty(), $"The schema [{metadataKeyspaceName}] should be empty.");
Assert.True(metadataSchema.IsExists(), $"The schema [{metadataKeyspaceName}] should exist.");
// Drop schema
metadataSchema.Drop();
Assert.False(metadataSchema.IsExists(), $"The schema [{metadataKeyspaceName}] should not exist.");
}
public void ResetDatabase()
{
using (var session = new CassandraSession(ConnectionBuilder))
using (var db = new CassandraContext(session))
{
db.ThrowErrors = true;
db.TryDropKeyspace(Keyspace);
var keyspace = new CassandraKeyspace(new CassandraKeyspaceSchema {
Name = Keyspace
}, db);
db.Keyspace = keyspace;
keyspace.TryCreateSelf();
keyspace.TryCreateColumnFamily<AsciiType>("Standard");
keyspace.TryCreateColumnFamily<AsciiType, AsciiType>("Super");
keyspace.TryCreateColumnFamily<AsciiType>("StandardAsciiType");
keyspace.TryCreateColumnFamily<BytesType>("StandardBytesType");
keyspace.TryCreateColumnFamily<IntegerType>("StandardIntegerType");
keyspace.TryCreateColumnFamily<LexicalUUIDType>("StandardLexicalUUIDType");
keyspace.TryCreateColumnFamily<LongType>("StandardLongType");
keyspace.TryCreateColumnFamily<TimeUUIDType>("StandardTimeUUIDType");
keyspace.TryCreateColumnFamily<UTF8Type>("StandardUTF8Type");
keyspace.TryCreateColumnFamily<UUIDType>("StandardUUIDType");
keyspace.TryCreateColumnFamily(new CassandraColumnFamilySchema() {
FamilyName = "Counters",
ColumnNameType = CassandraType.AsciiType,
DefaultColumnValueType = CassandraType.CounterColumnType
});
keyspace.TryCreateColumnFamily(new CassandraColumnFamilySchema {
FamilyName = "StandardDecimalType",
ColumnNameType = CassandraType.DecimalType
});
keyspace.TryCreateColumnFamily(new CassandraColumnFamilySchema {
FamilyName = "StandardCompositeType",
ColumnNameType = CassandraType.CompositeType(new[] { CassandraType.AsciiType, CassandraType.DoubleType })
});
keyspace.TryCreateColumnFamily(new CassandraColumnFamilySchema {
FamilyName = "StandardDynamicCompositeType",
ColumnNameType = CassandraType.DynamicCompositeType(new Dictionary<char, CassandraType> { { 'a', CassandraType.AsciiType }, { 'd', CassandraType.DoubleType } })
});
db.ExecuteNonQuery(@"
CREATE COLUMNFAMILY Users (
Id int PRIMARY KEY,
Name ascii,
Email ascii,
Age int
);", CqlVersion.Cql);
db.ExecuteNonQuery(@"CREATE INDEX User_Age ON Users (Age);", CqlVersion.Cql);
db.Keyspace.ClearCachedKeyspaceSchema();
var family = db.GetColumnFamily<AsciiType>("Standard");
var superFamily = db.GetColumnFamily<AsciiType, AsciiType>("Super");
var userFamily = db.GetColumnFamily("Users");
var counterFamily = db.GetColumnFamily("Counters");
ResetFamily(family);
ResetSuperFamily(superFamily);
ResetUsersFamily(userFamily);
ResetCounterColumnFamily(counterFamily);
}
}
private static void SetupKeyspace()
{
if (CassandraSession.KeyspaceExists(server, keyspaceName))
CassandraSession.DropKeyspace(server, keyspaceName);
var keyspace = new CassandraKeyspace(keyspaceName);
keyspace.TryCreateSelf(server);
keyspace.TryCreateColumnFamily<UTF8Type>(server, "Posts");
keyspace.TryCreateColumnFamily<LongType>(server, "Tags");
keyspace.TryCreateColumnFamily<TimeUUIDType, UTF8Type>(server, "Comments");
}
public _CassandraSetup()
{
var keyspaceName = "Testing";
var server = new Server("localhost");
if (!CassandraSession.KeyspaceExists(server, keyspaceName))
CassandraSession.AddKeyspace(server, new KsDef {
Name = "Testing",
Replication_factor = 1,
Strategy_class = "org.apache.cassandra.locator.SimpleStrategy",
Cf_defs = new List<CfDef>()
});
var keyspace = new CassandraKeyspace(keyspaceName);
if (!keyspace.ColumnFamilyExists(server, "Standard"))
keyspace.AddColumnFamily(server, new CfDef {
Name = "Standard",
Keyspace = "Testing",
Column_type = "Standard",
Comparator_type = "AsciiType",
Comment = "Used for testing Standard family."
});
if (!keyspace.ColumnFamilyExists(server, "StandardAsciiType"))
keyspace.AddColumnFamily(server, new CfDef {
Name = "StandardAsciiType",
Keyspace = "Testing",
Column_type = "Standard",
Comparator_type = "AsciiType",
Comment = "Used for testing Standard family."
});
if (!keyspace.ColumnFamilyExists(server, "StandardBytesType"))
keyspace.AddColumnFamily(server, new CfDef {
Name = "StandardBytesType",
Keyspace = "Testing",
Column_type = "Standard",
Comparator_type = "BytesType",
Comment = "Used for testing BytesType family."
});
if (!keyspace.ColumnFamilyExists(server, "StandardIntegerType"))
keyspace.AddColumnFamily(server, new CfDef {
Name = "StandardIntegerType",
Keyspace = "Testing",
Column_type = "Standard",
Comparator_type = "IntegerType",
Comment = "Used for testing IntegerType family."
});
if (!keyspace.ColumnFamilyExists(server, "StandardLexicalUUIDType"))
keyspace.AddColumnFamily(server, new CfDef {
Name = "StandardLexicalUUIDType",
Keyspace = "Testing",
Column_type = "Standard",
Comparator_type = "LexicalUUIDType",
Comment = "Used for testing LexicalUUIDType family."
});
if (!keyspace.ColumnFamilyExists(server, "StandardLongType"))
keyspace.AddColumnFamily(server, new CfDef {
Name = "StandardLongType",
Keyspace = "Testing",
Column_type = "Standard",
Comparator_type = "LongType",
Comment = "Used for testing LongType family."
});
if (!keyspace.ColumnFamilyExists(server, "StandardTimeUUIDType"))
keyspace.AddColumnFamily(server, new CfDef {
Name = "StandardTimeUUIDType",
Keyspace = "Testing",
Column_type = "Standard",
Comparator_type = "TimeUUIDType",
Comment = "Used for testing TimeUUIDType family."
});
if (!keyspace.ColumnFamilyExists(server, "StandardUTF8Type"))
keyspace.AddColumnFamily(server, new CfDef {
Name = "StandardUTF8Type",
Keyspace = "Testing",
Column_type = "Standard",
Comparator_type = "UTF8Type",
Comment = "Used for testing UTF8Type family."
});
if (!keyspace.ColumnFamilyExists(server, "Super"))
keyspace.AddColumnFamily(server, new CfDef {
Name = "Super",
Keyspace = "Testing",
Column_type = "Super",
Comparator_type = "AsciiType",
Subcomparator_type = "AsciiType",
Comment = "Used for testing Super family."
});
DB = new CassandraContext(keyspaceName, server);
DB.ThrowErrors = true;
Family = DB.GetColumnFamily<AsciiType>("Standard");
SuperFamily = DB.GetColumnFamily<AsciiType, AsciiType>("Super");
Family.RemoveAllRows();
SuperFamily.RemoveAllRows();
Family.InsertColumn(TestKey1, "Test1", Math.PI);
Family.InsertColumn(TestKey1, "Test2", Math.PI);
Family.InsertColumn(TestKey1, "Test3", Math.PI);
SuperFamily.InsertColumn(TestKey1, TestSuperName, "Test1", Math.PI);
SuperFamily.InsertColumn(TestKey1, TestSuperName, "Test2", Math.PI);
SuperFamily.InsertColumn(TestKey1, TestSuperName, "Test3", Math.PI);
Family.InsertColumn(TestKey2, "Test1", Math.PI);
Family.InsertColumn(TestKey2, "Test2", Math.PI);
Family.InsertColumn(TestKey2, "Test3", Math.PI);
SuperFamily.InsertColumn(TestKey2, TestSuperName, "Test1", Math.PI);
SuperFamily.InsertColumn(TestKey2, TestSuperName, "Test2", Math.PI);
SuperFamily.InsertColumn(TestKey2, TestSuperName, "Test3", Math.PI);
}
public async Task SetUp()
{
_cassandraKeyspace = await ArmClient.GetCassandraKeyspace(_cassandraKeyspaceId).GetAsync();
}
public static void Test()
{
int TestTimeInMinutes = 10;
int ThreadCount = 50;
int ThreadCount2 = 10;
int TimeOut_Sec = 5;
bool usePooling = true;
object alive_monitor = new object();
bool alive_condition = true;
List <Thread> threads = new List <Thread>();
int thrStarted_cnt = 0;
object thrStarted_monitor = new object();
//initialize
CassandraContext main_db = new CassandraContext(new ConnectionBuilder(keyspace: KeyspaceName, server: Server, cqlVersion: CqlVersion.Cql3, pooling: usePooling));
{
if (main_db.KeyspaceExists(KeyspaceName))
{
main_db.DropKeyspace(KeyspaceName);
}
var keyspace = new CassandraKeyspace(new CassandraKeyspaceSchema
{
Name = KeyspaceName,
}, main_db);
keyspace.TryCreateSelf();
CreateTablesIfNotExists(main_db);
}
for (int tI = 0; tI < ThreadCount; tI++)
{
int thrNo = tI;
var thr = new Thread(() =>
{
Console.Write("(*" + thrNo + ")");
try
{
CassandraContext db = new CassandraContext(new ConnectionBuilder(keyspace: KeyspaceName, server: Server, cqlVersion: CqlVersion.Cql3, pooling: usePooling));
lock (thrStarted_monitor)
{
thrStarted_cnt++;
Monitor.PulseAll(thrStarted_monitor);
}
while (true)
{
var job = GetJob(db, 10);
if (job != null)
{
Console.Write("-");
if (job.GetLogic() == null || job.GetCommand() == null)
{
Console.WriteLine("Error");
}
DeleteJob(db, job);
}
else
{
lock (alive_monitor)
{
if (!alive_condition)
{
return;
}
else
{
Monitor.Wait(alive_monitor, TimeOut_Sec * 1000);
}
}
}
}
}
finally
{
Console.Write("(~" + thrNo + ")");
}
});
threads.Add(thr);
thr.Start();
}
for (int tI = 0; tI < ThreadCount2; tI++)
{
int thrNo = tI;
var thr = new Thread(() =>
{
Console.Write("<*" + thrNo + ">");
try
{
CassandraContext db = new CassandraContext(new ConnectionBuilder(keyspace: KeyspaceName, server: Server, cqlVersion: CqlVersion.Cql3, pooling: usePooling));
lock (thrStarted_monitor)
{
thrStarted_cnt++;
Monitor.PulseAll(thrStarted_monitor);
}
while (true)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100; i++)
{
sb.AppendLine(Guid.NewGuid().ToString());
}
AddJob(db, sb.ToString(), Guid.NewGuid().ToString());
Console.Write("+");
Thread.Sleep(100);
lock (alive_monitor)
{
if (!alive_condition)
{
return;
}
}
}
}
finally
{
Console.Write("<~" + thrNo + ">");
}
});
threads.Add(thr);
thr.Start();
}
while (true)
{
lock (thrStarted_monitor)
{
Monitor.Wait(thrStarted_monitor);
if (thrStarted_cnt == ThreadCount + ThreadCount2)
{
break;
}
}
}
//wait for ten minutes
Thread.Sleep(TestTimeInMinutes * 60 * 1000);
lock (alive_monitor)
{
alive_condition = false;
Monitor.PulseAll(alive_monitor);
}
foreach (var thr in threads)
{
thr.Join();
}
var j = main_db.ExecuteQuery(SelectCQL_Main(1)).ToArray();
var c = main_db.ExecuteQuery(SelectCQL_Trans(1)).ToArray();
if (j.Count() > 0 || c.Count() > 0)
{
Console.WriteLine("Error");
}
Console.WriteLine("Finished");
}
private static void SetupKeyspace()
{
if (!CassandraSession.KeyspaceExists(server, keyspaceName))
CassandraSession.AddKeyspace(server, new KsDef {
Name = keyspaceName,
Replication_factor = 1,
Strategy_class = "org.apache.cassandra.locator.SimpleStrategy",
Cf_defs = new List<CfDef>()
});
var keyspace = new CassandraKeyspace(keyspaceName);
if (!keyspace.ColumnFamilyExists(server, "Posts"))
keyspace.AddColumnFamily(server, new CfDef {
Name = "Posts",
Keyspace = keyspaceName,
Column_type = "Super",
Comparator_type = "UTF8Type",
Subcomparator_type = "UTF8Type",
Comment = "Used for blog posts."
});
}
public _CassandraSetup()
{
var keyspaceName = "Testing";
var server = new Server("localhost");
if (!CassandraSession.KeyspaceExists(server, keyspaceName))
{
CassandraSession.AddKeyspace(server, new KsDef {
Name = "Testing",
Replication_factor = 1,
Strategy_class = "org.apache.cassandra.locator.SimpleStrategy",
Cf_defs = new List <CfDef>()
});
}
var keyspace = new CassandraKeyspace(keyspaceName);
if (!keyspace.ColumnFamilyExists(server, "Standard"))
{
keyspace.AddColumnFamily(server, new CfDef {
Name = "Standard",
Keyspace = "Testing",
Column_type = "Standard",
Comparator_type = "AsciiType",
Comment = "Used for testing Standard family."
});
}
if (!keyspace.ColumnFamilyExists(server, "StandardAsciiType"))
{
keyspace.AddColumnFamily(server, new CfDef {
Name = "StandardAsciiType",
Keyspace = "Testing",
Column_type = "Standard",
Comparator_type = "AsciiType",
Comment = "Used for testing Standard family."
});
}
if (!keyspace.ColumnFamilyExists(server, "StandardBytesType"))
{
keyspace.AddColumnFamily(server, new CfDef {
Name = "StandardBytesType",
Keyspace = "Testing",
Column_type = "Standard",
Comparator_type = "BytesType",
Comment = "Used for testing BytesType family."
});
}
if (!keyspace.ColumnFamilyExists(server, "StandardIntegerType"))
{
keyspace.AddColumnFamily(server, new CfDef {
Name = "StandardIntegerType",
Keyspace = "Testing",
Column_type = "Standard",
Comparator_type = "IntegerType",
Comment = "Used for testing IntegerType family."
});
}
if (!keyspace.ColumnFamilyExists(server, "StandardLexicalUUIDType"))
{
keyspace.AddColumnFamily(server, new CfDef {
Name = "StandardLexicalUUIDType",
Keyspace = "Testing",
Column_type = "Standard",
Comparator_type = "LexicalUUIDType",
Comment = "Used for testing LexicalUUIDType family."
});
}
if (!keyspace.ColumnFamilyExists(server, "StandardLongType"))
{
keyspace.AddColumnFamily(server, new CfDef {
Name = "StandardLongType",
Keyspace = "Testing",
Column_type = "Standard",
Comparator_type = "LongType",
Comment = "Used for testing LongType family."
});
}
if (!keyspace.ColumnFamilyExists(server, "StandardTimeUUIDType"))
{
keyspace.AddColumnFamily(server, new CfDef {
Name = "StandardTimeUUIDType",
Keyspace = "Testing",
Column_type = "Standard",
Comparator_type = "TimeUUIDType",
Comment = "Used for testing TimeUUIDType family."
});
}
if (!keyspace.ColumnFamilyExists(server, "StandardUTF8Type"))
{
keyspace.AddColumnFamily(server, new CfDef {
Name = "StandardUTF8Type",
Keyspace = "Testing",
Column_type = "Standard",
Comparator_type = "UTF8Type",
Comment = "Used for testing UTF8Type family."
});
}
if (!keyspace.ColumnFamilyExists(server, "Super"))
{
keyspace.AddColumnFamily(server, new CfDef {
Name = "Super",
Keyspace = "Testing",
Column_type = "Super",
Comparator_type = "AsciiType",
Subcomparator_type = "AsciiType",
Comment = "Used for testing Super family."
});
}
DB = new CassandraContext(keyspaceName, server);
DB.ThrowErrors = true;
Family = DB.GetColumnFamily <AsciiType>("Standard");
SuperFamily = DB.GetColumnFamily <AsciiType, AsciiType>("Super");
Family.RemoveAllRows();
SuperFamily.RemoveAllRows();
Family.InsertColumn(TestKey1, "Test1", Math.PI);
Family.InsertColumn(TestKey1, "Test2", Math.PI);
Family.InsertColumn(TestKey1, "Test3", Math.PI);
SuperFamily.InsertColumn(TestKey1, TestSuperName, "Test1", Math.PI);
SuperFamily.InsertColumn(TestKey1, TestSuperName, "Test2", Math.PI);
SuperFamily.InsertColumn(TestKey1, TestSuperName, "Test3", Math.PI);
Family.InsertColumn(TestKey2, "Test1", Math.PI);
Family.InsertColumn(TestKey2, "Test2", Math.PI);
Family.InsertColumn(TestKey2, "Test3", Math.PI);
SuperFamily.InsertColumn(TestKey2, TestSuperName, "Test1", Math.PI);
SuperFamily.InsertColumn(TestKey2, TestSuperName, "Test2", Math.PI);
SuperFamily.InsertColumn(TestKey2, TestSuperName, "Test3", Math.PI);
}
public void ResetDatabase()
{
using (var session = new CassandraSession(ConnectionBuilder))
using (var db = new CassandraContext(session))
{
db.ThrowErrors = true;
db.TryDropKeyspace(Keyspace);
var keyspace = new CassandraKeyspace(new CassandraKeyspaceSchema {
Name = Keyspace
}, db);
db.Keyspace = keyspace;
keyspace.TryCreateSelf();
keyspace.TryCreateColumnFamily <AsciiType>("Standard");
keyspace.TryCreateColumnFamily <AsciiType, AsciiType>("Super");
keyspace.TryCreateColumnFamily <AsciiType>("StandardAsciiType");
keyspace.TryCreateColumnFamily <BytesType>("StandardBytesType");
keyspace.TryCreateColumnFamily <IntegerType>("StandardIntegerType");
keyspace.TryCreateColumnFamily <LexicalUUIDType>("StandardLexicalUUIDType");
keyspace.TryCreateColumnFamily <LongType>("StandardLongType");
keyspace.TryCreateColumnFamily <TimeUUIDType>("StandardTimeUUIDType");
keyspace.TryCreateColumnFamily <UTF8Type>("StandardUTF8Type");
keyspace.TryCreateColumnFamily <UUIDType>("StandardUUIDType");
keyspace.TryCreateColumnFamily(new CassandraColumnFamilySchema()
{
FamilyName = "Counters",
ColumnNameType = CassandraType.AsciiType,
DefaultColumnValueType = CassandraType.CounterColumnType
});
keyspace.TryCreateColumnFamily(new CassandraColumnFamilySchema(type: ColumnType.Super)
{
FamilyName = "SuperCounters",
SuperColumnNameType = CassandraType.AsciiType,
ColumnNameType = CassandraType.AsciiType,
DefaultColumnValueType = CassandraType.CounterColumnType
});
keyspace.TryCreateColumnFamily(new CassandraColumnFamilySchema {
FamilyName = "StandardDecimalType",
ColumnNameType = CassandraType.DecimalType
});
keyspace.TryCreateColumnFamily(new CassandraColumnFamilySchema {
FamilyName = "StandardCompositeType",
ColumnNameType = CassandraType.CompositeType(new[] { CassandraType.AsciiType, CassandraType.DoubleType })
});
keyspace.TryCreateColumnFamily(new CassandraColumnFamilySchema {
FamilyName = "StandardDynamicCompositeType",
ColumnNameType = CassandraType.DynamicCompositeType(new Dictionary <char, CassandraType> {
{ 'a', CassandraType.AsciiType }, { 'd', CassandraType.DoubleType }
})
});
db.ExecuteNonQuery(@"
CREATE COLUMNFAMILY ""Users"" (
Id int PRIMARY KEY,
Name ascii,
Email ascii,
Age int
);");
db.ExecuteNonQuery(@"CREATE INDEX User_Age ON ""Users"" (Age);");
db.ExecuteNonQuery(@"
CREATE COLUMNFAMILY Cql3List (
Id int PRIMARY KEY,
TagList list<text> --list of strings
);");
db.ExecuteNonQuery(@"
CREATE COLUMNFAMILY Cql3Set (
Id int PRIMARY KEY,
TagSet set<uuid> --set of Guids
);");
db.ExecuteNonQuery(@"
CREATE COLUMNFAMILY Cql3Map (
Id int PRIMARY KEY,
TagMap map<bigint,uuid> --map of long integers and Guids
);");
db.Keyspace.ClearCachedKeyspaceSchema();
var family = db.GetColumnFamily <AsciiType>("Standard");
var superFamily = db.GetColumnFamily <AsciiType, AsciiType>("Super");
var userFamily = db.GetColumnFamily("Users");
var counterFamily = db.GetColumnFamily("Counters");
ResetFamily(family);
ResetSuperFamily(superFamily);
ResetUsersFamily(userFamily);
ResetCounterColumnFamily(counterFamily);
}
}
public static void Test()
{
int TestTimeInMinutes = 10;
int ThreadCount = 50;
int ThreadCount2 = 10;
int TimeOut_Sec = 5;
bool usePooling = true;
object alive_monitor = new object();
bool alive_condition = true;
List<Thread> threads = new List<Thread>();
int thrStarted_cnt = 0;
object thrStarted_monitor = new object();
//initialize
CassandraContext main_db = new CassandraContext(new ConnectionBuilder(keyspace: KeyspaceName, server: Server, cqlVersion: CqlVersion.Cql3, pooling: usePooling));
{
if (main_db.KeyspaceExists(KeyspaceName))
main_db.DropKeyspace(KeyspaceName);
var keyspace = new CassandraKeyspace(new CassandraKeyspaceSchema
{
Name = KeyspaceName,
}, main_db);
keyspace.TryCreateSelf();
CreateTablesIfNotExists(main_db);
}
for (int tI = 0; tI < ThreadCount; tI++)
{
int thrNo = tI;
var thr = new Thread(() =>
{
Console.Write("(*" + thrNo + ")");
try
{
CassandraContext db = new CassandraContext(new ConnectionBuilder(keyspace: KeyspaceName, server: Server, cqlVersion: CqlVersion.Cql3, pooling: usePooling));
lock (thrStarted_monitor)
{
thrStarted_cnt++;
Monitor.PulseAll(thrStarted_monitor);
}
while (true)
{
var job = GetJob(db, 10);
if (job != null)
{
Console.Write("-");
if (job.GetLogic() == null || job.GetCommand() == null)
Console.WriteLine("Error");
DeleteJob(db, job);
}
else
{
lock (alive_monitor)
{
if (!alive_condition)
return;
else
Monitor.Wait(alive_monitor, TimeOut_Sec * 1000);
}
}
}
}
finally
{
Console.Write("(~" + thrNo + ")");
}
});
threads.Add(thr);
thr.Start();
}
for (int tI = 0; tI < ThreadCount2; tI++)
{
int thrNo = tI;
var thr = new Thread(() =>
{
Console.Write("<*" + thrNo + ">");
try
{
CassandraContext db = new CassandraContext(new ConnectionBuilder(keyspace: KeyspaceName, server: Server, cqlVersion: CqlVersion.Cql3, pooling: usePooling));
lock (thrStarted_monitor)
{
thrStarted_cnt++;
Monitor.PulseAll(thrStarted_monitor);
}
while (true)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100; i++)
sb.AppendLine(Guid.NewGuid().ToString());
AddJob(db, sb.ToString(), Guid.NewGuid().ToString());
Console.Write("+");
Thread.Sleep(100);
lock (alive_monitor)
{
if (!alive_condition)
return;
}
}
}
finally
{
Console.Write("<~" + thrNo + ">");
}
});
threads.Add(thr);
thr.Start();
}
while (true)
{
lock (thrStarted_monitor)
{
Monitor.Wait(thrStarted_monitor);
if (thrStarted_cnt == ThreadCount+ThreadCount2)
break;
}
}
//wait for ten minutes
Thread.Sleep(TestTimeInMinutes * 60 * 1000);
lock (alive_monitor)
{
alive_condition = false;
Monitor.PulseAll(alive_monitor);
}
foreach (var thr in threads)
{
thr.Join();
}
var j = main_db.ExecuteQuery(SelectCQL_Main(1)).ToArray();
var c = main_db.ExecuteQuery(SelectCQL_Trans(1)).ToArray();
if (j.Count() > 0 || c.Count() > 0)
Console.WriteLine("Error");
Console.WriteLine("Finished");
}
