public static string ToHttpContract(this DataSynchronizationPeriod dataSynchronizationPeriod)
{
switch (dataSynchronizationPeriod)
{
case DataSynchronizationPeriod.Immediately:
return("0");
case DataSynchronizationPeriod.Sec1:
return("1");
case DataSynchronizationPeriod.Sec5:
return("5");
case DataSynchronizationPeriod.Sec15:
return("15");
case DataSynchronizationPeriod.Sec30:
return("30");
case DataSynchronizationPeriod.Min1:
return("60");
}
return("5");
}
private async ValueTask <OperationResult> ExecuteUpdateProcessAsync(string partitionKey, string rowKey,
string method, Func <T, bool> updateCallback,
DataSynchronizationPeriod syncPeriod)
{
while (true)
{
var entity = await GetAsync(partitionKey, rowKey);
if (entity == null)
{
return(OperationResult.RecordNotFound);
}
if (!updateCallback(entity))
{
return(OperationResult.Canceled);
}
var result = await ExecuteUpdateHttpAsync(entity, method, syncPeriod);
if (result == OperationResult.RecordChangedConcurrently)
{
continue;
}
return(result);
}
}
public async ValueTask <OperationResult> InsertAsync(DbTable table, IMyMemory myMemory,
DataSynchronizationPeriod synchronizationPeriod, DateTime now)
{
var entity = myMemory.ParseDynamicEntity();
if (string.IsNullOrEmpty(entity.PartitionKey))
{
return(OperationResult.PartitionKeyIsNull);
}
if (string.IsNullOrEmpty(entity.RowKey))
{
return(OperationResult.RowKeyIsNull);
}
if (table.HasRecord(entity))
{
return(OperationResult.RecordExists);
}
var(result, dbPartition, dbRow) = table.Insert(entity, now);
if (result != OperationResult.Ok)
{
return(result);
}
_dataSynchronizer.SynchronizeUpdate(table, new[] { dbRow });
await _persistenceHandler.SynchronizePartitionAsync(table, dbPartition.PartitionKey, synchronizationPeriod);
return(OperationResult.Ok);
}
public MyNoSqlServerDataWriter(Func <string> getUrl, string tableName,
DataSynchronizationPeriod dataSynchronizationPeriod = DataSynchronizationPeriod.Sec5)
{
_getUrl = getUrl;
_dataSynchronizationPeriod = dataSynchronizationPeriod;
_tableName = tableName.ToLower();
Task.Run(CreateTableIfNotExistsAsync);
}
public MyNoSqlServerClient(IMySignalRConnection myNoSqlConnection, string tableName,
DataSynchronizationPeriod dataSynchronizationPeriod = DataSynchronizationPeriod.Sec5)
{
_myNoSqlConnection = myNoSqlConnection;
_dataSynchronizationPeriod = dataSynchronizationPeriod;
_tableName = tableName.ToLower();
Task.Run(CreateTableIfNotExistsAsync);
}
public static SyncTable Create(DbTable dbTable, DataSynchronizationPeriod period)
{
return(new SyncTable
{
DbTable = dbTable,
SyncDateTime = DateTime.UtcNow.GetNextPeriod(period)
});
}
private static void CleanTableAndBulkInsert(DbTable table, IEnumerable <IMyMemory> entitiesToInsert,
DataSynchronizationPeriod syncPeriod)
{
table.CleanAndBulkInsert(entitiesToInsert);
ServiceLocator.SnapshotSaverScheduler.SynchronizeTable(table, syncPeriod);
ServiceLocator.DataSynchronizer?.PublishInitTable(table);
}
public static SyncPartition Create(DbTable dbTable, string partitionKey, DataSynchronizationPeriod period)
{
return(new SyncPartition
{
DbTable = dbTable,
PartitionKey = partitionKey,
SyncDateTime = DateTime.UtcNow.GetNextPeriod(period)
});
}
public static SyncSetTableSavable Create(DbTable dbTable, bool savable, DataSynchronizationPeriod period)
{
return(new SyncSetTableSavable
{
DbTable = dbTable,
SyncDateTime = DateTime.UtcNow.GetNextPeriod(period),
Savable = savable
});
}
public static SyncPartition Create(DbTable dbTable, DbPartition dbPartition, DataSynchronizationPeriod period)
{
return(new SyncPartition
{
DbTable = dbTable,
DbPartition = dbPartition,
SyncDateTime = DateTime.UtcNow.GetNextPeriod(period)
});
}
public void SynchronizeTable(DbTable dbTable, DataSynchronizationPeriod period)
{
lock (_lockObject)
{
if (!_syncTables.ContainsKey(dbTable.Name))
{
_syncTables.Add(dbTable.Name, SyncTable.Create(dbTable, period));
}
}
}
private static void CleanPartitionAndBulkInsert(DbTable table, IEnumerable <IMyMemory> entitiesToInsert, string partitionKey,
DataSynchronizationPeriod syncPeriod)
{
var partitionsToSynchronize = table.CleanAndBulkInsert(partitionKey, entitiesToInsert);
foreach (var dbPartition in partitionsToSynchronize)
{
ServiceLocator.SnapshotSaverScheduler.SynchronizePartition(table, dbPartition, syncPeriod);
ServiceLocator.DataSynchronizer?.PublishInitPartition(table, dbPartition);
}
}
private bool CheckIfWeHaveSyncTableTaskEarlier(string tableName, DataSynchronizationPeriod period)
{
if (!_syncTables.ContainsKey(tableName))
{
return(false);
}
var syncTableTask = _syncTables[tableName];
return(syncTableTask.SyncDateTime < DateTime.UtcNow.GetNextPeriod(period));
}
private async ValueTask <OperationResult> ExecuteUpdateHttpAsync(T entity, string method,
DataSynchronizationPeriod syncPeriod)
{
var response = await GetUrl()
.AppendPathSegments(RowController, method)
.WithTableNameAsQueryParam(TableName)
.AppendDataSyncPeriod(syncPeriod)
.AllowNonOkCodes()
.PutJsonAsync(entity);
return(await response.GetOperationResultCodeAsync());
}
public ValueTask SynchronizeTableAsync(DbTable dbTable, DataSynchronizationPeriod period)
{
if (!dbTable.Persist)
{
return(new ValueTask());
}
_snapshotSaverScheduler.SynchronizeTable(dbTable, period);
return(period == DataSynchronizationPeriod.Immediately
? _snapshotSaverEngine.SynchronizeImmediatelyAsync(dbTable)
: new ValueTask());
}
public async ValueTask <OperationResult> CleanAndKeepLastRecordsAsync(DbTable table, string partitionKey, int amount,
DataSynchronizationPeriod synchronizationPeriod)
{
var(dbPartition, dbRows) = table.CleanAndKeepLastRecords(partitionKey, amount);
if (dbPartition != null)
{
_dataSynchronizer.SynchronizeDelete(table, dbRows);
await _persistenceHandler.SynchronizePartitionAsync(table, dbPartition.PartitionKey, synchronizationPeriod);
}
return(OperationResult.Ok);
}
public static string AsString(this DataSynchronizationPeriod src, string @default)
{
if (@default != null)
{
return(PeriodAsString.ContainsKey(src) ? PeriodAsString[src] : @default);
}
if (PeriodAsString.ContainsKey(src))
{
return(PeriodAsString[src]);
}
throw new Exception("Invalid Type: " + src);
}
public async ValueTask <OperationResult> DeleteAsync(DbTable table, string partitionKey, string rowKey,
DataSynchronizationPeriod synchronizationPeriod)
{
var(dbPartition, dbRow) = table.DeleteRow(partitionKey, rowKey);
if (dbPartition == null)
{
return(OperationResult.RowNotFound);
}
_dataSynchronizer.SynchronizeDelete(table, new[] { dbRow });
await _persistenceHandler.SynchronizePartitionAsync(table, dbPartition.PartitionKey, synchronizationPeriod);
return(OperationResult.Ok);
}
public async ValueTask CleanAndBulkInsertAsync(IEnumerable <T> entities,
DataSynchronizationPeriod dataSynchronizationPeriod = DataSynchronizationPeriod.Sec5)
{
try
{
await GetUrl()
.AppendPathSegments("Bulk", "CleanAndBulkInsert")
.AppendDataSyncPeriod(dataSynchronizationPeriod)
.WithTableNameAsQueryParam(TableName)
.PostJsonAsync(entities);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task CleanAndBulkInsertAsync(IEnumerable <T> entities,
DataSynchronizationPeriod dataSynchronizationPeriod = DataSynchronizationPeriod.Sec5)
{
try
{
await _myNoSqlConnection.Url
.AppendPathSegments("Bulk", "CleanAndBulkInsert")
.AppendDataSyncPeriod(dataSynchronizationPeriod)
.SetQueryParam(TableName, _tableName)
.PostJsonAsync(entities);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async ValueTask BulkInsertOrReplaceAsync(IEnumerable <T> entities,
DataSynchronizationPeriod dataSynchronizationPeriod = DataSynchronizationPeriod.Sec5)
{
try
{
await _getUrl()
.AppendPathSegments("Bulk", "InsertOrReplace")
.SetQueryParam(TableName, _tableName)
.AppendDataSyncPeriod(dataSynchronizationPeriod)
.PostJsonAsync(entities);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async ValueTask <OperationResult> MergeAsync(DbTable table, IMyMemory myMemory,
DataSynchronizationPeriod synchronizationPeriod, DateTime now)
{
var entity = myMemory.ParseDynamicEntity();
var(result, partition, dbRow) = table.Merge(entity, now);
if (result != OperationResult.Ok)
{
return(result);
}
_dataSynchronizer.SynchronizeUpdate(table, new[] { dbRow });
await _persistenceHandler.SynchronizePartitionAsync(table, partition.PartitionKey, synchronizationPeriod);
return(OperationResult.Ok);
}
public static ValueTask <IActionResult> SynchronizeDeletePartitionAsync(this IActionResult result, DbTable dbTable,
DbPartition dbPartition,
DataSynchronizationPeriod period)
{
if (ServiceLocator.SnapshotStorage == null)
{
return(new ValueTask <IActionResult>(result));
}
if (period == DataSynchronizationPeriod.Immediately)
{
return(result.ResponseWithActionAsync(() => ServiceLocator
.SnapshotStorage
.DeleteTablePartitionAsync(dbTable.Name, dbPartition.PartitionKey)));
}
ServiceLocator.SnapshotSaverScheduler.SynchronizePartition(dbTable, dbPartition, period);
return(new ValueTask <IActionResult>(result));
}
public static ValueTask <IActionResult> SynchronizePartitionAsync(this IActionResult result, DbTable dbTable, DbPartition partitionToSave,
DataSynchronizationPeriod period)
{
if (ServiceLocator.SnapshotStorage == null)
{
return(new ValueTask <IActionResult>(result));
}
if (period == DataSynchronizationPeriod.Immediately)
{
var partitionSnapshot = PartitionSnapshot.Create(dbTable, partitionToSave);
return(result.ResponseWithActionAsync(() => ServiceLocator
.SnapshotStorage
.SavePartitionSnapshotAsync(partitionSnapshot)));
}
ServiceLocator.SnapshotSaverScheduler.SynchronizePartition(dbTable, partitionToSave, period);
return(new ValueTask <IActionResult>(result));
}
private static int GetSecondsAmount(this DataSynchronizationPeriod period)
{
switch (period)
{
case DataSynchronizationPeriod.Sec1:
return(1);
case DataSynchronizationPeriod.Sec5:
return(5);
case DataSynchronizationPeriod.Sec15:
return(15);
case DataSynchronizationPeriod.Sec30:
return(30);
case DataSynchronizationPeriod.Min1:
return(60);
}
return(0);
}
public static DateTime GetNextPeriod(this DateTime dateTime, DataSynchronizationPeriod period)
{
return(dateTime.AddSeconds(period.GetSecondsAmount()));
}
public static SyncDeletePartition Create(string tableName, string partitionKey, DataSynchronizationPeriod period)
{
return(new SyncDeletePartition
{
TableName = tableName,
PartitionKey = partitionKey,
SyncDateTime = DateTime.UtcNow.GetNextPeriod(period)
});
}
public ValueTask <OperationResult> MergeAsync(string partitionKey, string rowKey,
Func <T, bool> updateCallback, DataSynchronizationPeriod syncPeriod = DataSynchronizationPeriod.Sec5)
{
return(ExecuteUpdateProcessAsync(partitionKey, rowKey, "Merge", updateCallback, syncPeriod));
}
public void SynchronizeTable(DbTable dbTable, DataSynchronizationPeriod period)
{
EnqueueTask(dbTable, SyncTable.Create(dbTable, period));
}
public void SynchronizePartition(DbTable dbTable, string partitionKey, DataSynchronizationPeriod period)
{
EnqueueTask(dbTable, SyncPartition.Create(dbTable, partitionKey, period));
}
