Insert(DynamicEntity entity, DateTime now)
{
_readerWriterLockSlim.EnterWriteLock();
try
{
if (!_partitions.ContainsKey(entity.PartitionKey))
{
_partitions.Add(entity.PartitionKey, DbPartition.Create(entity.PartitionKey));
}
var partition = _partitions[entity.PartitionKey];
var dbRow = DbRow.CreateNew(entity, now);
if (partition.Insert(dbRow, now))
{
return(OperationResult.Ok, partition, dbRow);
}
return(OperationResult.RecordExists, null, null);
}
finally
{
_readerWriterLockSlim.ExitWriteLock();
}
}
public void InitPartitionFromSnapshot(PartitionSnapshot partitionSnapshot)
{
_readerWriterLockSlim.EnterWriteLock();
try
{
var partition = DbPartition.Create(partitionSnapshot.PartitionKey);
if (_partitions.ContainsKey(partitionSnapshot.PartitionKey))
{
return;
}
_partitions.Add(partition.PartitionKey, partition);
var partitionAsMyMemory = new MyMemoryAsByteArray(partitionSnapshot.Snapshot);
foreach (var dbRowMemory in partitionAsMyMemory.SplitJsonArrayToObjects())
{
var entity = dbRowMemory.ParseDynamicEntity();
var dbRow = DbRow.RestoreSnapshot(entity, dbRowMemory);
partition.InsertOrReplace(dbRow);
}
}
finally
{
_readerWriterLockSlim.ExitWriteLock();
}
}
public (DbPartition partition, DbRow dbRow) Insert(IMyNoSqlDbEntity entityInfo, List <MyJsonFirstLevelFieldData> fields)
{
ReaderWriterLockSlim.EnterWriteLock();
try
{
if (!_partitions.ContainsKey(entityInfo.PartitionKey))
{
_partitions.Add(entityInfo.PartitionKey, DbPartition.Create(entityInfo.PartitionKey));
}
var partition = _partitions[entityInfo.PartitionKey];
var dbRow = DbRow.CreateNew(entityInfo, fields);
if (partition.Insert(dbRow))
{
return(partition, dbRow);
}
}
finally
{
ReaderWriterLockSlim.ExitWriteLock();
}
return(null, null);
}
public void CleanAndBulkInsert(IEnumerable <IMyMemory> itemsAsArray)
{
var dbRows = itemsAsArray
.Select(arraySpan => arraySpan
.ToDbRow())
.ToList();
_readerWriterLockSlim.EnterWriteLock();
try
{
_partitions.Clear();
foreach (var dbRow in dbRows)
{
if (!_partitions.ContainsKey(dbRow.PartitionKey))
{
_partitions.Add(dbRow.PartitionKey, DbPartition.Create(dbRow.PartitionKey));
}
var partition = _partitions[dbRow.PartitionKey];
partition.InsertOrReplace(dbRow);
}
}
finally
{
_readerWriterLockSlim.ExitWriteLock();
}
}
public static SyncPartition Create(DbTable dbTable, DbPartition dbPartition, DataSynchronizationPeriod period)
{
return(new SyncPartition
{
DbTable = dbTable,
DbPartition = dbPartition,
SyncDateTime = DateTime.UtcNow.GetNextPeriod(period)
});
}
public static void BroadCastInit(DbTable dbTable, DbPartition partition)
{
var clientsToSend = Connections.Get(itm => itm.SubscribedToTable(dbTable.Name)).Select(itm => itm.Client);
byte[] packetToBroadcast = null;
foreach (var clientProxy in clientsToSend)
{
if (packetToBroadcast == null)
{
packetToBroadcast = partition.GetAllRows().ToHubUpdateContract();
}
clientProxy.SendAsync(dbTable.Name, "i:" + partition.PartitionKey, packetToBroadcast);
}
}
public IEnumerable <DbPartition> CleanAndBulkInsert(string partitionKey, IEnumerable <IMyMemory> itemsAsArray)
{
var dbRows = itemsAsArray
.Select(arraySpan => arraySpan
.ToDbRow())
.ToArray();
_readerWriterLockSlim.EnterWriteLock();
var result = new Dictionary <string, DbPartition>();
try
{
if (_partitions.ContainsKey(partitionKey))
{
_partitions[partitionKey].Clean();
}
foreach (var dbRow in dbRows)
{
if (!_partitions.ContainsKey(dbRow.PartitionKey))
{
_partitions.Add(dbRow.PartitionKey, DbPartition.Create(dbRow.PartitionKey));
}
var partition = _partitions[dbRow.PartitionKey];
partition.InsertOrReplace(dbRow);
if (!result.ContainsKey(dbRow.PartitionKey))
{
result.Add(dbRow.PartitionKey, partition);
}
}
}
finally
{
_readerWriterLockSlim.ExitWriteLock();
}
return(result.Values);
}
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 (IEnumerable <DbPartition> partitions, IReadOnlyList <DbRow> rows) BulkInsertOrReplace(
IEnumerable <IMyMemory> itemsAsArray)
{
var dbRows = itemsAsArray
.Select(arraySpan => arraySpan.ToDbRow())
.ToList();
var partitionsToSync = new Dictionary <string, DbPartition>();
var rowsToSync = new List <DbRow>();
_readerWriterLockSlim.EnterWriteLock();
try
{
foreach (var dbRow in dbRows)
{
if (!_partitions.ContainsKey(dbRow.PartitionKey))
{
_partitions.Add(dbRow.PartitionKey, DbPartition.Create(dbRow.PartitionKey));
}
var partition = _partitions[dbRow.PartitionKey];
partition.InsertOrReplace(dbRow);
if (!partitionsToSync.ContainsKey(partition.PartitionKey))
{
partitionsToSync.Add(partition.PartitionKey, partition);
}
rowsToSync.Add(dbRow);
}
}
finally
{
_readerWriterLockSlim.ExitWriteLock();
}
return(partitionsToSync.Values, rowsToSync);
}
public static void BroadcastInitPartition(DbTable dbTable, DbPartition partition)
{
var connections = TableSubscribers.GetConnections(dbTable.Name);
if (connections == null)
{
return;
}
var packetToBroadcast = new InitPartitionContract
{
TableName = dbTable.Name,
PartitionKey = partition.PartitionKey,
Data = partition.GetAllRows().ToHubUpdateContract()
};
foreach (var connection in connections)
{
connection.SendPacket(packetToBroadcast);
}
}
public void SynchronizePartition(DbTable dbTable, DbPartition partitionToSave, DataSynchronizationPeriod period)
{
lock (_lockObject)
{
if (CheckIfWeHaveSyncTableTaskEarlier(dbTable.Name, period))
{
return;
}
if (!_syncPartitions.ContainsKey(dbTable.Name))
{
_syncPartitions.Add(dbTable.Name, new Dictionary <string, SyncPartition>());
}
var dict = _syncPartitions[dbTable.Name];
if (!dict.ContainsKey(partitionToSave.PartitionKey))
{
dict.Add(partitionToSave.PartitionKey, SyncPartition.Create(dbTable, partitionToSave, period));
}
}
}
public (DbPartition partition, DbRow dbRow) InsertOrReplace(DynamicEntity entity, DateTime now)
{
_readerWriterLockSlim.EnterWriteLock();
try
{
if (!_partitions.ContainsKey(entity.PartitionKey))
{
_partitions.Add(entity.PartitionKey, DbPartition.Create(entity.PartitionKey));
}
var partition = _partitions[entity.PartitionKey];
var dbRow = DbRow.CreateNew(entity, now);
partition.InsertOrReplace(dbRow);
return(partition, dbRow);
}
finally
{
_readerWriterLockSlim.ExitWriteLock();
}
}
public DbPartition InitPartitionFromSnapshot(IMyMemory data)
{
DbPartition partition = null;
ReaderWriterLockSlim.EnterWriteLock();
try
{
var initData = new ReadOnlyMemory <byte>(data.AsArray());
foreach (var dbRowMemory in new[] { initData }.SplitJsonArrayToObjects())
{
var jsonFields = dbRowMemory.ParseFirstLevelOfJson();
var entityInfo = jsonFields.GetEntityInfo();
if (!_partitions.ContainsKey(entityInfo.PartitionKey))
{
partition = DbPartition.Create(entityInfo.PartitionKey);
_partitions.Add(entityInfo.PartitionKey, partition);
}
if (partition == null)
{
partition = _partitions[entityInfo.PartitionKey];
}
var dbRow = DbRow.RestoreSnapshot(entityInfo, dbRowMemory);
partition.InsertOrReplace(dbRow);
}
}
finally
{
ReaderWriterLockSlim.ExitWriteLock();
}
return(partition);
}
public void PublishInitPartition(DbTable dbTable, DbPartition partition)
{
}
public void PublishInitPartition(DbTable dbTable, DbPartition partition)
{
ChangesHub.BroadCastInit(dbTable, partition);
}
public static PartitionSnapshot Create(DbTable table, DbPartition partition)
{
var dbRowsAsByteArray = partition.GetAllRows().ToJsonArray().AsArray();
return(Create(table.Name, partition.PartitionKey, dbRowsAsByteArray));
}
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));
}
