private static async Task <(CngKey[] keys, Node[] nodes)> InitNodes(int n, int cacheSize, int syncLimit, string storeType, string dbPath, ILogger logger)
{
var(keys, peers, pmap) = InitPeers(n);
var nodes = new List <Node>();
var proxies = new List <InMemAppProxy>();
var router = new InMemRouter();
for (var i = 0; i < peers.Length; i++)
{
var conf = new Config(TimeSpan.FromMilliseconds(5), TimeSpan.FromSeconds(1), cacheSize, syncLimit, storeType, $"{dbPath}/db_{i}");
var trans = await router.Register(peers[i].NetAddr);
IStore store = null;
Exception err;
switch (storeType)
{
case "badger":
(store, err) = await LocalDbStore.New(pmap, conf.CacheSize, conf.StorePath, logger);
Assert.Null(err);
break;
case "inmem":
store = new InmemStore(pmap, conf.CacheSize, logger);
break;
default:
throw new NotImplementedException();
}
var id = pmap[peers[i].PubKeyHex];
var proxy = new InMemAppProxy(id, logger);
var node = new Node(conf, id, keys[i], peers,
store,
trans,
proxy, logger);
err = await node.Init(false);
Assert.Null(err);
nodes.Add(node);
proxies.Add(proxy);
}
return(keys.ToArray(), nodes.ToArray());
}
public async Task TestProcessSync()
{
var(keys, peers, pmap) = InitPeers(2);
var config = Config.TestConfig();
//Start two nodes
var router = new InMemRouter();
var id0 = pmap[peers[0].PubKeyHex];
var peer0Trans = await router.Register(peers[0].NetAddr);
var node0 = new Node(config, id0, keys[0], peers, new InmemStore(pmap, config.CacheSize, logger), peer0Trans, new InMemAppProxy(id0, logger), logger);
await node0.Init(false);
await node0.StartAsync(false);
var id1 = pmap[peers[1].PubKeyHex];
var peer1Trans = await router.Register(peers[1].NetAddr);
var node1 = new Node(config, id1, keys[1], peers, new InmemStore(pmap, config.CacheSize, logger), peer1Trans, new InMemAppProxy(id1, logger), logger);
await node1.Init(false);
await node1.StartAsync(false);
//Manually prepare SyncRequest and expected SyncResponse
var node0Known = await node0.Controller.KnownEvents();
var node1Known = await node1.Controller.KnownEvents();
Exception err;
Event[] unknown;
(unknown, err) = await node1.Controller.EventDiff(node0Known);
Assert.Null(err);
WireEvent[] unknownWire;
(unknownWire, err) = node1.Controller.ToWire(unknown);
Assert.Null(err);
var args = new SyncRequest
{
FromId = node0.Id,
Known = node0Known
};
var expectedResp = new SyncResponse
{
FromId = node1.Id,
Events = unknownWire,
Known = node1Known
};
//Make actual SyncRequest and check SyncResponse
SyncResponse resp;
(resp, err) = await peer0Trans.Sync(peers[1].NetAddr, args);
Assert.Null(err);
// Verify the response
resp.ShouldCompareTo(expectedResp);
Assert.Equal(expectedResp.Events.Length, resp.Events.Length);
int i = 0;
foreach (var e in expectedResp.Events)
{
var ex = resp.Events[i];
e.Body.ShouldCompareTo(ex.Body);
i++;
}
resp.Known.ShouldCompareTo(expectedResp.Known);
// shutdown nodes
node0.Shutdown();
node1.Shutdown();
}
public async Task TestAddTransaction()
{
var(keys, peers, pmap) = InitPeers(2);
var config = Config.TestConfig();
//Start two nodes
var router = new InMemRouter();
var id0 = pmap[peers[0].PubKeyHex];
var peer0Trans = await router.Register(peers[0].NetAddr);
var peer0Proxy = new InMemAppProxy(id0, logger);
var node0 = new Node(config, id0, keys[0], peers, new InmemStore(pmap, config.CacheSize, logger), peer0Trans, peer0Proxy, logger);
await node0.Init(false);
await node0.StartAsync(false);
var id1 = pmap[peers[1].PubKeyHex];
var peer1Trans = await router.Register(peers[1].NetAddr);
var peer1Proxy = new InMemAppProxy(id1, logger);
var node1 = new Node(config, id1, keys[1], peers, new InmemStore(pmap, config.CacheSize, logger), peer1Trans, peer1Proxy, logger);
await node1.Init(false);
await node1.StartAsync(false);
//Submit a Tx to node0
var message = "Hello World!";
await peer0Proxy.SubmitTx(message.StringToBytes());
await node0.AddingTransactionsCompleted();
//simulate a SyncRequest from node0 to node1
var node0Known = await node0.Controller.KnownEvents();
var args = new SyncRequest
{
FromId = node0.Id,
Known = node0Known
};
Exception err;
SyncResponse resp;
(resp, err) = await peer0Trans.Sync(peers[1].NetAddr, args);
Assert.Null(err);
err = await node0.Sync(resp.Events);
Assert.Null(err);
////check the Tx was removed from the transactionPool and added to the new Head
Assert.Empty(node0.Controller.TransactionPool);
var(node0Head, _) = await node0.Controller.GetHead();
Assert.Single(node0Head.Transactions());
Assert.Equal(message, node0Head.Transactions()[0].BytesToString());
node0.Shutdown();
node1.Shutdown();
}
public async Task TestProcessEagerSync()
{
var(keys, peers, pmap) = InitPeers(2);
var config = Config.TestConfig();
//Start two nodes
var router = new InMemRouter();
var id0 = pmap[peers[0].PubKeyHex];
var peer0Trans = await router.Register(peers[0].NetAddr);
var node0 = new Node(config, id0, keys[0], peers, new InmemStore(pmap, config.CacheSize, logger), peer0Trans, new InMemAppProxy(id0, logger), logger);
await node0.Init(false);
await node0.StartAsync(false);
var peer1Trans = await router.Register(peers[1].NetAddr);
var id1 = pmap[peers[1].PubKeyHex];
var node1 = new Node(config, id1, keys[1], peers, new InmemStore(pmap, config.CacheSize, logger), peer1Trans, new InMemAppProxy(id1, logger), logger);
await node1.Init(false);
await node1.StartAsync(false);
//Manually prepare EagerSyncRequest and expected EagerSyncResponse
var node1Known = await node1.Controller.KnownEvents();
Event[] unknown;
Exception err;
(unknown, err) = await node0.Controller.EventDiff(node1Known);
Assert.Null(err);
WireEvent[] unknownWire;
(unknownWire, err) = node0.Controller.ToWire(unknown);
Assert.Null(err);
var args = new EagerSyncRequest
{
FromId = node0.Id,
Events = unknownWire
};
var expectedResp = new EagerSyncResponse
{
FromId = node1.Id,
Success = true
};
//Make actual EagerSyncRequest and check EagerSyncResponse
EagerSyncResponse resp;
(resp, err) = await peer0Trans.EagerSync(peers[1].NetAddr, args);
Assert.Null(err);
// Verify the response
Assert.Equal(expectedResp.Success, resp.Success);
// shutdown nodes
node0.Shutdown();
node1.Shutdown();
}
