public void Connect_Failure_Event() { const string remoteId = "QmXFX2P5ammdmXQgfqGkfswtEVFsZUJ5KeHRXQYCTdiTAb"; MultiAddress remoteAddress = $"/ip4/127.0.0.1/tcp/4040/ipfs/{remoteId}"; var swarm = new SwarmService { LocalPeer = _self }; Peer unreachable = null; swarm.PeerNotReachable += (s, e) => { unreachable = e; }; swarm.StartAsync().Wait(); try { ExceptionAssert.Throws <Exception>(() => { var _ = swarm.ConnectAsync(remoteAddress).Result; }); } finally { swarm.StopAsync().Wait(); } Assert.IsNotNull(unreachable); Assert.AreEqual(remoteId, unreachable.Id.ToBase58()); }
public async Task Connect_IsPending() { var swarm = new SwarmService { 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 _ = swarm.ConnectAsync(venus); Assert.IsTrue(swarm.HasPendingConnection(venus)); } finally { await swarm.StopAsync(); } }
public async Task ConnectionEstablished() { var peerB = new Peer { AgentVersion = "peerB", Id = "QmdpwjdB94eNm2Lcvp9JqoCxswo3AKQqjLuNZyLixmCM1h", PublicKey = "CAASXjBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQDlTSgVLprWaXfmxDr92DJE1FP0wOexhulPqXSTsNh5ot6j+UiuMgwb0shSPKzLx9AuTolCGhnwpTBYHVhFoBErAgMBAAE=" }; var swarmB = new SwarmService { LocalPeer = peerB }; var swarmBConnections = 0; swarmB.ConnectionEstablished += (s, e) => { ++swarmBConnections; }; await swarmB.StartAsync(); var peerBAddress = await swarmB.StartListeningAsync("/ip4/127.0.0.1/tcp/0"); var swarm = new SwarmService { LocalPeer = _self }; var swarmConnections = 0; swarm.ConnectionEstablished += (s, e) => { ++swarmConnections; }; await swarm.StartAsync(); try { var _ = await swarm.ConnectAsync(peerBAddress); Assert.AreEqual(1, swarmConnections); // wait for swarmB to settle var endTime = DateTime.Now.AddSeconds(3); while (true) { if (DateTime.Now > endTime) { Assert.Fail("swarmB did not raise event."); } if (swarmBConnections == 1) { break; } await Task.Delay(100).ConfigureAwait(false); } } finally { await swarm.StopAsync(); await swarmB.StopAsync(); } }
public async Task PermanentlyDead() { var peer = new Peer { Id = "QmXFX2P5ammdmXQgfqGkfswtEVFsZUJ5KeHRXQYCTdiTAb", Addresses = new MultiAddress[] { "/ip4/127.0.0.1/tcp/4040/ipfs/QmXFX2P5ammdmXQgfqGkfswtEVFsZUJ5KeHRXQYCTdiTAb" } }; var swarm = new SwarmService { LocalPeer = self }; var manager = new PeerManager { SwarmService = swarm, InitialBackoff = TimeSpan.FromMilliseconds(100), MaxBackoff = TimeSpan.FromMilliseconds(200), }; Assert.AreEqual(0, manager.DeadPeers.Count); try { await swarm.StartAsync(); await manager.StartAsync(); try { await swarm.ConnectAsync(peer); } catch { // ignored } Assert.AreEqual(1, manager.DeadPeers.Count); var end = DateTime.Now + TimeSpan.FromSeconds(6); while (DateTime.Now <= end) { if (manager.DeadPeers[peer].NextAttempt == DateTime.MaxValue) { return; } } Assert.Fail("not truely dead"); } finally { await swarm.StopAsync(); await manager.StopAsync(); } }
public async Task Backoff_Increases() { var peer = new Peer { Id = "QmXFX2P5ammdmXQgfqGkfswtEVFsZUJ5KeHRXQYCTdiTxx", Addresses = new MultiAddress[] { "/ip4/127.0.0.1/tcp/4040/ipfs/QmXFX2P5ammdmXQgfqGkfswtEVFsZUJ5KeHRXQYCTdiTxx" } }; var swarm = new SwarmService { LocalPeer = self }; var manager = new PeerManager { SwarmService = swarm, InitialBackoff = TimeSpan.FromMilliseconds(100), }; Assert.AreEqual(0, manager.DeadPeers.Count); try { await swarm.StartAsync(); await manager.StartAsync(); try { await swarm.ConnectAsync(peer); } catch { // ignored } Assert.AreEqual(1, manager.DeadPeers.Count); var end = DateTime.Now + TimeSpan.FromSeconds(4); while (DateTime.Now <= end) { if (manager.DeadPeers[peer].Backoff > manager.InitialBackoff) { return; } } Assert.Fail("backoff did not increase"); } finally { await swarm.StopAsync(); await manager.StopAsync(); } }
public async Task Listening_IPv6Any() { var peerA = new Peer { Id = _self.Id, PublicKey = _self.PublicKey, AgentVersion = _self.AgentVersion }; MultiAddress addr = "/ip6/::/tcp/0"; var swarmA = new SwarmService { LocalPeer = peerA }; var peerB = new Peer { Id = _other.Id, PublicKey = _other.PublicKey, AgentVersion = _other.AgentVersion }; var swarmB = new SwarmService { LocalPeer = peerB }; await swarmA.StartAsync(); await swarmB.StartAsync(); try { var another = await swarmA.StartListeningAsync(addr); Assert.IsFalse(peerA.Addresses.Contains(addr)); Assert.IsTrue(peerA.Addresses.Contains(another)); await swarmB.ConnectAsync(another); Assert.IsTrue(swarmB.KnownPeers.Contains(peerA)); // TODO: Assert.IsTrue(swarmA.KnownPeers.Contains(peerB)); await swarmA.StopListeningAsync(addr); Assert.AreEqual(0, peerA.Addresses.Count()); } finally { await swarmA.StopAsync(); await swarmB.StopAsync(); } }
public async Task RemotePeer_Contains_ConnectedAddress2() { // Only works on Windows because connecting to 127.0.0.100 is allowed // when listening on 0.0.0.0 if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { return; } var peerB = new Peer { AgentVersion = "peerB", Id = "QmdpwjdB94eNm2Lcvp9JqoCxswo3AKQqjLuNZyLixmCM1h", PublicKey = "CAASXjBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQDlTSgVLprWaXfmxDr92DJE1FP0wOexhulPqXSTsNh5ot6j+UiuMgwb0shSPKzLx9AuTolCGhnwpTBYHVhFoBErAgMBAAE=" }; var swarmB = new SwarmService { LocalPeer = peerB }; await swarmB.StartAsync(); var peerBAddress = await swarmB.StartListeningAsync("/ip4/0.0.0.0/tcp/0"); var peerBPort = peerBAddress.Protocols[1].Value; Assert.IsTrue(peerB.Addresses.Any()); var swarm = new SwarmService { LocalPeer = _self }; await swarm.StartAsync(); try { MultiAddress ma = $"/ip4/127.0.0.100/tcp/{peerBPort}/ipfs/{peerB.Id}"; var connection = await swarm.ConnectAsync(ma); var remote = connection.RemotePeer; Assert.AreEqual(remote.ConnectedAddress, ma); CollectionAssert.Contains(remote.Addresses.ToArray(), ma); } finally { await swarm.StopAsync(); await swarmB.StopAsync(); } }
public async Task Connect_WithSomeUnreachableAddresses() { const string bid = "QmdpwjdB94eNm2Lcvp9JqoCxswo3AKQqjLuNZyLixmCM1h"; var peerB = new Peer { AgentVersion = "peerB", Id = bid, PublicKey = "CAASXjBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQDlTSgVLprWaXfmxDr92DJE1FP0wOexhulPqXSTsNh5ot6j+UiuMgwb0shSPKzLx9AuTolCGhnwpTBYHVhFoBErAgMBAAE=", Addresses = new MultiAddress[] { $"/ip4/127.0.0.2/tcp/2/ipfs/{bid}", $"/ip4/127.0.0.3/tcp/3/ipfs/{bid}" } }; var swarmB = new SwarmService { LocalPeer = peerB }; await swarmB.StartAsync(); var _ = await swarmB.StartListeningAsync("/ip4/127.0.0.1/tcp/0"); Assert.IsTrue(peerB.Addresses.Any()); var swarm = new SwarmService { LocalPeer = _self }; await swarm.StartAsync(); try { var remotePeer = (await swarm.ConnectAsync(peerB)).RemotePeer; Assert.IsNotNull(remotePeer.ConnectedAddress); Assert.AreEqual(peerB.PublicKey, remotePeer.PublicKey); Assert.IsTrue(remotePeer.IsValid()); Assert.IsTrue(swarm.KnownPeers.Contains(peerB)); } finally { await swarm.StopAsync(); await swarmB.StopAsync(); } }
public void Connecting_To_Self() { var swarm = new SwarmService { LocalPeer = _self }; swarm.StartAsync().Wait(); try { ExceptionAssert.Throws <Exception>(() => { var _ = swarm.ConnectAsync(_earth).Result; }); } finally { swarm.StopAsync().Wait(); } }
public async Task PeerDisconnected() { var peerB = new Peer { AgentVersion = "peerB", Id = "QmdpwjdB94eNm2Lcvp9JqoCxswo3AKQqjLuNZyLixmCM1h", PublicKey = "CAASXjBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQDlTSgVLprWaXfmxDr92DJE1FP0wOexhulPqXSTsNh5ot6j+UiuMgwb0shSPKzLx9AuTolCGhnwpTBYHVhFoBErAgMBAAE=" }; var swarmB = new SwarmService { LocalPeer = peerB }; await swarmB.StartAsync(); var peerBAddress = await swarmB.StartListeningAsync("/ip4/127.0.0.1/tcp/0"); var swarm = new SwarmService { LocalPeer = _self }; var swarmConnections = 0; swarm.ConnectionEstablished += (s, e) => { ++swarmConnections; }; swarm.PeerDisconnected += (s, e) => { --swarmConnections; }; await swarm.StartAsync(); try { var _ = await swarm.ConnectAsync(peerBAddress); Assert.AreEqual(1, swarmConnections); await swarm.StopAsync(); Assert.AreEqual(0, swarmConnections); } finally { await swarm.StopAsync(); await swarmB.StopAsync(); } }
public async Task Connecting_To_Self_Indirect() { var swarm = new SwarmService { LocalPeer = _self }; await swarm.StartAsync(); try { var listen = await swarm.StartListeningAsync("/ip4/127.0.0.1/tcp/0"); var bad = listen.Clone(); bad.Protocols[2].Value = "QmXFX2P5ammdmXQgfqGkfswtEVFsZUJ5KeHRXQYCTdiTAb"; ExceptionAssert.Throws <Exception>(() => { swarm.ConnectAsync(bad).Wait(); }); } finally { await swarm.StopAsync(); } }
public void Connecting_To_Blacklisted_Address() { var swarm = new SwarmService { LocalPeer = _self }; swarm.BlackList.Add(_mars); swarm.StartAsync().Wait(); try { ExceptionAssert.Throws <Exception>(() => { var _ = swarm.ConnectAsync(_mars).Result; }); } finally { swarm.StopAsync().Wait(); } }
public void Connect_Not_Peer() { const string remoteId = "QmXFX2P5ammdmXQgfqGkfswtEVFsZUJ5KeHRXQYCTdiTAb"; MultiAddress remoteAddress = $"/dns/npmjs.com/tcp/80/ipfs/{remoteId}"; var swarm = new SwarmService { LocalPeer = _self }; swarm.StartAsync().Wait(); try { ExceptionAssert.Throws <Exception>(() => { var _ = swarm.ConnectAsync(remoteAddress).Result; }); } finally { swarm.StopAsync().Wait(); } }
public async Task MultiAddress() { var swarmB = new SwarmService { LocalPeer = other }; await swarmB.StartAsync(); var pingB = new Ping1(swarmB); await pingB.StartAsync(); var peerBAddress = await swarmB.StartListeningAsync("/ip4/127.0.0.1/tcp/0"); var swarm = new SwarmService { LocalPeer = self }; await swarm.StartAsync(); var pingA = new Ping1(swarm); await pingA.StartAsync(); try { await swarm.ConnectAsync(peerBAddress); var result = await pingA.PingAsync(other.Id, 4); Assert.IsTrue(result.All(r => r.Success)); } finally { await swarm.StopAsync(); await swarmB.StopAsync(); await pingB.StopAsync(); await pingA.StopAsync(); } }
public async Task RemotePeer_Contains_ConnectedAddress1() { var peerB = new Peer { AgentVersion = "peerB", Id = "QmdpwjdB94eNm2Lcvp9JqoCxswo3AKQqjLuNZyLixmCM1h", PublicKey = "CAASXjBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQDlTSgVLprWaXfmxDr92DJE1FP0wOexhulPqXSTsNh5ot6j+UiuMgwb0shSPKzLx9AuTolCGhnwpTBYHVhFoBErAgMBAAE=" }; var swarmB = new SwarmService { LocalPeer = peerB }; await swarmB.StartAsync(); var peerBAddress = await swarmB.StartListeningAsync("/ip4/0.0.0.0/tcp/0"); var swarm = new SwarmService { LocalPeer = _self }; await swarm.StartAsync(); try { var connection = await swarm.ConnectAsync(peerBAddress); var remote = connection.RemotePeer; Assert.AreEqual(remote.ConnectedAddress, peerBAddress); CollectionAssert.Contains(remote.Addresses.ToArray(), peerBAddress); } finally { await swarm.StopAsync(); await swarmB.StopAsync(); } }
public async Task Connect_CancelsOnStop() { var swarm = new SwarmService { 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(); var a = swarm.ConnectAsync(venus); Assert.IsFalse(a.IsCanceled || a.IsFaulted); await swarm.StopAsync(); var endTime = DateTime.Now.AddSeconds(3); while (!a.IsCanceled && !a.IsFaulted) { if (DateTime.Now > endTime) { Assert.Fail("swarm did not cancel pending connection."); } await Task.Delay(100); } Assert.IsTrue(a.IsCanceled || a.IsFaulted); }
public async Task Connect_PrivateNetwork() { var peerB = new Peer { AgentVersion = "peerB", Id = "QmdpwjdB94eNm2Lcvp9JqoCxswo3AKQqjLuNZyLixmCM1h", PublicKey = "CAASXjBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQDlTSgVLprWaXfmxDr92DJE1FP0wOexhulPqXSTsNh5ot6j+UiuMgwb0shSPKzLx9AuTolCGhnwpTBYHVhFoBErAgMBAAE=" }; var swarmB = new SwarmService { LocalPeer = peerB, NetworkProtector = new OpenNetwork() }; await swarmB.StartAsync(); var peerBAddress = await swarmB.StartListeningAsync("/ip4/127.0.0.1/tcp/0"); Assert.IsTrue(peerB.Addresses.Any()); var swarm = new SwarmService { LocalPeer = _self, NetworkProtector = new OpenNetwork() }; await swarm.StartAsync(); try { var _ = await swarm.ConnectAsync(peerBAddress); Assert.AreEqual(2, OpenNetwork.Count); } finally { await swarm.StopAsync(); await swarmB.StopAsync(); } }
public void Connect_Cancelled() { var cs = new CancellationTokenSource(); cs.Cancel(); const string remoteId = "QmXFX2P5ammdmXQgfqGkfswtEVFsZUJ5KeHRXQYCTdiTAb"; MultiAddress remoteAddress = $"/ip4/127.0.0.1/tcp/4002/ipfs/{remoteId}"; var swarm = new SwarmService { LocalPeer = _self }; swarm.StartAsync().Wait(cs.Token); try { ExceptionAssert.Throws <Exception>(() => { var _ = swarm.ConnectAsync(remoteAddress, cs.Token).Result; }); } finally { swarm.StopAsync().Wait(cs.Token); } }
public async Task Sends_Hello_OnConnect() { var topic = Guid.NewGuid().ToString(); var swarm1 = new SwarmService { LocalPeer = self }; var router1 = new FloodRouter { SwarmService = swarm1 }; var ns1 = new PubSubService { LocalPeer = self }; ns1.Routers.Add(router1); await swarm1.StartAsync(); await ns1.StartAsync(); var swarm2 = new SwarmService { LocalPeer = other }; var router2 = new FloodRouter { SwarmService = swarm2 }; var ns2 = new PubSubService { LocalPeer = other }; ns2.Routers.Add(router2); await swarm2.StartAsync(); await ns2.StartAsync(); try { await swarm1.StartListeningAsync("/ip4/127.0.0.1/tcp/0"); await swarm2.StartListeningAsync("/ip4/127.0.0.1/tcp/0"); var cs = new CancellationTokenSource(); await ns1.SubscribeAsync(topic, msg => { }, cs.Token); await swarm1.ConnectAsync(other, cs.Token); var peers = new Peer[0]; var endTime = DateTime.Now.AddSeconds(3); while (peers.Length == 0) { if (DateTime.Now > endTime) { Assert.Fail("timeout"); } await Task.Delay(100, cs.Token); peers = (await ns2.PeersAsync(topic, cs.Token)).ToArray(); } CollectionAssert.Contains(peers, self); } finally { await swarm1.StopAsync(); await ns1.StopAsync(); await swarm2.StopAsync(); await ns2.StopAsync(); } }
public async Task Relays_PublishedMessage() { var topic = Guid.NewGuid().ToString(); var swarm1 = new SwarmService { LocalPeer = self }; var router1 = new FloodRouter { SwarmService = swarm1 }; var ns1 = new PubSubService { LocalPeer = self }; ns1.Routers.Add(router1); await swarm1.StartAsync(); await ns1.StartAsync(); var swarm2 = new SwarmService { LocalPeer = other }; var router2 = new FloodRouter { SwarmService = swarm2 }; var ns2 = new PubSubService { LocalPeer = other }; ns2.Routers.Add(router2); await swarm2.StartAsync(); await ns2.StartAsync(); var swarm3 = new SwarmService { LocalPeer = other1 }; var router3 = new FloodRouter { SwarmService = swarm3 }; var ns3 = new PubSubService { LocalPeer = other1 }; ns3.Routers.Add(router3); await swarm3.StartAsync(); await ns3.StartAsync(); try { IPublishedMessage lastMessage2 = null; IPublishedMessage lastMessage3 = null; await swarm1.StartListeningAsync("/ip4/127.0.0.1/tcp/0"); await swarm2.StartListeningAsync("/ip4/127.0.0.1/tcp/0"); await swarm3.StartListeningAsync("/ip4/127.0.0.1/tcp/0"); var cs = new CancellationTokenSource(); await ns2.SubscribeAsync(topic, msg => lastMessage2 = msg, cs.Token); await ns3.SubscribeAsync(topic, msg => lastMessage3 = msg, cs.Token); await swarm1.ConnectAsync(other, cs.Token); await swarm3.ConnectAsync(other, cs.Token); var peers = new Peer[0]; var endTime = DateTime.Now.AddSeconds(3); while (peers.Length == 0) { if (DateTime.Now > endTime) { Assert.Fail("timeout"); } await Task.Delay(100, cs.Token); peers = (await ns2.PeersAsync(topic, cs.Token)).ToArray(); } CollectionAssert.Contains(peers, other1); await ns1.PublishAsync(topic, new byte[] { 1 }, cs.Token); endTime = DateTime.Now.AddSeconds(3); while (lastMessage2 == null || lastMessage3 == null) { if (DateTime.Now > endTime) { Assert.Fail("timeout"); } await Task.Delay(100, cs.Token); } Assert.IsNotNull(lastMessage2); Assert.AreEqual(self, lastMessage2.Sender); CollectionAssert.AreEqual(new byte[] { 1 }, lastMessage2.DataBytes); CollectionAssert.Contains(lastMessage2.Topics.ToArray(), topic); Assert.IsNotNull(lastMessage3); Assert.AreEqual(self, lastMessage3.Sender); CollectionAssert.AreEqual(new byte[] { 1 }, lastMessage3.DataBytes); CollectionAssert.Contains(lastMessage3.Topics.ToArray(), topic); } finally { await swarm1.StopAsync(); await ns1.StopAsync(); await swarm2.StopAsync(); await ns2.StopAsync(); await swarm3.StopAsync(); await ns3.StopAsync(); } }
public async Task Connect_Disconnect_Reconnect() { var peerB = new Peer { AgentVersion = "peerB", Id = "QmdpwjdB94eNm2Lcvp9JqoCxswo3AKQqjLuNZyLixmCM1h", PublicKey = "CAASXjBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQDlTSgVLprWaXfmxDr92DJE1FP0wOexhulPqXSTsNh5ot6j+UiuMgwb0shSPKzLx9AuTolCGhnwpTBYHVhFoBErAgMBAAE=" }; var swarmB = new SwarmService { LocalPeer = peerB }; await swarmB.StartAsync(); var peerBAddress = await swarmB.StartListeningAsync("/ip4/127.0.0.1/tcp/0"); Assert.IsTrue(peerB.Addresses.Any()); var swarm = new SwarmService { LocalPeer = _self }; await swarm.StartAsync(); await swarm.StartListeningAsync("/ip4/127.0.0.1/tcp/0"); try { var remotePeer = (await swarm.ConnectAsync(peerBAddress)).RemotePeer; Assert.IsNotNull(remotePeer.ConnectedAddress); Assert.AreEqual(peerB.PublicKey, remotePeer.PublicKey); Assert.IsTrue(remotePeer.IsValid()); Assert.IsTrue(swarm.KnownPeers.Contains(peerB)); // wait for swarmB to settle var endTime = DateTime.Now.AddSeconds(3); while (true) { if (DateTime.Now > endTime) { Assert.Fail("swarmB does not know about self"); } if (swarmB.KnownPeers.Contains(_self)) { break; } await Task.Delay(100); } var me = swarmB.KnownPeers.First(p => p == _self); Assert.AreEqual(_self.Id, me.Id); Assert.AreEqual(_self.PublicKey, me.PublicKey); Assert.IsNotNull(me.ConnectedAddress); // Check disconnect await swarm.DisconnectAsync(peerBAddress); Assert.IsNull(remotePeer.ConnectedAddress); Assert.IsTrue(swarm.KnownPeers.Contains(peerB)); Assert.IsTrue(swarmB.KnownPeers.Contains(_self)); // wait for swarmB to settle endTime = DateTime.Now.AddSeconds(3); while (true) { if (DateTime.Now > endTime) { Assert.Fail("swarmB did not close connection."); } if (me.ConnectedAddress == null) { break; } await Task.Delay(100); } // Reconnect remotePeer = (await swarm.ConnectAsync(peerBAddress)).RemotePeer; Assert.IsNotNull(remotePeer.ConnectedAddress); Assert.AreEqual(peerB.PublicKey, remotePeer.PublicKey); Assert.IsTrue(remotePeer.IsValid()); Assert.IsTrue(swarm.KnownPeers.Contains(peerB)); } finally { await swarm.StopAsync(); await swarmB.StopAsync(); } }