Beispiel #1
0
        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);
        }
Beispiel #2
0
        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());
        }
Beispiel #3
0
        public (InmemStore, Pub[]) InitInmemStore(int cacheSize)
        {
            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);
                var hex    = pubKey.ToHex();
                participantPubs.Add(new Pub {
                    Id = i, PrivKey = key, PubKey = pubKey, Hex = hex
                });
                participants.Add(hex, i);
            }

            var store = new InmemStore(participants, cacheSize, Log.Logger);

            return(store, participantPubs.ToArray());
        }