private void EnsurePersisted(ulong root, RocksDbAtomicWrite batch)
{
if (root == 0)
{
return;
}
if (!_nodeCache.TryGetValue(root, out var node) || _persistedNodes.Contains(root))
{
return;
}
foreach (var child in node.Children)
{
EnsurePersisted(child, batch);
}
_repository.WriteNodeToBatch(root, node, batch);
var lockTaken = false;
_dataLock.Enter(ref lockTaken);
try
{
_persistedNodes.Add(root);
}
finally
{
if (lockTaken)
{
_dataLock.Exit();
}
}
}
public void WriteNodeToBatch(ulong id, IHashTrieNode node, RocksDbAtomicWrite tx)
{
var prefix = EntryPrefix.PersistentHashMap.BuildPrefix(id);
tx.Put(prefix, NodeSerializer.ToBytes(node));
var hashPrefix = EntryPrefix.VersionByHash.BuildPrefix(node.Hash);
tx.Put(hashPrefix, UInt64Utils.ToBytes(id));
}
public void CommitIds()
{
RocksDbAtomicWrite tx = new RocksDbAtomicWrite(_dbContext);
foreach (var item in _idCache)
{
tx.Put(EntryPrefix.VersionByHash.BuildPrefix(HexUtils.HexToBytes(item.Key)), UInt64Utils.ToBytes(item.Value));
}
tx.Commit();
_idCache.Clear();
}
public void Commit()
{
var batch = new RocksDbAtomicWrite(_dbContext);
_balanceManager.Commit(batch);
_contractManager.Commit(batch);
_storageManager.Commit(batch);
_transactionManager.Commit(batch);
_blockManager.Commit(batch);
_eventManager.Commit(batch);
_validatorManager.Commit(batch);
batch.Commit();
ClearCache();
}
public void CommitNodes()
{
RocksDbAtomicWrite tx = new RocksDbAtomicWrite(_dbContext);
foreach (var item in _nodeCache)
{
tx.Put(EntryPrefix.PersistentHashMap.BuildPrefix(item.Key), NodeSerializer.ToBytes(item.Value));
Console.WriteLine("Adding node to DB : " + item.Key);
}
ulong nodesCnt = UInt64Utils.FromBytes(_dbContext.Get(EntryPrefix.NodesDownloadedTillNow.BuildPrefix()));
nodesCnt += (ulong)_nodeCache.Count;
tx.Put(EntryPrefix.NodesDownloadedTillNow.BuildPrefix(), UInt64Utils.ToBytes(nodesCnt));
tx.Commit();
_nodeCache.Clear();
}
public void Checkpoint(ulong root, RocksDbAtomicWrite batch)
{
EnsurePersisted(root, batch);
var lockTaken = false;
_dataLock.Enter(ref lockTaken);
try
{
foreach (var item in _nodeCache)
{
_toBeDeleted.Add(item.Key);
}
}
finally
{
if (lockTaken)
{
_dataLock.Exit();
}
}
}
public void AddAndRemoveTransaction(TransactionReceipt txToAdd, TransactionReceipt txToRemove)
{
/* write transaction to storage */
var batch = new RocksDbAtomicWrite(_rocksDbContext);
var prefixTx = EntryPrefix.TransactionByHash.BuildPrefix(txToRemove.Hash);
batch.Delete(prefixTx);
prefixTx = EntryPrefix.TransactionByHash.BuildPrefix(txToAdd.Hash);
batch.Put(prefixTx, txToAdd.ToByteArray());
/* add transaction to pool */
var pool = GetTransactionPool();
pool.Remove(txToRemove.Hash);
if (!pool.Contains(txToAdd.Hash))
{
pool.Add(txToAdd.Hash);
}
prefixTx = EntryPrefix.TransactionPool.BuildPrefix();
batch.Put(prefixTx, pool.TransactionHashListToByteArray());
batch.Commit();
}
public void Commit(RocksDbAtomicWrite batch)
{
_lastApprovedSnapshot.Commit(batch);
}
public void Commit(RocksDbAtomicWrite batch)
{
_state.Commit(batch);
}
public void Commit(RocksDbAtomicWrite batch)
{
throw new Exception("Invalid function used");
}
private void UpdateBatch()
{
batch = new RocksDbAtomicWrite(_dbContext);
_memDb.Clear();
}
public void SetVersion(uint repository, ulong version, RocksDbAtomicWrite tx)
{
tx.Put(EntryPrefix.StorageVersionIndex.BuildPrefix(repository), version.ToBytes().ToArray());
}
public void DeleteNodeToBatch(ulong id, RocksDbAtomicWrite tx)
{
var prefix = EntryPrefix.PersistentHashMap.BuildPrefix(id);
tx.Delete(prefix);
}
