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 Dial_Peer_Not_Listening() { var peer = new Peer { Id = _mars.PeerId, Addresses = new List <MultiAddress> { new MultiAddress($"/ip4/127.0.0.1/tcp/4242/ipfs/{_mars.PeerId}"), new MultiAddress($"/ip4/127.0.0.2/tcp/4242/ipfs/{_mars.PeerId}") } }; var swarm = new SwarmService { LocalPeer = _self }; await swarm.StartAsync(); try { ExceptionAssert.Throws <Exception>(() => { swarm.DialAsync(peer, "/foo/0.42.0").Wait(); }); } finally { await swarm.StopAsync(); } }
public async Task Dial_Peer_UnknownProtocol() { var peerB = new Peer { AgentVersion = "peerB", Id = "QmdpwjdB94eNm2Lcvp9JqoCxswo3AKQqjLuNZyLixmCM1h", PublicKey = "CAASXjBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQDlTSgVLprWaXfmxDr92DJE1FP0wOexhulPqXSTsNh5ot6j+UiuMgwb0shSPKzLx9AuTolCGhnwpTBYHVhFoBErAgMBAAE=" }; var swarmB = new SwarmService { LocalPeer = peerB }; var _ = await swarmB.StartListeningAsync("/ip4/127.0.0.1/tcp/0"); var swarm = new SwarmService { LocalPeer = _self }; await swarm.StartAsync(); try { ExceptionAssert.Throws <Exception>(() => { swarm.DialAsync(peerB, "/foo/0.42.0").Wait(); }); } finally { await swarm.StopAsync(); await swarmB.StopAsync(); } }
public async Task Listening_Event() { var peer = new Peer { Id = _self.Id, PublicKey = _self.PublicKey, AgentVersion = _self.AgentVersion }; MultiAddress addr = "/ip4/127.0.0.1/tcp/0"; var swarm = new SwarmService { LocalPeer = peer }; Peer listeningPeer = null; swarm.ListenerEstablished += (s, e) => { listeningPeer = e; }; try { await swarm.StartListeningAsync(addr); Assert.AreEqual(peer, listeningPeer); Assert.AreNotEqual(0, peer.Addresses.Count()); } finally { await swarm.StopAsync(); } }
public async Task FindPeer_Closest() { var unknownPeer = new MultiHash("QmdpwjdB94eNm2Lcvp9JqoCxswo3AKQqjLuNZyLixmCxxx"); var swarm = new SwarmService { LocalPeer = self }; await swarm.StartAsync(); var dht = new DhtService { SwarmService = swarm }; await dht.StartAsync(); dht.RoutingTable.Add(other); try { var peer = await dht.FindPeerAsync(unknownPeer); Assert.AreEqual(other, peer); } finally { await swarm.StopAsync(); await dht.StopAsync(); } }
/// <summary> /// Starts the services. /// </summary> /// <returns> /// A task that represents the asynchronous operation. /// </returns> /// <remarks> /// Starts the various IPFS and Peer2Peer services. This should /// be called after any configuration changes. /// </remarks> /// <exception cref="Exception"> /// When the engine is already started. /// </exception> public async Task StartAsync() { if (stopTasks.Count > 0) { throw new Exception("Already started"); } var tasks = new List <Task> { new Task(async() => { var bootstrap = new Peer2Peer.Discovery.Bootstrap { Addresses = await this.Bootstrap.ListAsync() }; bootstrap.PeerDiscovered += async(s, e) => { await SwarmService.RegisterPeerAsync(e.Address); }; await bootstrap.StartAsync(); stopTasks.Add(new Task(async() => await bootstrap.StopAsync())); }), new Task(async() => { await SwarmService.StartAsync(); stopTasks.Add(new Task(async() => await SwarmService.StopAsync())); }) }; foreach (var task in tasks) { task.Start(); } await Task.WhenAll(tasks); }
public async Task Provide() { Cid cid = "zBunRGrmCGokA1oMESGGTfrtcMFsVA8aEtcNzM54akPWXF97uXCqTjF3GZ9v8YzxHrG66J8QhtPFWwZebRZ2zeUEELu67"; var swarm = new SwarmService { LocalPeer = self }; var dht = new DhtService { SwarmService = swarm }; await dht.StartAsync(); try { await swarm.StartAsync(); await swarm.StartListeningAsync("/ip4/127.0.0.1/tcp/0"); await dht.ProvideAsync(cid); var peers = (await dht.FindProvidersAsync(cid, 1)).ToArray(); Assert.AreEqual(1, peers.Length); Assert.AreEqual(self, peers[0]); } finally { await dht.StopAsync(); await swarm.StopAsync(); } }
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 Start_Stop() { var swarm = new SwarmService { LocalPeer = _self }; await swarm.StartAsync(); await swarm.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 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 Stop_Closes_Listeners() { var peer = new Peer { Id = _self.Id, PublicKey = _self.PublicKey, AgentVersion = _self.AgentVersion }; MultiAddress addr = "/ip4/0.0.0.0/tcp/0"; var swarm = new SwarmService { LocalPeer = peer }; try { await swarm.StartAsync(); await swarm.StartListeningAsync(addr); Assert.IsTrue(peer.Addresses.Any()); await swarm.StopAsync(); Assert.AreEqual(0, peer.Addresses.Count()); await swarm.StartAsync(); await swarm.StartListeningAsync(addr); Assert.IsTrue(peer.Addresses.Any()); await swarm.StopAsync(); Assert.AreEqual(0, peer.Addresses.Count()); } catch (Exception) { await swarm.StopAsync(); throw; } }
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 IsRunning() { var swarm = new SwarmService { LocalPeer = _self }; Assert.IsFalse(swarm.IsRunning); await swarm.StartAsync(); Assert.IsTrue(swarm.IsRunning); await swarm.StopAsync(); Assert.IsFalse(swarm.IsRunning); }
public async Task Noop_OnPeerDiscovered_When_NotBelow_MinConnections() { var swarmA = new SwarmService { LocalPeer = peerA }; await swarmA.StartAsync(); await swarmA.StartListeningAsync("/ip4/127.0.0.1/tcp/0"); var swarmB = new SwarmService { LocalPeer = peerB }; await swarmB.StartAsync(); var peerBAddress = await swarmB.StartListeningAsync("/ip4/127.0.0.1/tcp/0"); try { using (new AutoDialer(swarmA) { MinConnections = 0 }) { var other = swarmA.RegisterPeerAddress(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(); } }
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 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 async Task Dial_Peer_No_Address() { var peer = new Peer { Id = _mars.PeerId }; var swarm = new SwarmService { LocalPeer = _self }; await swarm.StartAsync(); try { ExceptionAssert.Throws <Exception>(() => { swarm.DialAsync(peer, "/foo/0.42.0").Wait(); }); } finally { await swarm.StopAsync(); } }
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 Dial_Peer() { var peerB = new Peer { AgentVersion = "peerB", Id = "QmdpwjdB94eNm2Lcvp9JqoCxswo3AKQqjLuNZyLixmCM1h", PublicKey = "CAASXjBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQDlTSgVLprWaXfmxDr92DJE1FP0wOexhulPqXSTsNh5ot6j+UiuMgwb0shSPKzLx9AuTolCGhnwpTBYHVhFoBErAgMBAAE=" }; var swarmB = new SwarmService { LocalPeer = peerB }; await swarmB.StartAsync(); var _ = await swarmB.StartListeningAsync("/ip4/127.0.0.1/tcp/0"); var swarm = new SwarmService { LocalPeer = _self }; await swarm.StartAsync(); try { await using (var stream = await swarm.DialAsync(peerB, "/ipfs/id/1.0.0")) { Assert.IsNotNull(stream); Assert.IsTrue(stream.CanRead); Assert.IsTrue(stream.CanWrite); } } finally { await swarm.StopAsync(); await swarmB.StopAsync(); } }
public async Task Listening_Start_Stop() { var peer = new Peer { Id = _self.Id, PublicKey = _self.PublicKey, AgentVersion = _self.AgentVersion }; MultiAddress addr = "/ip4/0.0.0.0/tcp/0"; var swarm = new SwarmService { LocalPeer = peer }; await swarm.StartAsync(); try { await swarm.StartListeningAsync(addr); Assert.IsTrue(peer.Addresses.Any()); await swarm.StopListeningAsync(addr); Assert.AreEqual(0, peer.Addresses.Count()); await swarm.StartListeningAsync(addr); Assert.IsTrue(peer.Addresses.Any()); await swarm.StopListeningAsync(addr); Assert.AreEqual(0, peer.Addresses.Count()); } finally { await swarm.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 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); } }