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)); }