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 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 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 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 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_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 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 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 void Listening_MissingTransport()
{
var peer = new Peer
{
Id = _self.Id,
PublicKey = _self.PublicKey,
AgentVersion = _self.AgentVersion
};
var swarm = new SwarmService {
LocalPeer = peer
};
ExceptionAssert.Throws <ArgumentException>(() =>
{
var _ = swarm.StartListeningAsync("/ip4/127.0.0.1").Result;
});
Assert.AreEqual(0, peer.Addresses.Count());
}
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 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 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 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 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 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();
}
}
/// <summary>
/// Starts the network services.
/// </summary>
/// <returns>
/// A task that represents the asynchronous operation.
/// </returns>
/// <remarks>
/// Starts the various IPFS and Lib.P2P network services. This should
/// be called after any configuration changes.
/// </remarks>
/// <exception cref="Exception">
/// When the engine is already started.
/// </exception>
public async Task StartAsync()
{
_dfsState.IsStarted = true;
if (_stopTasks.Count > 0)
{
throw new Exception("IPFS engine is already started.");
}
// Repository must be at the correct version.
await MigrationManager.MirgrateToVersionAsync(MigrationManager.LatestVersion).ConfigureAwait(false);
Log.Debug("starting " + LocalPeer.Id);
// Everybody needs the swarm.
_stopTasks.Add(async() => { await SwarmService.StopAsync().ConfigureAwait(false); });
await SwarmService.StartAsync().ConfigureAwait(false);
var peerManager = new PeerManager
{
SwarmService = SwarmService
};
await peerManager.StartAsync().ConfigureAwait(false);
_stopTasks.Add(async() => { await peerManager.StopAsync().ConfigureAwait(false); });
// Start the primary services.
var tasks = new List <Func <Task> >
{
async() =>
{
_stopTasks.Add(async() => await BitSwapService.StopAsync().ConfigureAwait(false));
await BitSwapService.StartAsync().ConfigureAwait(false);
},
async() =>
{
_stopTasks.Add(async() => await DhtService.StopAsync().ConfigureAwait(false));
await DhtService.StartAsync().ConfigureAwait(false);
},
async() =>
{
_stopTasks.Add(async() => await PingService.StopAsync().ConfigureAwait(false));
await PingService.StartAsync().ConfigureAwait(false);
},
async() =>
{
_stopTasks.Add(async() => await PubSubService.StopAsync().ConfigureAwait(false));
await PubSubService.StartAsync().ConfigureAwait(false);
}
};
Log.Debug("waiting for services to start");
await Task.WhenAll(tasks.Select(t => t())).ConfigureAwait(false);
// Starting listening to the swarm.
var json = await ConfigApi.GetAsync("Addresses.Swarm").ConfigureAwait(false);
var numberListeners = 0;
foreach (string a in json)
{
try
{
await SwarmService.StartListeningAsync(a).ConfigureAwait(false);
++numberListeners;
}
catch (Exception e)
{
Log.Warning($"Listener failure for '{a}'", e);
}
}
if (numberListeners == 0)
{
Log.Error("No listeners were created.");
}
// Now that the listener addresses are established, the discovery
// services can begin.
MulticastService multicast = null;
if (!Options.Discovery.DisableMdns)
{
multicast = new MulticastService();
#pragma warning disable CS1998
_stopTasks.Add(async() => multicast.Dispose());
#pragma warning restore CS1998
}
var autodialer = new AutoDialer(SwarmService)
{
MinConnections = Options.Swarm.MinConnections
};
#pragma warning disable CS1998
_stopTasks.Add(async() => autodialer.Dispose());
#pragma warning restore CS1998
tasks = new List <Func <Task> >
{
// Bootstrap discovery
async() =>
{
var bootstrap = new Bootstrap
{
Addresses = await BootstrapApi.ListAsync()
};
bootstrap.PeerDiscovered += OnPeerDiscovered;
_stopTasks.Add(async() => await bootstrap.StopAsync().ConfigureAwait(false));
await bootstrap.StartAsync().ConfigureAwait(false);
},
async() =>
{
if (Options.Discovery.DisableRandomWalk)
{
return;
}
var randomWalk = new RandomWalk {
Dht = DhtApi
};
_stopTasks.Add(async() => await randomWalk.StopAsync().ConfigureAwait(false));
await randomWalk.StartAsync().ConfigureAwait(false);
}
};
Log.Debug("waiting for discovery services to start");
await Task.WhenAll(tasks.Select(t => t())).ConfigureAwait(false);
multicast?.Start();
Log.Debug("started");
}
public async Task Connects_OnPeerDisconnected_When_Below_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");
var swarmC = new SwarmService {
LocalPeer = peerC
};
await swarmC.StartAsync();
var peerCAddress = await swarmC.StartListeningAsync("/ip4/127.0.0.1/tcp/0");
var isBConnected = false;
swarmA.ConnectionEstablished += (s, conn) =>
{
if (conn.RemotePeer == peerB)
{
isBConnected = true;
}
};
try
{
using (new AutoDialer(swarmA)
{
MinConnections = 1
})
{
swarmA.RegisterPeerAddress(peerBAddress);
var c = swarmA.RegisterPeerAddress(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); // get cancellaton token
}
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();
}
}
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();
}
}
