/// <summary>
/// Initializing Root Node
/// </summary>
/// <param name="DBreezeTableName">Real table name in DBreeze, that will hold the structure, must be synchronized with other tables in transaction</param>
/// <param name="tran"></param>
/// <param name="maximalInsertSpeed">will use DBreeze Technical_SetTable_OverwriteIsNotAllowed among transaction for DBreezeTableName</param>
public DataAsTree(string DBreezeTableName, DBreeze.Transactions.Transaction tran, bool maximalInsertSpeed = false)
{
if (tran == null)
throw new Exception("Transaction is null");
if (RootNode != null)
throw new Exception("Can't be more then one root node, use other constructor");
//Setting up RootNode
this.RootNode = this;
this.Transaction = tran;
this.maximalInsertSpeed = maximalInsertSpeed;
this.DBreezeTableName = DBreezeTableName;
this.NodeId = 0;
this.ParentNodeId = 0;
}
private void SetBlockHash(DBreeze.Transactions.Transaction transaction, HashHeightPair nextBlockHash)
{
this.blockHash = nextBlockHash;
transaction.Insert <byte[], byte[]>("BlockHash", blockHashKey, nextBlockHash.ToBytes());
}
public void SaveCurrentTip(DBreeze.Transactions.Transaction transaction, ChainedHeader tip)
{
SaveCurrentTip(transaction, (tip == null) ? null : new HashHeightPair(tip));
}
protected virtual void OnInsertTransactions(DBreeze.Transactions.Transaction dbreezeTransaction, List <(Transaction, Block)> transactions)
/// <inheritdoc />
public void SaveChanges(IList <UnspentOutputs> unspentOutputs, IEnumerable <TxOut[]> originalOutputs, uint256 oldBlockHash, uint256 nextBlockHash, int height, 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)))
{
uint256 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 <UnspentOutputs> toInsert = new List <UnspentOutputs>();
foreach (var coin in unspentOutputs.OrderBy(utxo => utxo.TransactionId, new UInt256Comparer()))
{
if (coin.IsPrunable)
{
this.logger.LogDebug("Outputs of transaction ID '{0}' are prunable and will be removed from the database.", coin.TransactionId);
transaction.RemoveKey("Coins", coin.TransactionId.ToBytes(false));
}
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.TransactionId, i, toInsert.Count);
transaction.Insert("Coins", coin.TransactionId.ToBytes(false), this.dBreezeSerializer.Serialize(coin.ToCoins()));
}
if (rewindDataList != null)
{
int nextRewindIndex = this.GetRewindIndex(transaction) + 1;
foreach (RewindData rewindData in rewindDataList)
{
this.logger.LogDebug("Rewind state #{0} created.", nextRewindIndex);
transaction.Insert("Rewind", nextRewindIndex, this.dBreezeSerializer.Serialize(rewindData));
nextRewindIndex++;
}
}
insertedEntities += unspentOutputs.Count;
transaction.Commit();
}
}
this.performanceCounter.AddInsertedEntities(insertedEntities);
}
/// <inheritdoc />
public Task SaveChangesAsync(IEnumerable <UnspentOutputs> unspentOutputs, IEnumerable <TxOut[]> originalOutputs, uint256 oldBlockHash, uint256 nextBlockHash, List <RewindData> rewindDataList = null)
{
List <UnspentOutputs> all = unspentOutputs.ToList();
this.logger.LogTrace("({0}.Count():{1},{2}:'{3}',{4}:'{5}')", nameof(unspentOutputs), all.Count, nameof(oldBlockHash), oldBlockHash, nameof(nextBlockHash), nextBlockHash);
int insertedEntities = 0;
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"); // Why it was there and what is it for? No one knows.
using (new StopwatchDisposable(o => this.PerformanceCounter.AddInsertTime(o)))
{
uint256 current = this.GetTipHash(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 (rewindDataList != null)
{
int nextRewindIndex = this.GetRewindIndex(transaction) + 1;
foreach (RewindData rewindData in rewindDataList)
{
this.logger.LogTrace("Rewind state #{0} created.", nextRewindIndex);
transaction.Insert("Rewind", nextRewindIndex, rewindData);
nextRewindIndex++;
}
}
insertedEntities += all.Count;
transaction.Commit();
}
}
this.PerformanceCounter.AddInsertedEntities(insertedEntities);
this.logger.LogTrace("(-)");
});
this.logger.LogTrace("(-)");
return(task);
}
public abstract long GetLastServerSyncTimeStamp(DBreeze.Transactions.Transaction tran);
/// <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(BlockHashHeightTable, blockHashHeightKey, this.dBreezeSerializer.Serialize(newTip));
}
/// <summary>
/// <para>Adding children to the node</para>
/// Table, storing data structure, must be in tran.SynchronizeTables list.
/// Then transaction must be Committed in the end by the programmer.
/// </summary>
/// <param name="nodes">Nodes to add to current node</param>
/// <param name="tran">Existing transaction. Table, storing data structure, must be in tran.SynchronizeTables list</param>
/// <param name="maximalSpeed">set it to true to gain maximal saving speed</param>
/// <returns>return node with setup parent id</returns>
public DataAsTree AddNode(DataAsTree node, DBreeze.Transactions.Transaction tran, bool maximalSpeed = false)
{
CheckTransaction(tran);
if (node == null)
{
throw new Exception("Nodes is not supplied");
}
SetupWriteTables(tran, maximalSpeed);
byte[] val = null;
long maxId = tran.Select <byte[], long>(this.DBreezeTableName, new byte[] { 1 }).Value;
bool skipToFillNameIndex = false;
if (node.NodeId == 0)
{
//Insert
node.ParentNodeId = this.NodeId;
maxId++;
node.NodeId = maxId;
}
else
{
//Update
var oldRow = nt2Write.Select <byte[], byte[]>(node.ParentNodeId.To_8_bytes_array_BigEndian().Concat(node.NodeId.To_8_bytes_array_BigEndian()));
if (oldRow.Exists)
{
var oldNode = SetupNodeFromRow(oldRow);
if (!oldNode.NodeName.Equals(node.NodeName, StringComparison.OrdinalIgnoreCase))
{
RemoveOldNodeFromNameIndex(oldNode.NodeName, node.ParentNodeId.To_8_bytes_array_BigEndian().Concat(node.NodeId.To_8_bytes_array_BigEndian()));
}
else
{
skipToFillNameIndex = true;
}
}
else
{
//Fake? We create new row
node.ParentNodeId = this.NodeId;
maxId++;
node.NodeId = maxId;
}
}
//ParentNodeId(long),NodeId(long)
byte[] key = node.ParentNodeId.To_8_bytes_array_BigEndian()
.Concat(node.NodeId.To_8_bytes_array_BigEndian());
if (node.NodeContent != null)
{
node.ContentRef = nt2Write.InsertDataBlock(node.ContentRef, node.NodeContent);
}
else
{
node.ContentRef = null;
}
val = SetupValueRowFromNode(node, 1);
CopyInternals(node);
nt2Write.Insert <byte[], byte[]>(key, val);
/*node.NodeName index support*/
if (!skipToFillNameIndex)
{
DBreeze.DataTypes.Row <string, byte[]> nodeNameIndexRow = null;
byte[] btNodeNameIndex = null;
nodeNameIndexRow = nt3Write.Select <string, byte[]>(node.NodeName.ToLower());
if (nodeNameIndexRow.Exists)
{
btNodeNameIndex = nodeNameIndexRow.Value.Concat(key);
}
else
{
btNodeNameIndex = key;
}
nt3Write.Insert <string, byte[]>(node.NodeName.ToLower(), btNodeNameIndex);
}
/*-----------------------------*/
//Latest used Id
tran.Insert <byte[], long>(this.DBreezeTableName, new byte[] { 1 }, maxId);
return(node);
}//eo func
/// <summary>
/// Removes node
/// </summary>
/// <param name="node"></param>
/// <param name="tran"></param>
/// <param name="maximalSpeed"></param>
public void RemoveNode(DataAsTree node, DBreeze.Transactions.Transaction tran, bool maximalSpeed = false)
{
this.RemoveNode(node.ParentNodeId, node.NodeId, tran, maximalSpeed);
}
private void CreateIndex(string name, bool multiValue, string builder, string[] dependencies, DBreeze.Transactions.Transaction transaction)
{
if (this.Indexes.ContainsKey(name))
{
throw new IndexStoreException("The '" + name + "' index already exists");
}
var index = new Index(this, name, multiValue, builder, dependencies);
this.Indexes[name] = index;
var dbIndex = transaction.Select <string, string>("Common", index.Table);
if (dbIndex.Exists)
{
transaction.RemoveAllKeys(index.Table, true);
}
if (!this.tableNames.Contains(index.Table))
{
this.tableNames.Add(index.Table);
}
var transactions = new List <(Transaction, Block)>();
foreach (var row in transaction.SelectForward <byte[], Block>("Block"))
{
var block = row.Value;
var key = block.GetHash().ToBytes();
foreach (var transaction2 in block.Transactions)
{
transactions.Add((transaction2, block));
}
if (transactions.Count >= 5000)
{
index.IndexTransactionDetails(transactions);
transactions.Clear();
}
}
index.IndexTransactionDetails(transactions);
transaction.Insert <string, string>("Common", index.Table, index.ToString());
}
public static byte[] Get(DBreeze.Transactions.Transaction dbTx, byte[] contactHash)
{
var row = dbTx.Select <byte[], byte[]>(TABLE, contactHash);
return(row.Exists ? row.Value : null);
}
public static void Add(DBreeze.Transactions.Transaction dbTx, byte[] contactHash, byte[] txHash)
{
dbTx.Insert <byte[], byte[]>(TABLE, contactHash, txHash);
}
public byte[] GetLast(DBreeze.Transactions.Transaction dbTx)
{
var record = dbTx.SelectBackward <uint, byte[]>(TABLE).First();
return(record == null ? null : record.Value);
}
public void Add(DBreeze.Transactions.Transaction dbTx, uint blockNumber, byte[] block)
{
dbTx.Insert <uint, byte[]>(TABLE, blockNumber, block);
}
/// <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 PutStakeInternal(DBreeze.Transactions.Transaction transaction, IEnumerable <StakeItem> stakeEntries)
{
throw new NotImplementedException();
}
/// <summary>
///
/// </summary>
/// <param name="_tran"></param>
/// <param name="_DocumentsStorageTablesPrefix"></param>
public InTran_DocumentAppender(DBreeze.Transactions.Transaction _tran, string _DocumentsStorageTablesPrefix)
{
if(_tran == null)
throw new Exception("DocumentAppender transaction is null");
tran = _tran;
//documentSpaceId = _documentSpaceId;
DocumentsStorageTablesPrefix = _DocumentsStorageTablesPrefix;
}
public abstract List <SyncOperation> GetSyncOperations(DBreeze.Transactions.Transaction tran, out bool repeatSync);
protected override void OnInsertTransactions(DBreeze.Transactions.Transaction dbreezeTransaction, List <(Transaction, Block)> transactions)
private void SaveHighestPollId(DBreeze.Transactions.Transaction transaction)
{
transaction.Insert <byte[], int>(TableName, RepositoryHighestIndexKey, this.highestPollId);
}
public int IndexTransactionDetails(DBreeze.Transactions.Transaction dbreezeTransaction, List <(Transaction, Block)> transactions, bool remove = false)
/// <inheritdoc />
public 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();
var 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.GetTipHash(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);
}
private void AddBusinessType(DBreeze.Transactions.Transaction t, BusinessTypeModel _model)
{
t.Insert <string, string>(Datalog._Business_Type, _model.key, _model.remark);
}
public void PutAsyncWritesBlocksAndTransactionsToDbAndSavesNextBlockHash()
{
string dir = CreateTestDir(this);
var nextBlockHash = new uint256(1241256);
var blocks = new List <Block>();
Block block = this.Network.Consensus.ConsensusFactory.CreateBlock();
BlockHeader blockHeader = block.Header;
blockHeader.Bits = new Target(12);
Transaction transaction = this.Network.CreateTransaction();
transaction.Version = 32;
block.Transactions.Add(transaction);
transaction = this.Network.CreateTransaction();
transaction.Version = 48;
block.Transactions.Add(transaction);
blocks.Add(block);
Block block2 = this.Network.Consensus.ConsensusFactory.CreateBlock();
block2.Header.Nonce = 11;
transaction = this.Network.CreateTransaction();
transaction.Version = 15;
block2.Transactions.Add(transaction);
blocks.Add(block2);
using (var engine = new DBreezeEngine(dir))
{
DBreeze.Transactions.Transaction trans = engine.GetTransaction();
trans.Insert <byte[], byte[]>("Common", new byte[0], this.DBreezeSerializer.Serialize(new HashHeightPair(uint256.Zero, 1)));
trans.Insert <byte[], bool>("Common", new byte[1], true);
trans.Commit();
}
using (IBlockRepository repository = this.SetupRepository(this.Network, dir))
{
Task task = repository.PutAsync(new HashHeightPair(nextBlockHash, 100), blocks);
task.Wait();
}
using (var engine = new DBreezeEngine(dir))
{
DBreeze.Transactions.Transaction trans = engine.GetTransaction();
Row <byte[], byte[]> blockHashKeyRow = trans.Select <byte[], byte[]>("Common", new byte[0]);
Dictionary <byte[], byte[]> blockDict = trans.SelectDictionary <byte[], byte[]>("Block");
Dictionary <byte[], byte[]> transDict = trans.SelectDictionary <byte[], byte[]>("Transaction");
Assert.Equal(new HashHeightPair(nextBlockHash, 100), this.DBreezeSerializer.Deserialize <HashHeightPair>(blockHashKeyRow.Value));
Assert.Equal(2, blockDict.Count);
Assert.Equal(3, transDict.Count);
foreach (KeyValuePair <byte[], byte[]> item in blockDict)
{
Block bl = blocks.Single(b => b.GetHash() == new uint256(item.Key));
Assert.Equal(bl.Header.GetHash(), Block.Load(item.Value, this.Network).Header.GetHash());
}
foreach (KeyValuePair <byte[], byte[]> item in transDict)
{
Block bl = blocks.Single(b => b.Transactions.Any(t => t.GetHash() == new uint256(item.Key)));
Assert.Equal(bl.GetHash(), new uint256(item.Value));
}
}
}
private void DeleteBusinessType(DBreeze.Transactions.Transaction t, BusinessTypeModel _model)
{
t.RemoveKey(Datalog._Business_Type, _model.key, out bool wasremoved);
t.RemoveAllKeys(_model.key, true);
}
private void ResetLocked(DBreeze.Transactions.Transaction transaction)
{
this.highestPollId = -1;
transaction.RemoveAllKeys(DataTable, true);
this.CurrentTip = null;
}
private void AddBusinessData(DBreeze.Transactions.Transaction t, BusinessDataModel _model)
{
t.Insert <string, string>(_model.tableName, _model.key, _model.content);
}
public void Initialize()
{
// Load highest index.
lock (this.lockObject)
{
using (DBreeze.Transactions.Transaction transaction = this.dbreeze.GetTransaction())
{
try
{
List <Poll> polls = GetAllPolls(transaction);
// If the polls repository contains duplicate polls then reset the highest poll id and
// set the tip to null.
// This will trigger the VotingManager to rebuild the voting and polls repository as the
// polls repository tip is null. This happens later during startup, see VotingManager.Synchronize()
var uniquePolls = new HashSet <Poll>(polls);
if (uniquePolls.Count != polls.Count)
{
this.logger.LogWarning("The polls repository contains {0} duplicate polls, it will be rebuilt.", polls.Count - uniquePolls.Count);
this.ResetLocked(transaction);
transaction.Commit();
return;
}
// Check to see if a polls repository tip is saved, if not rebuild the repo.
Row <byte[], byte[]> rowTip = transaction.Select <byte[], byte[]>(DataTable, RepositoryTipKey);
if (!rowTip.Exists)
{
this.logger.LogInformation("The polls repository tip is unknown, it will be rebuilt.");
this.ResetLocked(transaction);
transaction.Commit();
return;
}
// Check to see if the polls repo tip exists in chain.
// The node could have been rewound so we need to rebuild the repo from that point.
this.CurrentTip = this.dBreezeSerializer.Deserialize <HashHeightPair>(rowTip.Value);
ChainedHeader chainedHeaderTip = this.chainIndexer.GetHeader(this.CurrentTip.Hash);
if (chainedHeaderTip != null)
{
this.highestPollId = (polls.Count > 0) ? polls.Max(p => p.Id) : -1;
this.logger.LogInformation("Polls repository tip exists on chain; initializing at height {0}; highest poll id: {1}.", this.CurrentTip.Height, this.highestPollId);
return;
}
this.logger.LogInformation("The polls repository tip {0} was not found in the consensus chain, determining fork.", this.CurrentTip);
// The polls repository tip could not be found in the chain.
// Look at all other known hash/height pairs to find something in common with the consensus chain.
// We will take that as the last known valid height.
int maxGoodHeight = -1;
foreach (Poll poll in polls)
{
if (poll.PollStartBlockData.Height > maxGoodHeight && this.chainIndexer.GetHeader(poll.PollStartBlockData.Hash) != null)
{
maxGoodHeight = poll.PollStartBlockData.Height;
}
if (poll.PollExecutedBlockData?.Height > maxGoodHeight && this.chainIndexer.GetHeader(poll.PollExecutedBlockData.Hash) != null)
{
maxGoodHeight = poll.PollExecutedBlockData.Height;
}
if (poll.PollVotedInFavorBlockData?.Height > maxGoodHeight && this.chainIndexer.GetHeader(poll.PollVotedInFavorBlockData.Hash) != null)
{
maxGoodHeight = poll.PollVotedInFavorBlockData.Height;
}
}
if (maxGoodHeight == -1)
{
this.logger.LogInformation("No common blocks found; the repo will be rebuilt from scratch.");
this.ResetLocked(transaction);
transaction.Commit();
return;
}
this.CurrentTip = new HashHeightPair(this.chainIndexer.GetHeader(maxGoodHeight));
this.logger.LogInformation("Common block found at height {0}; the repo will be rebuilt from there.", this.CurrentTip.Height);
// Trim polls to tip.
HashSet <Poll> pollsToDelete = new HashSet <Poll>();
foreach (Poll poll in polls)
{
if (poll.PollStartBlockData.Height > this.CurrentTip.Height)
{
pollsToDelete.Add(poll);
this.logger.LogDebug("Poll {0} will be deleted.", poll.Id);
continue;
}
bool modified = false;
if (poll.PubKeysHexVotedInFavor.Any(v => v.Height > this.CurrentTip.Height))
{
poll.PubKeysHexVotedInFavor = poll.PubKeysHexVotedInFavor.Where(v => v.Height <= this.CurrentTip.Height).ToList();
modified = true;
}
if (poll.PollExecutedBlockData?.Height > this.CurrentTip.Height)
{
poll.PollExecutedBlockData = null;
modified = true;
}
if (poll.PollVotedInFavorBlockData?.Height > this.CurrentTip.Height)
{
poll.PollVotedInFavorBlockData = null;
modified = true;
}
// Check if the current tip is before the poll expiry activation block,
// if so un-expire it.
if (poll.IsExpired && !IsPollExpiredAt(poll, chainedHeaderTip, this.network))
{
this.logger.LogDebug("Un-expiring poll {0}.", poll.Id);
poll.IsExpired = false;
modified = true;
}
if (modified)
{
UpdatePoll(transaction, poll);
}
}
DeletePollsAndSetHighestPollId(transaction, pollsToDelete.Select(p => p.Id).ToArray());
SaveCurrentTip(transaction, this.CurrentTip);
transaction.Commit();
this.logger.LogInformation("Polls repository initialized at height {0}; highest poll id: {1}.", this.CurrentTip.Height, this.highestPollId);
}
catch (Exception err) when(err.Message == "No more byte to read")
{
this.logger.LogWarning("There was an error reading the polls repository, it will be rebuild.");
this.ResetLocked(transaction);
transaction.Commit();
}
}
}
}
private void DeleteBusinessData(DBreeze.Transactions.Transaction t, BusinessDataModel businessDataModel)
{
t.RemoveKey <string>(businessDataModel.tableName, businessDataModel.key, out bool wasremoved);
}
/// <summary>
/// Set's the tip of the coinview to a new block hash.
/// </summary>
/// <param name="transaction">Open DBreeze transaction.</param>
/// <param name="nextBlockHash">Hash of the block to become the new tip.</param>
private void SetBlockHash(DBreeze.Transactions.Transaction transaction, uint256 nextBlockHash)
{
this.blockHash = nextBlockHash;
transaction.Insert <byte[], uint256>("BlockHash", blockHashKey, nextBlockHash);
}
public override List <SyncOperation> GetSyncOperations(DBreeze.Transactions.Transaction tran, out bool repeatSync)
{
var syncList = new List <SyncOperation>();
_newLocalSyncTimeStamp = DateTime.UtcNow.Ticks; //This value will be applied if there is nothing to synchronize
repeatSync = false;
var changedEntities = new Dictionary <long, Tuple <long, bool> >(); //Key is entityId, Value is Synctimestamp
var entityType = typeof(T).FullName;
var lastLocalSyncTimeStamp = tran.Select <byte[], long>(_entitySync.entityTable, new byte[] { LocalSyncTS, 1 }).Value;
foreach (var row in
tran.SelectForwardFromTo <byte[], byte[]>(_entitySync.entityTable,
new byte[] { SyncLog }.ConcatMany((lastLocalSyncTimeStamp + 1).To_8_bytes_array_BigEndian(), long.MinValue.To_8_bytes_array_BigEndian()),
true, //true, but LastLocalSyncTimeStamp+1 is used
new byte[] { SyncLog }.ConcatMany(long.MaxValue.To_8_bytes_array_BigEndian(), long.MaxValue.To_8_bytes_array_BigEndian()),
true))
{
if (changedEntities.Count > _entitySync.LimitationOfEntitesPerRound)
{
repeatSync = true;
break;
}
//We will leave only last update of the particular entity
if (!changedEntities.TryGetValue(row.Key.Substring(9, 8).To_Int64_BigEndian(), out var tpl1))
{
changedEntities[row.Key.Substring(9, 8).To_Int64_BigEndian()] = new Tuple <long, bool>(row.Key.Substring(1, 8).To_Int64_BigEndian(),
(row.Value?.Length >= 1 && row.Value[0] == 1) ? true : false) //indicating that new entity was inserted
;
}
else
{
changedEntities[row.Key.Substring(9, 8).To_Int64_BigEndian()] = new Tuple <long, bool>(row.Key.Substring(1, 8).To_Int64_BigEndian(),
(tpl1.Item2 || (row.Value?.Length >= 1 && row.Value[0] == 1)) ? true : false) //indicating that new entity was inserted (from any of inserts that must be done for the id)
;
}
_newLocalSyncTimeStamp = row.Key.Substring(1, 8).To_Int64_BigEndian();
}
foreach (var ent in changedEntities.OrderBy(r => r.Key))
{
var rowEntity = tran.Select <byte[], byte[]>(_entitySync.entityTable, new byte[] { Entity }.Concat(ent.Key.To_8_bytes_array_BigEndian()));
var syncOperation = new SyncOperation()
{
ExternalId = ent.Value.Item2 ? 0 : ent.Key, //if entity new ExternalId will be 0 otherwise will equal to InternalId and higher than 0
InternalId = ent.Key,
Operation = rowEntity.Exists ? SyncOperation.eOperation.INSERT : SyncOperation.eOperation.REMOVE,
Type = entityType,
SyncTimestamp = ent.Value.Item1
};
if (rowEntity.Exists)
{
syncOperation.SerializedObject = rowEntity.GetDataBlockWithFixedAddress <byte[]>();
}
syncList.Add(syncOperation);
}
return(syncList);
}
