public void Add(DBreeze.Transactions.Transaction dbTx, uint blockNumber, byte[] block)
{
dbTx.Insert <uint, byte[]>(TABLE, blockNumber, block);
}
/// <inheritdoc />
public override Task SaveChangesAsync(IEnumerable <UnspentOutputs> unspentOutputs, IEnumerable <TxOut[]> originalOutputs, uint256 oldBlockHash, uint256 nextBlockHash)
{
this.logger.LogTrace("({0}.Count():{1},{2}.Count():{3},{4}:'{5}',{6}:'{7}')", nameof(unspentOutputs), unspentOutputs?.Count(), nameof(originalOutputs), originalOutputs?.Count(), nameof(oldBlockHash), oldBlockHash, nameof(nextBlockHash), nextBlockHash);
RewindData rewindData = originalOutputs != null ? new RewindData(oldBlockHash) : null;
int insertedEntities = 0;
List <UnspentOutputs> all = unspentOutputs.ToList();
Dictionary <uint256, TxOut[]> unspentToOriginal = new Dictionary <uint256, TxOut[]>(all.Count);
using (new StopwatchDisposable(o => this.PerformanceCounter.AddInsertTime(o)))
{
if (originalOutputs != null)
{
IEnumerator <TxOut[]> originalEnumerator = originalOutputs.GetEnumerator();
foreach (UnspentOutputs output in all)
{
originalEnumerator.MoveNext();
unspentToOriginal.Add(output.TransactionId, originalEnumerator.Current);
}
}
}
Task task = Task.Run(() =>
{
this.logger.LogTrace("()");
using (DBreeze.Transactions.Transaction transaction = this.dbreeze.GetTransaction())
{
transaction.ValuesLazyLoadingIsOn = false;
transaction.SynchronizeTables("BlockHash", "Coins", "Rewind");
transaction.Technical_SetTable_OverwriteIsNotAllowed("Coins");
using (new StopwatchDisposable(o => this.PerformanceCounter.AddInsertTime(o)))
{
uint256 current = this.GetCurrentHash(transaction);
if (current != oldBlockHash)
{
this.logger.LogTrace("(-)[BLOCKHASH_MISMATCH]");
throw new InvalidOperationException("Invalid oldBlockHash");
}
this.SetBlockHash(transaction, nextBlockHash);
all.Sort(UnspentOutputsComparer.Instance);
foreach (UnspentOutputs coin in all)
{
this.logger.LogTrace("Outputs of transaction ID '{0}' are {1} and will be {2} to the database.", coin.TransactionId, coin.IsPrunable ? "PRUNABLE" : "NOT PRUNABLE", coin.IsPrunable ? "removed" : "inserted");
if (coin.IsPrunable)
{
transaction.RemoveKey("Coins", coin.TransactionId.ToBytes(false));
}
else
{
transaction.Insert("Coins", coin.TransactionId.ToBytes(false), coin.ToCoins());
}
if (originalOutputs != null)
{
TxOut[] original = null;
unspentToOriginal.TryGetValue(coin.TransactionId, out original);
if (original == null)
{
// This one haven't existed before, if we rewind, delete it.
rewindData.TransactionsToRemove.Add(coin.TransactionId);
}
else
{
// We'll need to restore the original outputs.
UnspentOutputs clone = coin.Clone();
clone.Outputs = original.ToArray();
rewindData.OutputsToRestore.Add(clone);
}
}
}
if (rewindData != null)
{
int nextRewindIndex = this.GetRewindIndex(transaction) + 1;
this.logger.LogTrace("Rewind state #{0} created.", nextRewindIndex);
transaction.Insert("Rewind", nextRewindIndex, rewindData);
}
insertedEntities += all.Count;
transaction.Commit();
}
}
this.PerformanceCounter.AddInsertedEntities(insertedEntities);
this.logger.LogTrace("(-)");
});
this.logger.LogTrace("(-)");
return(task);
}
public void SaveChanges(IList <UnspentOutput> unspentOutputs, HashHeightPair oldBlockHash, HashHeightPair nextBlockHash, List <RewindData> rewindDataList = null)
{
int insertedEntities = 0;
using (DBreeze.Transactions.Transaction transaction = this.CreateTransaction())
{
transaction.ValuesLazyLoadingIsOn = false;
transaction.SynchronizeTables("BlockHash", "Coins", "Rewind");
// Speed can degrade when keys are in random order and, especially, if these keys have high entropy.
// This settings helps with speed, see dBreeze documentations about details.
// We should double check if this settings help in our scenario, or sorting keys and operations is enough.
// Refers to issue #2483. https://github.com/stratisproject/StratisBitcoinFullNode/issues/2483
transaction.Technical_SetTable_OverwriteIsNotAllowed("Coins");
using (new StopwatchDisposable(o => this.performanceCounter.AddInsertTime(o)))
{
HashHeightPair current = this.GetTipHash(transaction);
if (current != oldBlockHash)
{
this.logger.LogTrace("(-)[BLOCKHASH_MISMATCH]");
throw new InvalidOperationException("Invalid oldBlockHash");
}
this.SetBlockHash(transaction, nextBlockHash);
// Here we'll add items to be inserted in a second pass.
List <UnspentOutput> toInsert = new List <UnspentOutput>();
foreach (var coin in unspentOutputs.OrderBy(utxo => utxo.OutPoint, new OutPointComparer()))
{
if (coin.Coins == null)
{
this.logger.LogDebug("Outputs of transaction ID '{0}' are prunable and will be removed from the database.", coin.OutPoint);
transaction.RemoveKey("Coins", coin.OutPoint.ToBytes());
}
else
{
// Add the item to another list that will be used in the second pass.
// This is for performance reasons: dBreeze is optimized to run the same kind of operations, sorted.
toInsert.Add(coin);
}
}
for (int i = 0; i < toInsert.Count; i++)
{
var coin = toInsert[i];
this.logger.LogDebug("Outputs of transaction ID '{0}' are NOT PRUNABLE and will be inserted into the database. {1}/{2}.", coin.OutPoint, i, toInsert.Count);
transaction.Insert("Coins", coin.OutPoint.ToBytes(), this.dataStoreSerializer.Serialize(coin.Coins));
}
if (rewindDataList != null)
{
foreach (RewindData rewindData in rewindDataList)
{
var nextRewindIndex = rewindData.PreviousBlockHash.Height + 1;
this.logger.LogDebug("Rewind state #{0} created.", nextRewindIndex);
transaction.Insert("Rewind", nextRewindIndex, this.dataStoreSerializer.Serialize(rewindData));
}
}
insertedEntities += unspentOutputs.Count;
transaction.Commit();
}
}
this.performanceCounter.AddInsertedEntities(insertedEntities);
}
private void SetBlockHash(DBreeze.Transactions.Transaction transaction, HashHeightPair nextBlockHash)
{
this.blockHash = nextBlockHash;
transaction.Insert <byte[], byte[]>("BlockHash", blockHashKey, nextBlockHash.ToBytes());
}
/// <summary>
/// Set's the hash and height tip of the new <see cref="ProvenBlockHeader"/>.
/// </summary>
/// <param name="transaction"> Open DBreeze transaction.</param>
/// <param name="newTip"> Hash height pair of the new block tip.</param>
private void SetTip(DBreeze.Transactions.Transaction transaction, HashHeightPair newTip)
{
Guard.NotNull(newTip, nameof(newTip));
transaction.Insert <byte[], HashHeightPair>(BlockHashHeightTable, blockHashHeightKey, newTip);
}
private void SaveTip(HashHeightPair tipToSave, DBreeze.Transactions.Transaction transaction)
{
transaction.Insert <byte[], byte[]>(TableName, TipKey.ToBytes(), this.dBreezeSerializer.Serialize(tipToSave));
}