//func removeBadgerStore(store *BadgerStore, t *testing.T) {
// if err = store.Close(); err != nil {
// t.Fatal(err)
// }
// if err = os.RemoveAll(store.path); err != nil {
// t.Fatal(err)
// }
//}
private static async Task <LocalDbStore> CreateTestDb(string dir, ILogger logger)
{
var participants = new Dictionary <string, int>
{
{
"alice", 0
},
{
"bob", 1
},
{
"charlie", 2
}
};
var cacheSize = 100;
var(storeBase, err) = await LocalDbStore.New(participants, cacheSize, dir, logger);
Assert.Null(err);
var store = storeBase as LocalDbStore;
Assert.NotNull(store);
return(store);
}
private static async Task <(LocalDbStore store, Pub[] pubs)> InitBadgerStore(int cacheSize, string dbPath, ILogger logger)
{
var n = 3;
var participantPubs = new List <Pub>();
var participants = new Dictionary <string, int>();
for (var i = 0; i < n; i++)
{
var key = CryptoUtils.GenerateEcdsaKey();
var pubKey = CryptoUtils.FromEcdsaPub(key);
participantPubs.Add(new Pub {
Id = i, PrivKey = key, PubKey = pubKey, Hex = pubKey.ToHex()
});
participants[pubKey.ToHex()] = i;
}
var(storeBase, err) = await LocalDbStore.New(participants, cacheSize, dbPath, logger);
Assert.Null(err);
var store = storeBase as LocalDbStore;
Assert.NotNull(store);
return(store, participantPubs.ToArray());
}
private static async Task <Node> RecycleNode(Node oldNode, ILogger logger)
{
var conf = oldNode.Conf;
var id = oldNode.Id;
var key = oldNode.Controller.Key;
var peers = oldNode.PeerSelector.Peers();
IStore store = null;
if (oldNode.Store is InmemStore)
{
store = new InmemStore(oldNode.Store.Participants().participants.Clone(), conf.CacheSize, logger);
}
if (oldNode.Store is LocalDbStore)
{
(store, _) = await LocalDbStore.Load(conf.CacheSize, conf.StorePath, logger);
}
Assert.NotNull(store);
await oldNode.Trans.CloseAsync();
var trans = await((InMemRouterTransport)oldNode.Trans).Router.Register(oldNode.LocalAddr);
var prox = new InMemAppProxy(id, logger);
var newNode = new Node(conf, id, key, peers, store, trans, prox, logger);
var err = await newNode.Init(true);
Assert.Null(err);
return(newNode);
}
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 TestLoadStore()
{
var dbPath = GetPath();
//Create the test db
var tempStore = await CreateTestDb(dbPath, logger);
Assert.NotNull(tempStore);
tempStore.Close();
var cacheSize = 100;
var(badgerStoreres, err) = await LocalDbStore.Load(cacheSize, tempStore.Path, logger);
var badgerStore = badgerStoreres as LocalDbStore;
Assert.NotNull(badgerStore);
Assert.Null(err);
Dictionary <string, int> dbParticipants;
using (var tx = badgerStore.BeginTx())
{
(dbParticipants, err) = await badgerStore.DbGetParticipants();
}
Assert.Null(err);
Assert.Equal(badgerStore.Participants().participants.Count, dbParticipants.Count);
foreach (var p in dbParticipants)
{
var dbP = p.Key;
var dbId = p.Value;
var ok = badgerStore.Participants().participants.TryGetValue(dbP, out int id);
Assert.True(ok);
Assert.Equal(id, dbId);
}
}
