Пример #1
0
        internal async Task ProcessPeerDiscoveryJob()
        {
            try
            {
                var newNodes = await _peerDiscoveryService.DiscoverNodesAsync();

                if (newNodes == null || newNodes.Nodes.Count <= 0)
                {
                    Logger.LogDebug("Discovery: no new nodes discovered");
                    return;
                }

                Logger.LogDebug($"Discovery: new nodes discovered : {newNodes}.");

                foreach (var node in newNodes.Nodes)
                {
                    if (_networkService.IsPeerPoolFull())
                    {
                        Logger.LogDebug("Discovery: Peer pool is full, aborting add.");
                        break;
                    }

                    await _networkService.AddPeerAsync(node.Endpoint);
                }
            }
            catch (Exception e)
            {
                Logger.LogError(e, "Exception in discovery worker.");
            }
        }
Пример #2
0
        protected override async void DoWork()
        {
            try
            {
                var newNodes = await _peerDiscoveryService.DiscoverNodesAsync();

                if (newNodes == null || newNodes.Nodes.Count <= 0)
                {
                    Logger.LogDebug("Discovery: no new nodes discovered");
                    return;
                }

                Logger.LogDebug($"Discovery: new nodes discovered : {newNodes}.");

                foreach (var node in newNodes.Nodes)
                {
                    if (_peerPool.PeerCount >= NetworkOptions.MaxPeers)
                    {
                        Logger.LogDebug($"Discovery: Max peers reached {_peerPool.PeerCount}, aborting add.");
                        break;
                    }

                    await _networkService.AddPeerAsync(node.Endpoint);
                }
            }
            catch (Exception e)
            {
                Logger.LogError(e, "Exception in discovery worker.");
            }
        }
Пример #3
0
        public async Task DiscoverNodes_Test()
        {
            await _peerDiscoveryService.DiscoverNodesAsync();

            await _peerDiscoveryJobProcessor.CompleteAsync();

            var nodeList = await _nodeManager.GetRandomNodesAsync(10);

            nodeList.Nodes.Count.ShouldBe(1);
            nodeList.Nodes[0].Endpoint.ShouldBe("192.168.100.100:8003");
            nodeList.Nodes[0].Pubkey.ShouldBe(ByteString.CopyFromUtf8("192.168.100.100:8003"));
        }
        internal async Task ProcessPeerDiscoveryJobAsync()
        {
            await _peerDiscoveryService.RefreshNodeAsync();

            await _peerDiscoveryService.DiscoverNodesAsync();

            if (_networkService.IsPeerPoolFull())
            {
                return;
            }

            var nodes = await _peerDiscoveryService.GetNodesAsync(10);

            foreach (var node in nodes.Nodes)
            {
                try
                {
                    var reconnectingPeer = _reconnectionService.GetReconnectingPeer(node.Endpoint);

                    if (reconnectingPeer != null)
                    {
                        Logger.LogDebug($"Peer {node.Endpoint} is already in the reconnection queue.");
                        continue;
                    }

                    if (_networkService.IsPeerPoolFull())
                    {
                        Logger.LogTrace("Peer pool is full, aborting add.");
                        break;
                    }

                    await _networkService.AddPeerAsync(node.Endpoint);
                }
                catch (Exception e)
                {
                    Logger.LogError(e, $"Exception connecting to {node.Endpoint}.");
                }
            }
        }
Пример #5
0
        internal async Task ProcessPeerDiscoveryJob()
        {
            var newNodes = await _peerDiscoveryService.DiscoverNodesAsync();

            if (newNodes == null || newNodes.Nodes.Count <= 0)
            {
                Logger.LogDebug("No new nodes discovered");
                return;
            }

            Logger.LogDebug($"New nodes discovered : {newNodes}.");

            foreach (var node in newNodes.Nodes)
            {
                try
                {
                    var reconnectingPeer = _reconnectionService.GetReconnectingPeer(node.Endpoint);

                    if (reconnectingPeer != null)
                    {
                        Logger.LogDebug($"Peer {node.Endpoint} is already in the reconnection queue.");
                        continue;
                    }

                    if (_networkService.IsPeerPoolFull())
                    {
                        Logger.LogDebug("Peer pool is full, aborting add.");
                        break;
                    }

                    await _networkService.AddPeerAsync(node.Endpoint);
                }
                catch (Exception e)
                {
                    Logger.LogError(e, $"Exception connecting to {node.Endpoint}.");
                }
            }
        }
Пример #6
0
        public async Task DiscoverNodes_Test()
        {
            var result = await _peerDiscoveryService.DiscoverNodesAsync();

            result.Nodes.Count.ShouldBe(1);
        }