static void rq_MessageReceived(object sender, QueueItemEventArgs e)
{
IAsyncQueue rq = (IAsyncQueue)sender;
rq.Completed(e.Item.ItemId, (int)ItemState.Commit, e.Item.HasAttach);
Console.WriteLine("MessageReceived: " + e.Item.ItemId);
}
public BlockStoreSignaled(
IBlockStoreQueue blockStoreQueue,
StoreSettings storeSettings,
IChainState chainState,
IConnectionManager connection,
INodeLifetime nodeLifetime,
ILoggerFactory loggerFactory,
IInitialBlockDownloadState initialBlockDownloadState,
ISignals signals,
IAsyncProvider asyncProvider)
{
this.blockStoreQueue = blockStoreQueue;
this.chainState = chainState;
this.connection = connection;
this.nodeLifetime = nodeLifetime;
this.logger = loggerFactory.CreateLogger(GetType().FullName);
this.storeSettings = storeSettings;
this.initialBlockDownloadState = initialBlockDownloadState;
this.signals = signals;
this.asyncProvider = asyncProvider;
this.blocksToAnnounce = asyncProvider.CreateAsyncQueue <ChainedHeader>();
this.dequeueLoopTask = DequeueContinuouslyAsync();
this.asyncProvider.RegisterTask($"{nameof(BlockStoreSignaled)}.{nameof(this.dequeueLoopTask)}",
this.dequeueLoopTask);
}
/// <summary>
/// 清空队列。
/// </summary>
public static async Task Clear <T>(this IAsyncQueue <T> aq, TimeSpan timeout)
{
using (var source = new CancellationTokenSource(timeout))
{
await aq.Clear(source.Token);
}
}
/// <summary>
/// 移除并返回位于队列开始处的对象。
/// </summary>
public static async Task <T> Dequeue <T>(this IAsyncQueue <T> aq, TimeSpan timeout)
{
using (var source = new CancellationTokenSource(timeout))
{
return(await aq.Dequeue(source.Token));
}
}
static void rq_MessageArraived(object sender, QueueItemEventArgs e)
{
IAsyncQueue rq = (IAsyncQueue)sender;
IQueueItem item = rq.Dequeue();
Console.WriteLine("MessageArraived: " + item.ItemId);
}
/// <summary>
/// 清空队列。
/// </summary>
public static async Task Clear <T>(this IAsyncQueue <T> aq, int millisecondsTimeout)
{
using (var source = new CancellationTokenSource(millisecondsTimeout))
{
await aq.Clear(source.Token);
}
}
public ILargeMessageQueue <T> Create <T>(
IAsyncQueue <LargeMessageReference> referenceQueue,
IAsyncBlockBlobRepository blobRepository,
ILargeMessageQueueErrorHandler errorHandler) where T : class
{
return(new LargeMessageQueue <T>(_serializer, referenceQueue, blobRepository, _loggerFactory.CreateLogger <LargeMessageQueue <T> >(), errorHandler));
}
/// <summary>
/// Worker of <see cref="AsyncQueue_DequeueParallelAsync"/> test that tries to consume items from the queue
/// until the last item is reached or cancellation is triggered.
/// </summary>
/// <param name="asyncQueue">Queue to consume items from.</param>
/// <param name="list">List to add consumed items to.</param>
/// <param name="lastItem">Value of the last item that will be added to the queue.</param>
/// <param name="cts">Cancellation source to cancel when we are done.</param>
private async Task AsyncQueue_DequeueParallelAsync_WorkerAsync(IAsyncQueue <int> asyncQueue, List <int> list, int lastItem, CancellationTokenSource cts)
{
while (true)
{
try
{
int item = await asyncQueue.DequeueAsync(cts.Token);
await Task.Delay(this.random.Next(10));
list.Add(item);
// If we reached the last item, signal cancel to the other worker and finish.
if (item == lastItem)
{
cts.Cancel();
break;
}
}
catch (OperationCanceledException)
{
break;
}
}
}
/// <summary>
/// 将对象添加到队列的结尾处。
/// </summary>
/// <param name="item">要添加到的对象。</param>
public static async Task Enqueue <T>(this IAsyncQueue <T> aq, T item, TimeSpan timeout)
{
using (var source = new CancellationTokenSource(timeout))
{
await aq.Enqueue(item, CancellationToken.None);
}
}
/// <summary>
/// Calls <see cref="Initialize"/> method.
/// </summary>
/// <param name="name"></param>
/// <param name="asyncQueue"></param>
/// <param name="consumerCount"></param>
/// <param name="priority"></param>
public AsyncQueue(
string name,
IAsyncQueue asyncQueue,
int consumerCount,
ThreadPriority priority)
{
Initialize(name, asyncQueue, consumerCount, priority);
}
/// <summary>
/// Initializes the instance of the object and subscribes to the peer's message producer.
/// </summary>
/// <param name="peer">Connected network peer that we receive messages from.</param>
public NetworkPeerListener(INetworkPeer peer, IAsyncProvider asyncProvider)
{
this.peer = peer;
this.asyncProvider = asyncProvider;
this.asyncIncomingMessagesQueue = asyncProvider.CreateAsyncQueue <IncomingMessage>();
this.messageProducerRegistration = peer.MessageProducer.AddMessageListener(this);
}
public ILargeMessageQueue <T> Create <T>(string queueName, string blobContainerName, ILargeMessageQueueErrorHandler errorHandler) where T : class
{
IAsyncQueue <LargeMessageReference> referenceQueue = _queueFactory.CreateAsyncQueue <LargeMessageReference>(queueName);
IAsyncBlockBlobRepository blobRepository = _blobRepositoryFactory.CreateAsyncBlockBlobRepository(blobContainerName);
ILargeMessageQueue <T> queue = new LargeMessageQueue <T>(_serializer, referenceQueue, blobRepository, _loggerFactory.CreateLogger <LargeMessageQueue <T> >(), errorHandler);
return(queue);
}
/// <summary>
/// 将对象添加到队列的结尾处。
/// </summary>
/// <param name="item">要添加到的对象。</param>
public static async Task EnqueueRange <T>(this IAsyncQueue <T> aq, IEnumerable <T> items)
{
if (items != null)
{
foreach (var item in items)
{
await aq.Enqueue(item, CancellationToken.None);
}
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="backoffPolicy">The back off policy to use.</param>
/// <param name="queue">The queue to be processed</param>
/// <param name="logger">The logger to use for reporting issues</param>
/// <param name="dequeErrorHandler">Optional error handler for dequeue failures. This can return true / false or throw an exception</param>
protected AbstractBackoffQueueProcessor(
IAsyncBackoffPolicy backoffPolicy,
IAsyncQueue <T> queue,
ILogger <AbstractBackoffQueueProcessor <T> > logger,
Func <Exception, Task <bool> > dequeErrorHandler = null)
{
_backoffPolicy = backoffPolicy;
_queue = queue;
_logger = logger;
_dequeErrorHandler = dequeErrorHandler;
}
public static async void Consumer(IAsyncQueue <int> queue)
{
while (true)
{
Console.WriteLine("{0}:Waiting", Thread.CurrentThread.ManagedThreadId);
int val = await queue.Dequeue();
Console.WriteLine("{0}: Processing {1}", Thread.CurrentThread.ManagedThreadId, val);
Thread.Sleep(2000);
}
}
static Producer <RT, A, Unit> ToProducer <RT, A>(this IAsyncQueue <A> q)
where RT : struct, HasCancel <RT>
{
return(Proxy.enumerate(go()));
async IAsyncEnumerable <A> go()
{
while (true)
{
yield return(await q.DequeueAsync());
}
}
}
/// <summary>
/// 将对象添加到队列的结尾处。
/// </summary>
/// <param name="item">要添加到的对象。</param>
public static async Task EnqueueRange <T>(this IAsyncQueue <T> aq, IEnumerable <T> items, TimeSpan timeout)
{
if (items != null)
{
using (var source = new CancellationTokenSource(timeout))
{
foreach (var item in items)
{
await aq.Enqueue(item, CancellationToken.None);
}
}
}
}
public void CheckBlocksAnnounced_AndQueueEmptiesOverTime()
{
using (NodeBuilder builder = NodeBuilder.Create(this))
{
CoreNode stratisNodeSync = builder.CreateStratisPowNode(this.network, "bss-1-stratisNodeSync").WithReadyBlockchainData(ReadyBlockchain.BitcoinRegTest10Miner).Start();
CoreNode stratisNode1 = builder.CreateStratisPowNode(this.network, "bss-1-stratisNode1").Start();
// Change the second node's list of default behaviours include the test behaviour in it.
// We leave the other behaviors alone for this test because we want to see what messages the node gets under normal operation.
IConnectionManager node1ConnectionManager = stratisNode1.FullNode.NodeService <IConnectionManager>();
node1ConnectionManager.Parameters.TemplateBehaviors.Add(new TestBehavior());
// Connect node1 to initial node.
TestHelper.Connect(stratisNode1, stratisNodeSync);
INetworkPeer connectedPeer = node1ConnectionManager.ConnectedPeers.FindByEndpoint(stratisNodeSync.Endpoint);
TestBehavior testBehavior = connectedPeer.Behavior <TestBehavior>();
TestBase.WaitLoop(() => TestHelper.AreNodesSynced(stratisNode1, stratisNodeSync));
HashSet <uint256> advertised = new HashSet <uint256>();
// Check to see that all blocks got advertised to node1 via the "headers" payload.
foreach (IncomingMessage message in testBehavior.receivedMessageTracker["headers"])
{
if (message.Message.Payload is HeadersPayload)
{
foreach (BlockHeader header in ((HeadersPayload)message.Message.Payload).Headers)
{
advertised.Add(header.GetHash());
}
}
}
foreach (ChainedHeader chainedHeader in stratisNodeSync.FullNode.ChainIndexer.EnumerateToTip(this.network.GenesisHash))
{
if ((!advertised.Contains(chainedHeader.HashBlock)) && (!(chainedHeader.HashBlock == this.network.GenesisHash)))
{
throw new Exception($"An expected block was not advertised to peer: {chainedHeader.HashBlock}");
}
}
// Check current state of announce queue
BlockStoreSignaled blockStoreSignaled = stratisNodeSync.FullNode.NodeService <BlockStoreSignaled>();
IAsyncQueue <ChainedHeader> blocksToAnnounce = (IAsyncQueue <ChainedHeader>)blockStoreSignaled.GetMemberValue("blocksToAnnounce");
Queue <ChainedHeader> queueItems = (Queue <ChainedHeader>)blocksToAnnounce.GetMemberValue("items");
TestBase.WaitLoop(() => queueItems.Count == 0);
}
}
public LargeMessageQueue(
IQueueSerializer serializer,
IAsyncQueue <LargeMessageReference> referenceQueue,
IAsyncBlockBlobRepository blobRepository,
ILogger <LargeMessageQueue <T> > logger,
ILargeMessageQueueErrorHandler errorHandler)
{
_serializer = serializer;
_referenceQueue = referenceQueue;
_blobRepository = blobRepository;
_logger = logger;
_errorHandler = errorHandler;
_logger.LogTrace("LargeMessageQueue<T>: constructing");
}
public BatchSenderThread(IAsyncQueue <TQueueItem> dataSource, IMessageSender <TQueueItem> dataTarget, Func <TQueueItem, string> serializedData, ILogger logger)
: base(SafeLogger.FromLogger(logger))
{
if (dataSource == null || dataTarget == null)
{
throw new ArgumentException("data source and data target cannot be null");
}
_operational = new AutoResetEvent(false);
_doWork = new AutoResetEvent(false);
_running = false;
_dataSource = dataSource;
_dataTarget = dataTarget;
_serializedData = serializedData;
_outstandingTasks = 0;
}
/// <summary>
/// Inherited class must call this initializer method first.
/// </summary>
/// <param name="name">The name of the <see cref="AsyncQueue"/></param>
/// <param name="asyncQueue">The <see cref="IAsyncQueue"/> implementation</param>
/// <param name="consumerCount">Number of consumers</param>
/// <param name="priority">priority of consumer threads</param>
protected void Initialize(
string name,
IAsyncQueue asyncQueue,
int consumerCount,
ThreadPriority priority)
{
Assert.IsTrue(consumerCount > 0);
_name = name;
_asyncQueue = asyncQueue;
for (var id = 0; id < consumerCount; id++)
{
var consumerThread = new ConsumerThread(this, id, priority);
Consumers.Add(consumerThread.Thread);
}
}
public ActorHost(IActorHandlerMap actorHandlerMap,
IAsyncQueue <AsyncMessageContext> asyncQueue,
IAsyncQueue <ActorRegistration> actorRegistrationsQueue,
ISecurityProvider securityProvider,
ILocalSocket <IMessage> localRouterSocket,
ILocalSendingSocket <InternalRouteRegistration> internalRegistrationsSender,
ILocalSocketFactory localSocketFactory,
ILogger logger)
{
this.logger = logger;
this.actorHandlerMap = actorHandlerMap;
this.securityProvider = securityProvider;
this.localRouterSocket = localRouterSocket;
this.internalRegistrationsSender = internalRegistrationsSender;
this.asyncQueue = asyncQueue;
this.actorRegistrationsQueue = actorRegistrationsQueue;
receivingSocket = localSocketFactory.Create <IMessage>();
}
public ActorHost(ISocketFactory socketFactory,
IActorHandlerMap actorHandlerMap,
IAsyncQueue<AsyncMessageContext> asyncQueue,
IAsyncQueue<IActor> actorRegistrationsQueue,
RouterConfiguration routerConfiguration,
IMessageTracer messageTracer,
ILogger logger)
{
this.logger = logger;
this.messageTracer = messageTracer;
this.actorHandlerMap = actorHandlerMap;
localSocketIdentityPromise = new TaskCompletionSource<byte[]>();
this.socketFactory = socketFactory;
this.routerConfiguration = routerConfiguration;
this.asyncQueue = asyncQueue;
this.actorRegistrationsQueue = actorRegistrationsQueue;
cancellationTokenSource = new CancellationTokenSource();
}
//--//
public GatewayService(IAsyncQueue <QueuedItem> queue, EventProcessor processor, Func <string, string, QueuedItem> dataTransform = null)
{
if (queue == null || processor == null)
{
throw new ArgumentException("task queue and event processor cannot be null");
}
if (dataTransform != null)
{
_dataTransform = dataTransform;
}
else
{
_dataTransform = (deviceId, json) => new QueuedItem(deviceId, json);
}
_queue = queue;
_eventProcessor = processor;
}
private static IQueueItem[] CreateItems(int count, IAsyncQueue q)
{
IQueueItem[] items = new IQueueItem[count];
for (int i = 0; i < count; i++)
{
Priority p = (i % 5 == 0) ? Priority.High : (i % 2 == 0) ? Priority.Medium : Priority.Normal;
QueueItem item = new QueueItem(p);
item.MessageId = i;
item.Body = "this is a test אכן זוהי דוגמא";
item.Subject = "test";
item.Sender = "ibm";
item.Destination = "nissim";
q.Enqueue(item);
items[i] = item;
//logger.WriteLoge("Enqueue: " + ItemToString(item), Mode.INFO);
counter = i;
}
return(items);
}
//--//
public GatewayService( IAsyncQueue<QueuedItem> queue, EventProcessor processor, Func<string, QueuedItem> dataTransform = null )
{
if( queue == null || processor == null )
{
throw new ArgumentException( "task queue and event processor cannot be null" );
}
if( dataTransform != null )
{
_dataTransform = dataTransform;
}
else
{
_dataTransform = m => new QueuedItem
{
JsonData = m
};
}
_queue = queue;
_eventProcessor = processor;
}
/// <summary>
/// Creates a new instance of ChannelBase
/// </summary>
/// <param name="transport"></param>
/// <param name="sendTimeout"></param>
/// <param name="buffersLimit"></param>
/// <param name="fillEnvelopeRecipients">Indicates if the from and to properties of sent and received envelopes should be filled with the session information if not defined.</param>
/// <param name="autoReplyPings">Indicates if the channel should reply automatically to ping request commands. In this case, the ping command are not returned by the ReceiveCommandAsync method.</param>
public ChannelBase(ITransport transport, TimeSpan sendTimeout, int buffersLimit, bool fillEnvelopeRecipients, bool autoReplyPings)
{
if (transport == null)
{
throw new ArgumentNullException("transport");
}
this.Transport = transport;
this.Transport.Closing += Transport_Closing;
_sendTimeout = sendTimeout;
_fillEnvelopeRecipients = fillEnvelopeRecipients;
_autoReplyPings = autoReplyPings;
_channelCancellationTokenSource = new CancellationTokenSource();
this.State = SessionState.New;
#if MONO
_messageBuffer = new AsyncQueue <Message> (buffersLimit, buffersLimit);
_commandBuffer = new AsyncQueue <Command> (buffersLimit, buffersLimit);
_notificationBuffer = new AsyncQueue <Notification> (buffersLimit, buffersLimit);
_sessionBuffer = new AsyncQueue <Session> (1, 1);
#else
var bufferOptions = new System.Threading.Tasks.Dataflow.DataflowBlockOptions()
{
BoundedCapacity = buffersLimit
};
_messageBuffer = new BufferBlock <Message>(bufferOptions);
_commandBuffer = new BufferBlock <Command>(bufferOptions);
_notificationBuffer = new BufferBlock <Notification>(bufferOptions);
_sessionBuffer = new BufferBlock <Session>(
new DataflowBlockOptions()
{
BoundedCapacity = 1
});
#endif
}
public BlockStoreQueue(
ChainIndexer chainIndexer,
IChainState chainState,
IBlockStoreQueueFlushCondition blockStoreQueueFlushCondition,
StoreSettings storeSettings,
IBlockRepository blockRepository,
ILoggerFactory loggerFactory,
INodeStats nodeStats,
IAsyncProvider asyncProvider,
IInitialBlockDownloadState initialBlockDownloadState)
{
Guard.NotNull(blockStoreQueueFlushCondition, nameof(blockStoreQueueFlushCondition));
Guard.NotNull(chainIndexer, nameof(chainIndexer));
Guard.NotNull(chainState, nameof(chainState));
Guard.NotNull(storeSettings, nameof(storeSettings));
Guard.NotNull(loggerFactory, nameof(loggerFactory));
Guard.NotNull(blockRepository, nameof(blockRepository));
Guard.NotNull(nodeStats, nameof(nodeStats));
this.initialBlockDownloadState = initialBlockDownloadState;
this.blockStoreQueueFlushCondition = blockStoreQueueFlushCondition;
this.chainIndexer = chainIndexer;
this.chainState = chainState;
this.storeSettings = storeSettings;
this.blockRepository = blockRepository;
this.asyncProvider = asyncProvider;
this.batch = new List <ChainedHeaderBlock>();
this.blocksCacheLock = new object();
this.blocksQueue = asyncProvider.CreateAsyncQueue <ChainedHeaderBlock>();
this.pendingBlocksCache = new Dictionary <uint256, ChainedHeaderBlock>();
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.cancellation = new CancellationTokenSource();
this.saveAsyncLoopException = null;
this.BatchThresholdSizeBytes = storeSettings.MaxCacheSize * 1024 * 1024;
nodeStats.RegisterStats(this.AddComponentStats, StatsType.Component, this.GetType().Name);
}
public RequestsController(IForwardSender forwardSender, IAsyncQueue <RequestData> backwardRequestQueue)
{
this.forwardSender = forwardSender;
this.backwardRequestQueue = backwardRequestQueue;
}
public ILargeMessageQueue <T> Create <T>(IAsyncQueue <LargeMessageReference> referenceQueue, IAsyncBlockBlobRepository blobRepository) where T : class
{
return(Create <T>(referenceQueue, blobRepository, null));
}
public void MustNotAnnounceABlock_WhenNotInBestChain()
{
using (NodeBuilder builder = NodeBuilder.Create(this))
{
CoreNode stratisNodeSync = builder.CreateStratisPowNode(this.network, "bss-2-stratisNodeSync").WithReadyBlockchainData(ReadyBlockchain.BitcoinRegTest10Miner).Start();
CoreNode stratisNode1 = builder.CreateStratisPowNode(this.network, "bss-2-stratisNode1").WithReadyBlockchainData(ReadyBlockchain.BitcoinRegTest10Listener).Start();
CoreNode stratisNode2 = builder.CreateStratisPowNode(this.network, "bss-2-stratisNode2").WithReadyBlockchainData(ReadyBlockchain.BitcoinRegTest10NoWallet).Start();
// Store block 1 of chain0 for later usage
ChainedHeader firstBlock = null;
foreach (ChainedHeader chainedHeader in stratisNodeSync.FullNode.ChainIndexer.EnumerateToTip(this.network.GenesisHash))
{
if (chainedHeader.Height == 1)
{
firstBlock = chainedHeader;
}
}
Assert.NotNull(firstBlock);
// Mine longer chain1 using node1
TestHelper.MineBlocks(stratisNode1, 15);
IConnectionManager node1ConnectionManager = stratisNode1.FullNode.NodeService <IConnectionManager>();
node1ConnectionManager.Parameters.TemplateBehaviors.Add(new TestBehavior());
IConnectionManager node2ConnectionManager = stratisNode2.FullNode.NodeService <IConnectionManager>();
node2ConnectionManager.Parameters.TemplateBehaviors.Add(new TestBehavior());
// Connect node0 and node1
TestHelper.Connect(stratisNode1, stratisNodeSync);
INetworkPeer connectedPeer = node1ConnectionManager.ConnectedPeers.FindByEndpoint(stratisNodeSync.Endpoint);
TestBehavior testBehavior = connectedPeer.Behavior <TestBehavior>();
// We expect that node0 will abandon the 10 block chain and use the 15 block chain from node1
TestBase.WaitLoop(() => TestHelper.AreNodesSynced(stratisNode1, stratisNodeSync));
// Connect all nodes together
TestHelper.Connect(stratisNode2, stratisNodeSync);
TestHelper.Connect(stratisNode1, stratisNode2);
INetworkPeer connectedPeer2 = node2ConnectionManager.ConnectedPeers.FindByEndpoint(stratisNodeSync.Endpoint);
TestBehavior testBehavior2 = connectedPeer2.Behavior <TestBehavior>();
// Wait for node2 to sync; it should have the 15 block chain
TestBase.WaitLoop(() => TestHelper.AreNodesSynced(stratisNode2, stratisNodeSync));
// Insert block 1 from chain0 into node1's announce queue
BlockStoreSignaled node1BlockStoreSignaled = stratisNode1.FullNode.NodeService <BlockStoreSignaled>();
IAsyncQueue <ChainedHeader> node1BlocksToAnnounce = (IAsyncQueue <ChainedHeader>)node1BlockStoreSignaled.GetMemberValue("blocksToAnnounce");
Queue <ChainedHeader> node1QueueItems = (Queue <ChainedHeader>)node1BlocksToAnnounce.GetMemberValue("items");
TestBase.WaitLoop(() => node1QueueItems.Count == 0);
// Check that node2 does not have block 1 in test behaviour advertised list
foreach (IncomingMessage message in testBehavior2.receivedMessageTracker["headers"])
{
if (message.Message.Payload is HeadersPayload)
{
foreach (BlockHeader header in ((HeadersPayload)message.Message.Payload).Headers)
{
if (header.GetHash() == firstBlock.Header.GetHash())
{
throw new Exception("Should not have received payload announcing block from wrong chain");
}
}
}
}
}
}
public void CheckBlocksAnnounced_AndQueueEmptiesOverTime_ForMultiplePeers_WhenOneIsDisconnected()
{
using (NodeBuilder builder = NodeBuilder.Create(this))
{
CoreNode stratisNodeSync = builder.CreateStratisPowNode(this.network, "bss-2-stratisNodeSync").WithReadyBlockchainData(ReadyBlockchain.BitcoinRegTest10Miner).Start();
CoreNode stratisNode1 = builder.CreateStratisPowNode(this.network, "bss-2-stratisNode1").Start();
CoreNode stratisNode2 = builder.CreateStratisPowNode(this.network, "bss-2-stratisNode2").Start();
CoreNode stratisNode3 = builder.CreateStratisPowNode(this.network, "bss-2-stratisNode3").Start();
// Change the other nodes' lists of default behaviours include the test behaviour in it.
// We leave the other behaviors alone for this test because we want to see what messages the node gets under normal operation.
IConnectionManager node1ConnectionManager = stratisNode1.FullNode.NodeService <IConnectionManager>();
node1ConnectionManager.Parameters.TemplateBehaviors.Add(new TestBehavior());
IConnectionManager node2ConnectionManager = stratisNode2.FullNode.NodeService <IConnectionManager>();
node2ConnectionManager.Parameters.TemplateBehaviors.Add(new TestBehavior());
// Connect other nodes to initial node.
TestHelper.Connect(stratisNode1, stratisNodeSync);
TestHelper.Connect(stratisNode2, stratisNodeSync);
TestHelper.Connect(stratisNode3, stratisNodeSync);
// Make node3 unable to respond to anything, effectively disconnecting it.
IConnectionManager node3ConnectionManager = stratisNode3.FullNode.NodeService <IConnectionManager>();
node3ConnectionManager.Parameters.TemplateBehaviors.Clear();
node3ConnectionManager.Parameters.TemplateBehaviors.Add(new TestBehavior());
INetworkPeer connectedPeer1 = node1ConnectionManager.ConnectedPeers.FindByEndpoint(stratisNodeSync.Endpoint);
TestBehavior testBehavior1 = connectedPeer1.Behavior <TestBehavior>();
INetworkPeer connectedPeer2 = node2ConnectionManager.ConnectedPeers.FindByEndpoint(stratisNodeSync.Endpoint);
TestBehavior testBehavior2 = connectedPeer2.Behavior <TestBehavior>();
INetworkPeer connectedPeer3 = node3ConnectionManager.ConnectedPeers.FindByEndpoint(stratisNodeSync.Endpoint);
TestBehavior testBehavior3 = connectedPeer3.Behavior <TestBehavior>();
// If the announce queue is not getting stalled, the other 2 nodes should sync properly.
TestBase.WaitLoop(() => TestHelper.AreNodesSynced(stratisNode1, stratisNodeSync));
TestBase.WaitLoop(() => TestHelper.AreNodesSynced(stratisNode2, stratisNodeSync));
HashSet <uint256> advertised = new HashSet <uint256>();
// Check to see that all blocks got advertised to node1 via the "headers" payload.
foreach (IncomingMessage message in testBehavior1.receivedMessageTracker["headers"])
{
if (message.Message.Payload is HeadersPayload)
{
foreach (BlockHeader header in ((HeadersPayload)message.Message.Payload).Headers)
{
advertised.Add(header.GetHash());
}
}
}
foreach (ChainedHeader chainedHeader in stratisNodeSync.FullNode.ChainIndexer.EnumerateToTip(this.network.GenesisHash))
{
if ((!advertised.Contains(chainedHeader.HashBlock)) && (!(chainedHeader.HashBlock == this.network.GenesisHash)))
{
throw new Exception($"An expected block was not advertised to peer 1: {chainedHeader.HashBlock}");
}
}
advertised.Clear();
// Check to see that all blocks got advertised to node1 via the "headers" payload.
foreach (IncomingMessage message in testBehavior2.receivedMessageTracker["headers"])
{
if (message.Message.Payload is HeadersPayload)
{
foreach (BlockHeader header in ((HeadersPayload)message.Message.Payload).Headers)
{
advertised.Add(header.GetHash());
}
}
}
foreach (ChainedHeader chainedHeader in stratisNodeSync.FullNode.ChainIndexer.EnumerateToTip(this.network.GenesisHash))
{
if ((!advertised.Contains(chainedHeader.HashBlock)) && (!(chainedHeader.HashBlock == this.network.GenesisHash)))
{
throw new Exception($"An expected block was not advertised to peer 2: {chainedHeader.HashBlock}");
}
}
// Check current state of announce queue.
BlockStoreSignaled blockStoreSignaled = stratisNodeSync.FullNode.NodeService <BlockStoreSignaled>();
IAsyncQueue <ChainedHeader> blocksToAnnounce = (IAsyncQueue <ChainedHeader>)blockStoreSignaled.GetMemberValue("blocksToAnnounce");
Queue <ChainedHeader> queueItems = (Queue <ChainedHeader>)blocksToAnnounce.GetMemberValue("items");
// It should still eventually empty despite not being able to communicate with node3.
TestBase.WaitLoop(() => queueItems.Count == 0);
}
}