Example #1
0
        public async Task Connect_IsPending()
        {
            var swarm = new Swarm {
                LocalPeer = self
            };
            var venus = new Peer
            {
                Id        = "QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ",
                Addresses = new MultiAddress[]
                {
                    "/ip4/104.131.131.82/tcp/4001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ",            // mars.i.ipfs.io
                }
            };

            await swarm.StartAsync();

            try
            {
                Assert.IsFalse(swarm.HasPendingConnection(venus));

                var a = swarm.ConnectAsync(venus);
                Assert.IsTrue(swarm.HasPendingConnection(venus));
            }
            finally
            {
                await swarm.StopAsync();
            }
        }
Example #2
0
#pragma warning disable VSTHRD100 // Avoid async void methods
        /// <summary>
        ///   Called when the swarm has lost a connection to a peer.
        /// </summary>
        /// <param name="sender">
        ///   The swarm of peers.
        /// </param>
        /// <param name="disconnectedPeer">
        ///   The peer that was disconnected.
        /// </param>
        /// <remarks>
        ///   If the <see cref="MinConnections"/> is not reached, then another
        ///   peer is dialed.
        /// </remarks>
        async void OnPeerDisconnected(object sender, Peer disconnectedPeer)
#pragma warning restore VSTHRD100 // Avoid async void methods
        {
            var n = swarm.Manager.Connections.Count() + pendingConnects;

            if (!swarm.IsRunning || n >= MinConnections)
            {
                return;
            }

            // Find a random peer to connect with.
            var peers = swarm.KnownPeers
                        .Where(p => p.ConnectedAddress == null)
                        .Where(p => p != disconnectedPeer)
                        .Where(p => swarm.IsAllowed(p))
                        .Where(p => !swarm.HasPendingConnection(p))
                        .ToArray();

            if (peers.Length == 0)
            {
                return;
            }
            var rng  = new Random();
            var peer = peers[rng.Next(peers.Count())];

            Interlocked.Increment(ref pendingConnects);
            log.Debug($"Dialing {peer}");
            try
            {
                await swarm.ConnectAsync(peer).ConfigureAwait(false);
            }
            catch (Exception)
            {
                log.Warn($"Failed to dial {peer}");
            }
            finally
            {
                Interlocked.Decrement(ref pendingConnects);
            }
        }