public async Task Can_Start_And_Stop()
{
var peer = _dfs1.LocalPeer;
Assert.False(_dfs1.IsStarted);
await _dfs1.StartAsync();
Assert.True(_dfs1.IsStarted);
Assert.AreNotEqual(0, peer.Addresses.Count());
await _dfs1.StopAsync();
Assert.False(_dfs1.IsStarted);
Assert.AreEqual(0, peer.Addresses.Count());
await _dfs1.StartAsync();
Assert.AreNotEqual(0, peer.Addresses.Count());
await _dfs1.StopAsync();
Assert.AreEqual(0, peer.Addresses.Count());
await _dfs1.StartAsync();
Assert.AreNotEqual(0, peer.Addresses.Count());
ExceptionAssert.Throws <Exception>(() => _dfs1.StartAsync().Wait());
await _dfs1.StopAsync();
Assert.AreEqual(0, peer.Addresses.Count());
}
public async Task OnConnect_Sends_WantList()
{
_dfsService.Options.Discovery.DisableMdns = true;
_dfsService.Options.Discovery.BootstrapPeers = new MultiAddress[0];
await _dfsService.StartAsync();
_dfsServiceOther.Options.Discovery.DisableMdns = true;
_dfsServiceOther.Options.Discovery.BootstrapPeers = new MultiAddress[0];
await _dfsServiceOther.StartAsync();
try
{
var local = _dfsService.LocalPeer;
var remote = _dfsServiceOther.LocalPeer;
TestContext.WriteLine($"this at {local.Addresses.First()}");
TestContext.WriteLine($"other at {remote.Addresses.First()}");
var data = Guid.NewGuid().ToByteArray();
var cid = new Cid
{
Hash = MultiHash.ComputeHash(data)
};
var _ = _dfsService.BlockApi.GetAsync(cid);
await _dfsService.SwarmApi.ConnectAsync(remote.Addresses.First());
var endTime = DateTime.Now.AddSeconds(10);
while (DateTime.Now < endTime)
{
var wants = await _dfsServiceOther.BitSwapApi.WantsAsync(local.Id);
if (wants.Contains(cid))
{
return;
}
await Task.Delay(200);
}
throw new Exception("want list not sent");
}
finally
{
await _dfsServiceOther.StopAsync();
await _dfsService.StopAsync();
_dfsService.Options.Discovery = new DiscoveryOptions();
_dfsServiceOther.Options.Discovery = new DiscoveryOptions();
}
}
public async Task Put_Informs_Bitswap()
{
_dfs = TestDfs.GetTestDfs(null, "sha2-256");
await _dfs.StartAsync();
try
{
var data = Guid.NewGuid().ToByteArray();
var cid = new Cid
{
Hash = MultiHash.ComputeHash(data)
};
var cts = new CancellationTokenSource();
cts.CancelAfter(20000);
var wantTask = _dfs.BitSwapApi.GetAsync(cid, cts.Token);
var cid1 = await _dfs.BlockApi.PutAsync(data, cancel : cts.Token);
Assert.AreEqual(cid, cid1);
Assert.AreEqual(cid, wantTask.Result.Id);
Assert.AreEqual(data.Length, wantTask.Result.Size);
Assert.AreEqual(data, wantTask.Result.DataBytes);
}
finally
{
await _dfs.StopAsync();
}
}
public async Task RunAsync(CancellationToken ct)
{
_logger.Information("Starting the Catalyst Node");
_logger.Information($"***** using PublicKey: {_publicKey.Bytes.ToBase32()} *****");
await StartSocketsAsync().ConfigureAwait(false);
_dfsService.StartAsync().ConfigureAwait(false);
_synchronizer.StartAsync().ConfigureAwait(false);
_synchronizer.SyncCompleted.Subscribe((x) =>
{
var currentPoaNode = _peerRepository.GetPeersByIpAndPublicKey(_peerSettings.PeerId.Ip, _peerSettings.PeerId.PublicKey).FirstOrDefault();
if (currentPoaNode == null)
{
_logger.Information($"Current node with IP address '{_peerSettings.PeerId.Ip}' is not found in poa node list. So this node will not take part in consensus.");
}
else
{
Consensus.StartProducing();
}
});
bool exit;
do
{
await Task.Delay(300, ct); //just to get the exit message at the bottom
_logger.Debug("Type 'exit' to exit, anything else to continue");
exit = string.Equals(Console.ReadLine(), "exit", StringComparison.OrdinalIgnoreCase);
} while (!ct.IsCancellationRequested);
_logger.Debug("Stopping the Catalyst Node");
}
public async Task UnWant()
{
await _dfsService.StartAsync();
try
{
var cts = new CancellationTokenSource();
var block = new DagNode(Encoding.UTF8.GetBytes("BitSwapApiTest unknown block 2"));
var wantTask = _dfsService.BitSwapApi.GetAsync(block.Id, cts.Token).ConfigureAwait(false);
var endTime = DateTime.Now.AddSeconds(10);
while (true)
{
if (DateTime.Now > endTime)
{
throw new Exception("wanted block is missing");
}
await Task.Delay(100, cts.Token);
var w = await _dfsService.BitSwapApi.WantsAsync(cancel : cts.Token);
if (w.Contains(block.Id))
{
break;
}
}
cts.Cancel();
_dfsService.BitSwapApi.UnWant(block.Id, cts.Token);
var wants = await _dfsService.BitSwapApi.WantsAsync(cancel : cts.Token);
wants.ToArray().Should().NotContain(block.Id);
//Race condition as wantTask will be on another thread and could create unpredictable behaviour
//Assert.True(wantTask.IsCanceled);
}
finally
{
await _dfsService.StopAsync();
}
}
public async Task Put_Informs_Dht()
{
var data = Guid.NewGuid().ToByteArray();
await _dfs.StartAsync();
try
{
var self = _dfs.LocalPeer;
var cid = await _dfs.BlockApi.PutAsync(data);
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(3));
var peers = await _dfs.DhtApi.FindProvidersAsync(cid, 1, cancel : cts.Token);
Assert.AreEqual(self, peers.First());
}
finally
{
await _dfs.StopAsync();
}
}
public async Task Can_Start_And_Stop_MultipleEngines()
{
var peer1 = _dfs1.LocalPeer;
var peer2 = _dfs2.LocalPeer;
for (int n = 0; n < 3; ++n)
{
await _dfs1.StartAsync();
Assert.AreNotEqual(0, peer1.Addresses.Count());
await _dfs2.StartAsync();
Assert.AreNotEqual(0, peer2.Addresses.Count());
await _dfs2.StopAsync();
Assert.AreEqual(0, peer2.Addresses.Count());
await _dfs1.StopAsync();
Assert.AreEqual(0, peer1.Addresses.Count());
}
}
public async Task Subscribed_Topics()
{
var topic = Guid.NewGuid().ToString();
var cs = new CancellationTokenSource();
await ipfs.StartAsync();
try
{
await ipfs.PubSubApi.SubscribeAsync(topic, msg => { }, cs.Token);
var topics = ipfs.PubSubApi.SubscribedTopicsAsync(cs.Token).Result.ToArray();
Assert.True(topics.Length > 0);
topics.Should().Contain(topic);
}
finally
{
await ipfs.StopAsync();
cs.Cancel();
}
}
