public void Can_resync_if_missed_a_block()
{
_remoteBlockTree = Build.A.BlockTree(_genesisBlock).OfChainLength(SyncBatchSize.Max).TestObject;
ISyncPeer peer = new SyncPeerMock(_remoteBlockTree);
SemaphoreSlim semaphore = new SemaphoreSlim(0);
_synchronizer.SyncEvent += (sender, args) =>
{
if (args.SyncEvent == SyncEvent.Completed || args.SyncEvent == SyncEvent.Failed)
{
semaphore.Release(1);
}
};
_pool.Start();
_synchronizer.Start();
_pool.AddPeer(peer);
BlockTreeBuilder.ExtendTree(_remoteBlockTree, SyncBatchSize.Max * 2);
_syncServer.AddNewBlock(_remoteBlockTree.RetrieveHeadBlock(), peer);
semaphore.Wait(_standardTimeoutUnit);
semaphore.Wait(_standardTimeoutUnit);
Assert.AreEqual(SyncBatchSize.Max * 2 - 1, (int)_blockTree.BestSuggestedHeader.Number);
}
public async Task Can_resync_if_missed_a_block()
{
_remoteBlockTree = Build.A.BlockTree(_genesisBlock).OfChainLength(QueueBasedSyncManager.MaxBatchSize).TestObject;
ISynchronizationPeer peer = new SynchronizationPeerMock(_remoteBlockTree);
SemaphoreSlim semaphore = new SemaphoreSlim(0);
_manager.SyncEvent += (sender, args) =>
{
if (args.SyncStatus == SyncStatus.Completed || args.SyncStatus == SyncStatus.Failed)
{
semaphore.Release(1);
}
};
_manager.Start();
Task addPeerTask = _manager.AddPeer(peer);
Task firstToComplete = await Task.WhenAny(addPeerTask, Task.Delay(_standardTimeoutUnit));
Assert.AreSame(addPeerTask, firstToComplete);
BlockTreeBuilder.ExtendTree(_remoteBlockTree, QueueBasedSyncManager.MaxBatchSize * 2);
_manager.AddNewBlock(_remoteBlockTree.RetrieveHeadBlock(), peer.NodeId);
semaphore.Wait(_standardTimeoutUnit);
semaphore.Wait(_standardTimeoutUnit);
Assert.AreEqual(QueueBasedSyncManager.MaxBatchSize * 2 - 1, (int)_blockTree.BestSuggested.Number);
}
public static void ExtendTree(IBlockTree blockTree, long newChainLength)
{
Block previous = blockTree.RetrieveHeadBlock();
long initialLength = previous.Number + 1;
for (long i = initialLength; i < newChainLength; i++)
{
previous = Build.A.Block.WithNumber(i).WithParent(previous).TestObject;
blockTree.SuggestBlock(previous);
blockTree.UpdateMainChain(new[] { previous }, true);
}
}
public static void ExtendTree(IBlockTree blockTree, int newChainLength)
{
Block previous = blockTree.RetrieveHeadBlock();
int initialLength = (int)previous.Number + 1;
for (int i = initialLength; i < newChainLength; i++)
{
previous = Build.A.Block.WithNumber(i).WithParent(previous).TestObject;
blockTree.SuggestBlock(previous);
blockTree.MarkAsProcessed(previous.Hash);
blockTree.MoveToMain(previous.Hash);
}
}
public async Task Can_resync_if_missed_a_block()
{
_remoteBlockTree = Build.A.BlockTree(_genesisBlock).OfChainLength(SynchronizationManager.BatchSize).TestObject;
ISynchronizationPeer peer = new SynchronizationPeerMock(_remoteBlockTree);
ManualResetEvent resetEvent = new ManualResetEvent(false);
_manager.SyncEvent += (sender, args) => { resetEvent.Set(); };
Task addPeerTask = _manager.AddPeer(peer);
Task firstToComplete = await Task.WhenAny(addPeerTask, Task.Delay(2000));
Assert.AreSame(addPeerTask, firstToComplete);
_manager.Start();
resetEvent.WaitOne(TimeSpan.FromMilliseconds(2000));
BlockTreeBuilder.ExtendTree(_remoteBlockTree, SynchronizationManager.BatchSize * 2);
_manager.AddNewBlock(_remoteBlockTree.RetrieveHeadBlock(), peer.NodeId);
Assert.AreEqual(SynchronizationManager.BatchSize * 2 - 1, (int)_blockTree.BestSuggested.Number);
}
