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();
}
}
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 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_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();
}
}
/// <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 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 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 void Start_NoLocalPeer()
{
var swarm = new SwarmService();
ExceptionAssert.Throws <NotSupportedException>(() =>
{
swarm.StartAsync().Wait();
});
}
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 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 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 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);
}
}
