Ejemplo n.º 1
0
        public async Task NewPeerAddress_Duplicate()
        {
            var swarm = new Swarm {
                LocalPeer = self
            };
            await swarm.RegisterPeerAsync(mars);

            Assert.AreEqual(1, swarm.KnownPeerAddresses.Count());

            await swarm.RegisterPeerAsync(mars);

            Assert.AreEqual(1, swarm.KnownPeerAddresses.Count());
        }
Ejemplo n.º 2
0
        public void NewPeerAddress_BlackList()
        {
            var swarm = new Swarm {
                LocalPeer = self
            };

            swarm.BlackList.Add(mars);

            ExceptionAssert.Throws <Exception>(() =>
            {
                var _ = swarm.RegisterPeerAsync(mars).Result;
            });
            Assert.IsFalse(swarm.KnownPeerAddresses.Contains(mars));

            Assert.IsNotNull(swarm.RegisterPeerAsync(venus).Result);
            Assert.IsTrue(swarm.KnownPeerAddresses.Contains(venus));
        }
Ejemplo n.º 3
0
        public void NewPeerAddress_Self()
        {
            var swarm = new Swarm {
                LocalPeer = self
            };
            var selfAddress = "/ip4/178.62.158.247/tcp/4001/ipfs/" + self.Id;

            ExceptionAssert.Throws <Exception>(() =>
            {
                var _ = swarm.RegisterPeerAsync(selfAddress).Result;
            });

            selfAddress = "/ip4/178.62.158.247/tcp/4001/p2p/" + self.Id;
            ExceptionAssert.Throws <Exception>(() =>
            {
                var _ = swarm.RegisterPeerAsync(selfAddress).Result;
            });
        }
Ejemplo n.º 4
0
        public async Task NewPeerAddress()
        {
            var swarm = new Swarm {
                LocalPeer = self
            };
            await swarm.RegisterPeerAsync(mars);

            Assert.IsTrue(swarm.KnownPeerAddresses.Contains(mars));
        }
Ejemplo n.º 5
0
        public void NewPeerAddress_InvalidAddress_MissingPeerId()
        {
            var swarm = new Swarm {
                LocalPeer = self
            };

            ExceptionAssert.Throws <Exception>(() =>
            {
                var _ = swarm.RegisterPeerAsync("/ip4/10.1.10.10/tcp/29087").Result;
            });
            Assert.AreEqual(0, swarm.KnownPeerAddresses.Count());
        }
Ejemplo n.º 6
0
        public async Task PeerDiscovered()
        {
            var swarm = new Swarm {
                LocalPeer = self
            };
            var peerCount = 0;

            swarm.PeerDiscovered += (s, e) =>
            {
                ++peerCount;
            };
            await swarm.RegisterPeerAsync("/ip4/127.0.0.1/tcp/4001/ipfs/QmdpwjdB94eNm2Lcvp9JqoCxswo3AKQqjLuNZyLixmCM1h");

            await swarm.RegisterPeerAsync("/ip4/127.0.0.2/tcp/4001/ipfs/QmdpwjdB94eNm2Lcvp9JqoCxswo3AKQqjLuNZyLixmCM1h");

            await swarm.RegisterPeerAsync("/ip4/127.0.0.3/tcp/4001/ipfs/QmdpwjdB94eNm2Lcvp9JqoCxswo3AKQqjLuNZyLixmCM1h");

            await swarm.RegisterPeerAsync("/ip4/127.0.0.1/tcp/4001/ipfs/QmdpwjdB94eNm2Lcvp9JqoCxswo3AKQqjLuNZyLixmCM1i");

            await swarm.RegisterPeerAsync("/ip4/127.0.0.2/tcp/4001/ipfs/QmdpwjdB94eNm2Lcvp9JqoCxswo3AKQqjLuNZyLixmCM1i");

            await swarm.RegisterPeerAsync("/ip4/127.0.0.3/tcp/4001/ipfs/QmdpwjdB94eNm2Lcvp9JqoCxswo3AKQqjLuNZyLixmCM1i");

            swarm.RegisterPeer(new Peer {
                Id = "QmdpwjdB94eNm2Lcvp9JqoCxswo3AKQqjLuNZyLixmCM1j"
            });
            swarm.RegisterPeer(new Peer {
                Id = "QmdpwjdB94eNm2Lcvp9JqoCxswo3AKQqjLuNZyLixmCM1j"
            });

            Assert.AreEqual(3, peerCount);
        }
Ejemplo n.º 7
0
        public async Task KnownPeers()
        {
            var swarm = new Swarm {
                LocalPeer = self
            };

            Assert.AreEqual(0, swarm.KnownPeers.Count());
            Assert.AreEqual(0, swarm.KnownPeerAddresses.Count());

            await swarm.RegisterPeerAsync("/ip4/10.1.10.10/tcp/29087/ipfs/QmSoLMeWqB7YGVLJN3pNLQpmmEk35v6wYtsMGLzSr5QBU3");

            Assert.AreEqual(1, swarm.KnownPeers.Count());
            Assert.AreEqual(1, swarm.KnownPeerAddresses.Count());

            await swarm.RegisterPeerAsync("/ip4/10.1.10.11/tcp/29087/p2p/QmSoLMeWqB7YGVLJN3pNLQpmmEk35v6wYtsMGLzSr5QBU3");

            Assert.AreEqual(1, swarm.KnownPeers.Count());
            Assert.AreEqual(2, swarm.KnownPeerAddresses.Count());

            await swarm.RegisterPeerAsync(venus);

            Assert.AreEqual(2, swarm.KnownPeers.Count());
            Assert.AreEqual(3, swarm.KnownPeerAddresses.Count());
        }
Ejemplo n.º 8
0
        public async Task Noop_OnPeerDiscovered_When_NotBelow_MinConnections()
        {
            var swarmA = new Swarm {
                LocalPeer = peerA
            };
            await swarmA.StartAsync();

            var peerAAddress = await swarmA.StartListeningAsync("/ip4/127.0.0.1/tcp/0");

            var swarmB = new Swarm {
                LocalPeer = peerB
            };
            await swarmB.StartAsync();

            var peerBAddress = await swarmB.StartListeningAsync("/ip4/127.0.0.1/tcp/0");

            try
            {
                using (var dialer = new AutoDialer(swarmA)
                {
                    MinConnections = 0
                })
                {
                    var other = await swarmA.RegisterPeerAsync(peerBAddress);

                    // wait for the connection.
                    var endTime = DateTime.Now.AddSeconds(3);
                    while (other.ConnectedAddress == null)
                    {
                        if (DateTime.Now > endTime)
                        {
                            return;
                        }
                        await Task.Delay(100);
                    }
                    Assert.Fail("Autodial should not happen");
                }
            }
            finally
            {
                await swarmA?.StopAsync();

                await swarmB?.StopAsync();
            }
        }
Ejemplo n.º 9
0
        public async Task Connects_OnPeerDisconnected_When_Below_MinConnections()
        {
            var swarmA = new Swarm {
                LocalPeer = peerA
            };
            await swarmA.StartAsync();

            var peerAAddress = await swarmA.StartListeningAsync("/ip4/127.0.0.1/tcp/0");

            var swarmB = new Swarm {
                LocalPeer = peerB
            };
            await swarmB.StartAsync();

            var peerBAddress = await swarmB.StartListeningAsync("/ip4/127.0.0.1/tcp/0");

            var swarmC = new Swarm {
                LocalPeer = peerC
            };
            await swarmC.StartAsync();

            var peerCAddress = await swarmC.StartListeningAsync("/ip4/127.0.0.1/tcp/0");

            bool isBConnected = false;

            swarmA.ConnectionEstablished += (s, conn) =>
            {
                if (conn.RemotePeer == peerB)
                {
                    isBConnected = true;
                }
            };

            try
            {
                using (var dialer = new AutoDialer(swarmA)
                {
                    MinConnections = 1
                })
                {
                    var b = await swarmA.RegisterPeerAsync(peerBAddress);

                    var c = await swarmA.RegisterPeerAsync(peerCAddress);

                    // wait for the peer B connection.
                    var endTime = DateTime.Now.AddSeconds(3);
                    while (!isBConnected)
                    {
                        if (DateTime.Now > endTime)
                        {
                            Assert.Fail("Did not do autodial on peer discovered");
                        }
                        await Task.Delay(100);
                    }
                    Assert.IsNull(c.ConnectedAddress);
                    await swarmA.DisconnectAsync(peerBAddress);

                    // wait for the peer C connection.
                    endTime = DateTime.Now.AddSeconds(3);
                    while (c.ConnectedAddress == null)
                    {
                        if (DateTime.Now > endTime)
                        {
                            Assert.Fail("Did not do autodial on peer disconnected");
                        }
                        await Task.Delay(100);
                    }
                }
            }
            finally
            {
                await swarmA?.StopAsync();

                await swarmB?.StopAsync();

                await swarmC?.StopAsync();
            }
        }