public void CqlClient_Timestamp()
{
var config = new MappingConfiguration()
.Define(new Map <Song>().PartitionKey(s => s.Id).TableName("song_insert"));
//Use linq to create the table
var table = new Table <Song>(_session, config);
table.CreateIfNotExists();
var mapper = new Mapper(_session, config);
var song = new Song
{
Id = Guid.NewGuid(),
Artist = "The Who",
Title = "Substitute",
ReleaseDate = DateTimeOffset.UtcNow
};
//Set timestamp to 1 day ago
var timestamp = DateTimeOffset.Now.Subtract(TimeSpan.FromDays(1));
mapper.Insert(song, true, CqlQueryOptions.New().SetTimestamp(timestamp));
//query for timestamp in a column of the record
var cqlLowerCasePartitionKey = "SELECT WRITETIME (Artist) AS timestamp FROM " + table.Name + " WHERE Id = " + song.Id + ";";
var rows = _session.Execute(cqlLowerCasePartitionKey).GetRows().ToList();
Assert.AreEqual(1, rows.Count);
var creationTimestamp = rows[0].GetValue <long>("timestamp");
Assert.NotNull(creationTimestamp);
//Timestamp retrieved is in macroseconds. Converting it to milliseconds
Assert.AreEqual(TypeSerializer.SinceUnixEpoch(timestamp).Ticks / 10, rows[0].GetValue <object>("timestamp"));
}
public void Insert_SetTimestamp_Test()
{
BoundStatement statement = null;
var sessionMock = new Mock <ISession>(MockBehavior.Strict);
sessionMock.Setup(s => s.Cluster).Returns((ICluster)null);
sessionMock
.Setup(s => s.ExecuteAsync(It.IsAny <BoundStatement>()))
.Returns(() => TestHelper.DelayedTask(RowSet.Empty()))
.Callback <BoundStatement>(stmt => statement = stmt)
.Verifiable();
sessionMock
.Setup(s => s.PrepareAsync(It.IsAny <string>()))
.Returns <string>(query => TaskHelper.ToTask(GetPrepared(query)))
.Verifiable();
var mapper = GetMappingClient(sessionMock);
var song = new Song {
Id = Guid.NewGuid(), Title = "t2", ReleaseDate = DateTimeOffset.Now
};
var timestamp = DateTimeOffset.Now.Subtract(TimeSpan.FromDays(1));
mapper.Insert(song);
Assert.Null(statement.Timestamp);
mapper.Insert(song, CqlQueryOptions.New().SetTimestamp(timestamp));
Assert.AreEqual(timestamp, statement.Timestamp);
timestamp = DateTimeOffset.Now.Subtract(TimeSpan.FromHours(10));
mapper.InsertIfNotExists(song, CqlQueryOptions.New().SetTimestamp(timestamp));
Assert.AreEqual(timestamp, statement.Timestamp);
}
public static CqlQueryOptions AsCqlQueryOptions(this IOptionsSnapshot <CassandraOptions> snapshot)
{
var cqlQueryOptions = CqlQueryOptions.New();
var options = snapshot.Value;
if (options?.Query == null)
{
return(cqlQueryOptions);
}
if (options.Query.ConsistencyLevel.HasValue)
{
cqlQueryOptions.SetConsistencyLevel(options.Query.ConsistencyLevel.Value);
}
if (options.Query.PageSize.HasValue)
{
cqlQueryOptions.SetPageSize(options.Query.PageSize.Value);
}
if (options.Query.TracingEnabled.HasValue)
{
if (options.Query.TracingEnabled.Value)
{
cqlQueryOptions.EnableTracing();
}
else
{
cqlQueryOptions.DisableTracing();
}
}
return(cqlQueryOptions);
}
public static Task <IdentityResult> TryDeleteAsync <TPoco>(this IMapper mapper,
TPoco poco,
CqlQueryOptions queryOptions,
CassandraErrorDescriber errorDescriber,
ILogger logger)
{
return(TryExecuteAsync(() => mapper.DeleteAsync(poco, queryOptions: queryOptions), errorDescriber, logger));
}
public async Task <IActionResult> WriteEntity(TestEntity entity)
{
using (var context = await _cassandraCluster.ConnectAsync(KEY_SPACE))
{
var mapper = new Mapper(context);
await mapper.InsertAsync(entity, CqlQueryOptions.New().DisableTracing());
}
return(Ok());
}
public void AddEvent(string dataProviderKey, string deltaJson, Guid transactionId)
{
TransactionEventEntity n = new TransactionEventEntity()
{
Delta = deltaJson, DeltaTimeStamp = DateTime.UtcNow, Id = transactionId
};
var transactionalCasDataProvider = this.dataProviderPool.GetProvider(dataProviderKey);
using (new StopwatchLog(Metrics.CassGet))
{
transactionalCasDataProvider.Mapper.InsertAsync(n, CqlQueryOptions.New());
}
}
public void FetchAll_DecoratedPocos_WithOptions()
{
// We should be able to get all the decorated POCOs without any CQL (i.e. have it generated for us)
List <DecoratedUser> users = CqlClient.Fetch <DecoratedUser>(CqlQueryOptions.New().DisableTracing());
foreach (DecoratedUser user in users)
{
// Match users from UserId -> Id property and test that matching properties are equivalent
TestUser testUser = TestDataHelper.Users.SingleOrDefault(u => u.UserId == user.Id);
user.ShouldBeEquivalentTo(testUser, opt => opt.ExcludingMissingProperties());
// Also make sure that ignored property was ignored
user.AnUnusedProperty.Should().NotHaveValue();
}
}
public async Task InitializeMembershipTable(bool tryInitTableVersion)
{
try
{
var cassandraCluster =
Cluster.Builder()
.AddContactPoints(_cassandraClusteringOptions.ContactPoints.Split(','))
.Build();
var session = await cassandraCluster.ConnectAsync();
await Task.Run(
() =>
{
var keyspace = _cassandraClusteringOptions.Keyspace;
session.CreateKeyspaceIfNotExists(
keyspace,
new Dictionary <string, string>
{
{ "class", "SimpleStrategy" },
{ "replication_factor", _cassandraClusteringOptions.ReplicationFactor.ToString() }
});
session.ChangeKeyspace(keyspace);
});
var mappingConfiguration = new MappingConfiguration().Define(new EntityMappings(_cassandraClusteringOptions.TableName));
_dataTable = new Table <ClusterMembership>(session, mappingConfiguration);
await Task.Run(() => _dataTable.CreateIfNotExists());
_mapper = new Mapper(session, mappingConfiguration);
if (tryInitTableVersion)
{
await _mapper.InsertAsync(
ClusterVersion.New(_clusterId),
CqlQueryOptions.New().SetConsistencyLevel(DefaultConsistencyLevel));
}
}
catch (DriverException)
{
_logger.LogWarning("Cassandra driver error occured while initializing membership data table for cluster {clusterId}.", _clusterId);
throw;
}
}
public void AddState(string dataProviderKey, JToken data, Guid transactionId)
{
var dataStr = JsonConvert.SerializeObject(data, Formatting.Indented, new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.All
});
TransactionStateEntity n = new TransactionStateEntity()
{
Data = dataStr, Id = transactionId
};
var transactionalCasDataProvider = this.dataProviderPool.GetProvider(dataProviderKey);
using (new StopwatchLog(Metrics.CassAdd))
{
transactionalCasDataProvider.Mapper.InsertAsync(n, CqlQueryOptions.New());
}
}
/// <summary>
/// Insert Receipt
/// Insert into receipt_by_receipt_id
/// </summary>
/// <returns></returns>
public async Task <ResultModel <receipt> > AddReceiptAsync()
{
var guid = Guid.NewGuid();
receipt receiptAdd = new receipt
{
businessUnit = "wireless",
receiptId = guid,
domain = "wireless",
receiptType = ReceiptType.add.ToString(),
user = Environment.UserName,
dateCreated = TimeUuid.NewId(),
dateUpdate = null
};
try
{
Stopwatch sw = Stopwatch.StartNew();
CqlQueryOptions qo = new CqlQueryOptions().SetConsistencyLevel(ConsistencyLevel.LocalOne);
await mapper.InsertAsync(receiptAdd, qo);
sw.Stop();
File.AppendAllText(@"C:\Guids.txt", $"AddReceiptAsync: Time taken: {sw.Elapsed.Milliseconds}ms\r\n");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(new ResultModel <receipt>
{
resultCode = ResultStatus.failure
});
}
return(new ResultModel <receipt>
{
resultContent = receiptAdd,
resultCode = ResultStatus.success
});
}
public void Update_SetTimestamp_Test()
{
BoundStatement statement = null;
var sessionMock = new Mock <ISession>(MockBehavior.Strict);
sessionMock.Setup(s => s.Cluster).Returns((ICluster)null);
sessionMock.Setup(s => s.Keyspace).Returns <string>(null);
sessionMock
.Setup(s => s.ExecuteAsync(It.IsAny <BoundStatement>(), It.IsAny <string>()))
.Returns(() => TestHelper.DelayedTask(RowSet.Empty()))
.Callback <BoundStatement, string>((stmt, profile) => statement = stmt)
.Verifiable();
sessionMock
.Setup(s => s.ExecuteAsync(It.IsAny <BoundStatement>()))
.Returns(() => TestHelper.DelayedTask(RowSet.Empty()))
.Callback <BoundStatement>(stmt => statement = stmt)
.Verifiable();
sessionMock
.Setup(s => s.PrepareAsync(It.IsAny <string>()))
.Returns <string>((cql) => TestHelper.DelayedTask(GetPrepared(cql)))
.Verifiable();
var mapper = GetMappingClient(sessionMock);
var song = new Song {
Id = Guid.NewGuid(), Title = "t2", ReleaseDate = DateTimeOffset.Now
};
var timestamp = DateTimeOffset.Now.Subtract(TimeSpan.FromDays(1));
mapper.Update(song);
Assert.Null(statement.Timestamp);
mapper.Update(song, CqlQueryOptions.New().SetTimestamp(timestamp));
Assert.AreEqual(timestamp, statement.Timestamp);
timestamp = DateTimeOffset.Now.Subtract(TimeSpan.FromHours(10));
mapper.UpdateIf <Song>(Cql.New("UPDATE tbl1 SET t1 = ? WHERE id = ?",
new object[] { 1, 2 },
CqlQueryOptions.New().SetTimestamp(timestamp)));
Assert.AreEqual(timestamp, statement.Timestamp);
}
public async Task WriteStateAsync(string grainType, GrainReference grainReference, IGrainState grainState)
{
var isConcurrentState = _concurrentStateTypes.Contains(grainState.State.GetType());
var(id, cassandraState) = await GetCassandraGrainState(grainType, grainReference, isConcurrentState);
try
{
var json = JsonConvert.SerializeObject(grainState.State, _jsonSettings);
if (isConcurrentState)
{
var newEtag = 0;
if (cassandraState == null)
{
cassandraState = new CassandraGrainState
{
Id = id,
GrainType = grainType,
State = json,
ETag = newEtag.ToString()
};
await _mapper.InsertIfNotExistsAsync(cassandraState, CqlQueryOptions.New().SetSerialConsistencyLevel(SerialConsistencyLevel))
.ConfigureAwait(false);
}
else
{
int.TryParse(grainState.ETag, out var stateEtag);
newEtag = stateEtag;
newEtag++;
var appliedInfo =
await _mapper.UpdateIfAsync <CassandraGrainState>(
Cql.New(
$"SET {nameof(CassandraGrainState.State)} = ?, {nameof(CassandraGrainState.ETag)} = ? " +
$"WHERE {nameof(CassandraGrainState.Id)} = ? AND {nameof(CassandraGrainState.GrainType)} = ? " +
$"IF {nameof(CassandraGrainState.ETag)} = ?",
json,
newEtag.ToString(),
id,
grainType,
stateEtag.ToString())
.WithOptions(x => x.SetSerialConsistencyLevel(SerialConsistencyLevel)))
.ConfigureAwait(false);
if (!appliedInfo.Applied)
{
throw new CassandraConcurrencyException(cassandraState.Id, stateEtag.ToString(), appliedInfo.Existing.ETag);
}
}
grainState.ETag = newEtag.ToString();
}
else
{
if (cassandraState == null)
{
cassandraState = new CassandraGrainState
{
Id = id,
GrainType = grainType,
State = json,
ETag = string.Empty
};
await _mapper.InsertAsync(cassandraState, CqlQueryOptions.New().SetConsistencyLevel(DefaultConsistencyLevel))
.ConfigureAwait(false);
}
else
{
cassandraState.State = json;
await _mapper.UpdateAsync(cassandraState, CqlQueryOptions.New().SetConsistencyLevel(DefaultConsistencyLevel))
.ConfigureAwait(false);
}
}
}
catch (DriverException)
{
_logger.LogWarning("Cassandra driver error occured while creating grain state for grain {grainId}.", id);
throw;
}
}
private static async Task MainAsync(string[] args)
{
var db = new DatabaseConnection();
var queue = new BufferBlock <IList <RockSong> >(new DataflowBlockOptions {
BoundedCapacity = 5
});
var consumerOptions = new ExecutionDataflowBlockOptions {
BoundedCapacity = 1
};
var consumer1 = new ActionBlock <IList <RockSong> >((songList) =>
{
var options = new CqlQueryOptions().SetConsistencyLevel(ConsistencyLevel.LocalOne);
foreach (var rockSong in songList)
{
db.Mapper.Insert <RockSong>(rockSong, options);
}
Console.WriteLine($"Consumer 1 | pagedList count: {songList.Count}");
}, consumerOptions);
var consumer2 = new ActionBlock <IList <RockSong> >((songList) =>
{
var options = new CqlQueryOptions().SetConsistencyLevel(ConsistencyLevel.LocalOne);
foreach (var rockSong in songList)
{
db.Mapper.Insert <RockSong>(rockSong, options);
}
Console.WriteLine($"Consumer 2 | pagedList count: {songList.Count}");
}, consumerOptions);
var consumer3 = new ActionBlock <IList <RockSong> >((songList) =>
{
var options = new CqlQueryOptions().SetConsistencyLevel(ConsistencyLevel.LocalOne);
foreach (var rockSong in songList)
{
db.Mapper.Insert <RockSong>(rockSong, options);
}
Console.WriteLine($"Consumer 3 | pagedList count: {songList.Count}");
}, consumerOptions);
var linkoptions = new DataflowLinkOptions {
PropagateCompletion = true
};
queue.LinkTo(consumer1, linkoptions);
queue.LinkTo(consumer2, linkoptions);
queue.LinkTo(consumer3, linkoptions);
Console.WriteLine("Start Producing");
var start = DateTime.UtcNow;
await ProduceAsync(queue).ConfigureAwait(false);
await Task.WhenAll(consumer1.Completion, consumer2.Completion, consumer3.Completion);
Console.WriteLine($"Duration: {DateTime.UtcNow - start}");
Console.ReadLine();
}
public void InsertTransaction(Transaction transaction)
{
this.mapper.Insert(transaction, CqlQueryOptions.New().SetConsistencyLevel(ConsistencyLevel.Any));
}
public void InsertOrder(Order order)
{
this.mapper.Insert(order, CqlQueryOptions.New().SetConsistencyLevel(ConsistencyLevel.Quorum));
}
