public void Initialize() { var privateKey = new PrivateKey(TestPrivateKeyHex); _publicKey = privateKey.PublicKey; var logManager = NullLogManager.Instance; //var config = new NetworkConfigurationProvider(new NetworkHelper(logger)) { PongTimeout = 100 }; var config = new JsonConfigProvider(); var networkConfig = config.GetConfig <INetworkConfig>(); networkConfig.PongTimeout = 100; var statsConfig = config.GetConfig <IStatsConfig>(); _messageSender = Substitute.For <IMessageSender>(); _nodeFactory = new NodeFactory(); var calculator = new NodeDistanceCalculator(config); _nodeTable = new NodeTable(_nodeFactory, new FileKeyStore(config, new JsonSerializer(logManager), new AesEncrypter(config, logManager), new CryptoRandom(), logManager), calculator, config, logManager); _nodeTable.Initialize(); var evictionManager = new EvictionManager(_nodeTable, logManager); var lifecycleFactory = new NodeLifecycleManagerFactory(_nodeFactory, _nodeTable, new DiscoveryMessageFactory(config), evictionManager, new NodeStatsProvider(statsConfig, _nodeFactory, logManager), config, logManager); _nodes = new[] { _nodeFactory.CreateNode("192.168.1.18", 1), _nodeFactory.CreateNode("192.168.1.19", 2) }; _discoveryManager = new DiscoveryManager(lifecycleFactory, _nodeFactory, _nodeTable, new NetworkStorage("test", networkConfig, logManager, new PerfService(logManager)), config, logManager); _discoveryManager.MessageSender = _messageSender; }
private void AddPersistedNodes() { if (!_configurationProvider.IsDiscoveryNodesPersistenceOn) { return; } var nodes = _discoveryStorage.GetPersistedNodes(); foreach (var networkNode in nodes) { var node = _nodeFactory.CreateNode(networkNode.NodeId, networkNode.Host, networkNode.Port); var manager = _discoveryManager.GetNodeLifecycleManager(node, true); if (manager == null) { if (_logger.IsDebug) { _logger.Debug($"Skiping persisted node {networkNode.NodeId}@{networkNode.Host}:{networkNode.Port}, manager couldnt be created"); } continue;; } manager.NodeStats.CurrentPersistedNodeReputation = networkNode.Reputation; if (_logger.IsTrace) { _logger.Trace($"Adding persisted node {networkNode.NodeId}@{networkNode.Host}:{networkNode.Port}"); } } if (_logger.IsInfo) { _logger.Info($"Added persisted discovery nodes: {nodes.Length}"); } }
public void Initialize() { NetworkNodeDecoder.Init(); var privateKey = new PrivateKey(TestPrivateKeyHex); _publicKey = privateKey.PublicKey; var logManager = NullLogManager.Instance; IKeyStoreConfig keyStoreConfig = new KeyStoreConfig(); INetworkConfig networkConfig = new NetworkConfig(); networkConfig.PongTimeout = 100; IStatsConfig statsConfig = new StatsConfig(); _messageSender = Substitute.For <IMessageSender>(); _nodeFactory = new NodeFactory(LimboLogs.Instance); var calculator = new NodeDistanceCalculator(networkConfig); _nodeTable = new NodeTable(_nodeFactory, new FileKeyStore(keyStoreConfig, new EthereumJsonSerializer(), new AesEncrypter(keyStoreConfig, logManager), new CryptoRandom(), logManager), calculator, networkConfig, logManager); _nodeTable.Initialize(); _timestamp = new Timestamp(); var evictionManager = new EvictionManager(_nodeTable, logManager); var lifecycleFactory = new NodeLifecycleManagerFactory(_nodeFactory, _nodeTable, new DiscoveryMessageFactory(networkConfig, _timestamp), evictionManager, new NodeStatsProvider(statsConfig, _nodeFactory, logManager, true), networkConfig, logManager); _nodes = new[] { _nodeFactory.CreateNode("192.168.1.18", 1), _nodeFactory.CreateNode("192.168.1.19", 2) }; _discoveryManager = new DiscoveryManager(lifecycleFactory, _nodeFactory, _nodeTable, new NetworkStorage("test", networkConfig, logManager, new PerfService(logManager)), networkConfig, logManager); _discoveryManager.MessageSender = _messageSender; }
private void AddTrustedPeers() { var trustedPeers = _configurationProvider.TrustedPeers; if (trustedPeers == null || !trustedPeers.Any()) { return; } if (_logger.IsInfoEnabled) { _logger.Info("Initializing trusted peers."); } foreach (var trustedPeer in trustedPeers) { var node = _nodeFactory.CreateNode(new NodeId(new PublicKey(new Hex(trustedPeer.NodeId))), trustedPeer.Host, trustedPeer.Port); node.Description = trustedPeer.Description; var nodeStats = _nodeStatsProvider.GetNodeStats(node.Id); nodeStats.IsTrustedPeer = true; var peer = new Peer(node, nodeStats); if (!_candidatePeers.TryAdd(node.Id, peer)) { continue; } if (_logger.IsInfoEnabled) { _logger.Info($"Adding trusted peer to New collection {node.Id}@{node.Host}:{node.Port}"); } } }
public void Can_store_discovery_nodes() { var persistedNodes = _storage.GetPersistedNodes(); Assert.AreEqual(0, persistedNodes.Length); var nodes = new[] { _nodeFactory.CreateNode("192.1.1.1", 3441), _nodeFactory.CreateNode("192.1.1.2", 3442), _nodeFactory.CreateNode("192.1.1.3", 3443), _nodeFactory.CreateNode("192.1.1.4", 3444), _nodeFactory.CreateNode("192.1.1.5", 3445) }; nodes[0].Description = "Test desc"; nodes[4].Description = "Test desc 2"; var managers = nodes.Select(CreateLifecycleManager).ToArray(); var networkNodes = managers.Select(x => new NetworkNode(x.ManagedNode.Id.PublicKey, x.ManagedNode.Host, x.ManagedNode.Port, x.ManagedNode.Description, x.NodeStats.NewPersistedNodeReputation)).ToArray(); _storage.StartBatch(); _storage.UpdateNodes(networkNodes); _storage.Commit(); persistedNodes = _storage.GetPersistedNodes(); foreach (INodeLifecycleManager manager in managers) { NetworkNode persistedNode = persistedNodes.FirstOrDefault(x => x.NodeId.Equals(manager.ManagedNode.Id)); Assert.IsNotNull(persistedNode); Assert.AreEqual(manager.ManagedNode.Port, persistedNode.Port); Assert.AreEqual(manager.ManagedNode.Host, persistedNode.Host); Assert.AreEqual(manager.ManagedNode.Description, persistedNode.Description); Assert.AreEqual(manager.NodeStats.CurrentNodeReputation, persistedNode.Reputation); } _storage.StartBatch(); _storage.RemoveNodes(new[] { networkNodes.First() }); _storage.Commit(); persistedNodes = _storage.GetPersistedNodes(); foreach (INodeLifecycleManager manager in managers.Take(1)) { NetworkNode persistedNode = persistedNodes.FirstOrDefault(x => x.NodeId.Equals(manager.ManagedNode.Id)); Assert.IsNull(persistedNode); } foreach (INodeLifecycleManager manager in managers.Skip(1)) { NetworkNode persistedNode = persistedNodes.FirstOrDefault(x => x.NodeId.Equals(manager.ManagedNode.Id)); Assert.IsNotNull(persistedNode); Assert.AreEqual(manager.ManagedNode.Port, persistedNode.Port); Assert.AreEqual(manager.ManagedNode.Host, persistedNode.Host); Assert.AreEqual(manager.ManagedNode.Description, persistedNode.Description); Assert.AreEqual(manager.NodeStats.CurrentNodeReputation, persistedNode.Reputation); } }
public void PeersReadWriteTest() { var persistedPeers = _peerStorage.GetPersistedPeers(); Assert.AreEqual(0, persistedPeers.Length); var nodes = new[] { _nodeFactory.CreateNode("192.1.1.1", 3441), _nodeFactory.CreateNode("192.1.1.2", 3442), _nodeFactory.CreateNode("192.1.1.3", 3443), _nodeFactory.CreateNode("192.1.1.4", 3444), _nodeFactory.CreateNode("192.1.1.5", 3445), }; nodes[0].Description = "Test desc"; nodes[4].Description = "Test desc 2"; var peers = nodes.Select(x => new Peer(x, new NodeStats(_configurationProvider))).ToArray(); _peerStorage.StartBatch(); _peerStorage.UpdatePeers(peers); _peerStorage.Commit(); persistedPeers = _peerStorage.GetPersistedPeers(); foreach (var peer in peers) { var persistedNode = persistedPeers.FirstOrDefault(x => x.Node.Id.Equals(peer.Node.Id)); Assert.IsNotNull(persistedNode); Assert.AreEqual(peer.Node.Port, persistedNode.Node.Port); Assert.AreEqual(peer.Node.Host, persistedNode.Node.Host); Assert.AreEqual(peer.Node.Description, persistedNode.Node.Description); Assert.AreEqual(peer.NodeStats.CurrentNodeReputation, persistedNode.PersistedReputation); } _peerStorage.StartBatch(); _peerStorage.RemovePeers(peers.Take(1).ToArray()); _peerStorage.Commit(); persistedPeers = _peerStorage.GetPersistedPeers(); foreach (var peer in peers.Take(1)) { var persistedNode = persistedPeers.FirstOrDefault(x => x.Node.Id.Equals(peer.Node.Id)); Assert.IsNull(persistedNode.Node); } foreach (var peer in peers.Skip(1)) { var persistedNode = persistedPeers.FirstOrDefault(x => x.Node.Id.Equals(peer.Node.Id)); Assert.IsNotNull(persistedNode); Assert.AreEqual(peer.Node.Port, persistedNode.Node.Port); Assert.AreEqual(peer.Node.Host, persistedNode.Node.Host); Assert.AreEqual(peer.Node.Description, persistedNode.Node.Description); Assert.AreEqual(peer.NodeStats.CurrentNodeReputation, persistedNode.PersistedReputation); } }
public void InPeerBecomesActiveAndDisconnectTest() { var node = _nodeFactory.CreateNode("192.1.1.1", 3333); //trigger connection initialized var p2pSession = new TestP2PSession(); p2pSession.RemoteNodeId = node.Id; p2pSession.RemoteHost = node.Host; p2pSession.RemotePort = node.Port; p2pSession.ConnectionDirection = ConnectionDirection.In; _localPeer.TriggerSessionCreated(p2pSession); p2pSession.TriggerHandshakeComplete(); //trigger p2p initialization var p2pProtocol = new P2PProtocolHandler(p2pSession, new MessageSerializationService(), p2pSession.RemoteNodeId, p2pSession.RemotePort ?? 0, _logManager, new PerfService(_logManager)); var p2pArgs = new P2PProtocolInitializedEventArgs(p2pProtocol) { P2PVersion = 4, Capabilities = new[] { new Capability(Protocol.Eth, 62), new Capability(Protocol.Eth, 63) }.ToList() }; p2pSession.TriggerProtocolInitialized(p2pArgs); AssertTrue(() => _peerManager.ActivePeers.First().NodeStats.DidEventHappen(NodeStatsEventType.P2PInitialized), 5000); //Assert.IsTrue(_peerManager.ActivePeers.First().NodeStats.DidEventHappen(NodeStatsEventType.P2PInitialized)); //trigger eth62 initialization var eth62 = new Eth62ProtocolHandler(p2pSession, new MessageSerializationService(), _synchronizationManager, _logManager, new PerfService(_logManager), _blockTree, _transactionPool, _timestamp); var args = new EthProtocolInitializedEventArgs(eth62) { ChainId = _synchronizationManager.ChainId }; p2pSession.TriggerProtocolInitialized(args); AssertTrue(() => _peerManager.ActivePeers.First().NodeStats.DidEventHappen(NodeStatsEventType.Eth62Initialized), 5000); Assert.AreEqual(1, _peerManager.CandidatePeers.Count); Assert.AreEqual(1, _peerManager.ActivePeers.Count); //Assert.IsTrue(_peerManager.ActivePeers.First().NodeStats.DidEventHappen(NodeStatsEventType.Eth62Initialized)); AssertTrue(() => _peerManager.ActivePeers.First().SynchronizationPeer != null, 5000); //Assert.NotNull(_peerManager.ActivePeers.First().SynchronizationPeer); //verify active peer was added to synch manager _synchronizationManager.Received(1).AddPeer(Arg.Any <ISynchronizationPeer>()); //trigger disconnect p2pSession.TriggerPeerDisconnected(); AssertTrue(() => _peerManager.ActivePeers.Count == 0, 5000); Assert.AreEqual(1, _peerManager.CandidatePeers.Count); //Assert.AreEqual(0, _peerManager.ActivePeers.Count); //verify active peer was removed from synch manager _synchronizationManager.Received(1).RemovePeer(Arg.Any <ISynchronizationPeer>()); }
public MatrixMap(string path, Directions directions, INodeFactory nodeFactory, INeighbourFuncFactory neighbourFuncFactory) { var lines = File.ReadAllLines(path); var N = lines.Count(); Nodes = new Node[N, N]; SizeX = N; SizeY = N; CreateNodes(nodeFactory, lines, N); GetNeighboursOf = neighbourFuncFactory.CreateFunc(directions, SizeX, SizeY); void CreateNodes(INodeFactory nodeFactory, string[] lines, int N) { for (var i = 0; i < N; i++) { var costs = lines[i].Split(','); for (var j = 0; j < N; j++) { var cost = Convert.ToInt32(costs[j]); Nodes[i, j] = nodeFactory.CreateNode(cost); } } } }
/// <summary> /// Creates tree from hierarchy hasthtable /// </summary> /// <param name="root">Root object</param> /// <param name="factory">Factory</param> /// <param name="hierarchy">Hierarchy hashtable</param> /// <param name="links">Links between nodes and objects</param> /// <returns>Root node</returns> public static INode CreateTree(object root, INodeFactory factory, Hashtable hierarchy, Hashtable links) { INode node = factory.CreateNode(root); ++commonCount; if (hierarchy.ContainsKey(root)) { ArrayList list = hierarchy[root] as ArrayList; foreach (object o in list) { INode n = CreateTree(o, factory, hierarchy, links); n.Parent = node; } } if (links != null) { ArrayList l = null; if (links.ContainsKey(root)) { l = links[root] as ArrayList; } else { l = new ArrayList(); links[root] = l; } l.Add(node); } return(node); }
private INode Insert(INode h, K key, V val) { if (h == null) return nodeFactory.CreateNode(key, val, Color.Red); // split 4-nodes on the way down if (IsRed(h.Left) && IsRed(h.Left.Left)) h = SplitFourNode(h); // standard BST insert code int cmp = key.CompareTo(h.Key); if (cmp == 0) AddToValues(h, val); else if (cmp < 0) h.Left = Insert(h.Left, key, val); else h.Right = Insert(h.Right, key, val); // fix right-leaning reds on the way up if (IsRed(h.Right)) h = LeanLeft(h); return h; }
private TestP2PSession InitializeNode() { var node = _nodeFactory.CreateNode("192.1.1.1", 3333); _discoveryManager.GetNodeLifecycleManager(node); //verify new peer is added Assert.AreEqual(1, _peerManager.NewPeers.Count); Assert.AreEqual(node.Id, _peerManager.NewPeers.First().Node.Id); //trigger connection start var task = _peerManager.RunPeerUpdate(); task.Wait(); Assert.AreEqual(1, _localPeer.ConnectionAsyncCallsCounter); Assert.AreEqual(0, _peerManager.NewPeers.Count); Assert.AreEqual(1, _peerManager.ActivePeers.Count); //trigger connection initialized var p2pSession = new TestP2PSession(); p2pSession.RemoteNodeId = node.Id; _localPeer.TriggerConnectionInitialized(p2pSession); var peer = _peerManager.ActivePeers.First(); Assert.IsNotNull(peer.Session); return(p2pSession); }
private NodeBunch BuildCustomItem(Element item) { var links = item.GetItemLinks(); var headNode = _nodeFactory.CreateNode(item.AsPseudoList()); if (headNode == null) { throw new BuildingException("Node factory returned null."); } var tree = headNode.FetchTree(); if (tree.Count == 1) { var nodeBox = new NodeBox(headNode, links); return(new NodeBunch(nodeBox, nodeBox)); } else { var headNodeBox = new NodeBox(headNode); try { var tailNode = tree.Single(x => x.EstablishedLinks.Count == 0); var tailNodeBox = new NodeBox(tailNode, links); return(new NodeBunch(headNodeBox, tailNodeBox)); } catch (Exception ex) { throw new BuildingException("More than one tail node (the node which doesn't have links).", ex); } } }
public void Initialize(NodeId masterNodeKey = null) { Buckets = new NodeBucket[_configurationProvider.BucketsCount]; var pass = new SecureString(); var rawPass = _configurationProvider.KeyPass; for (var i = 0; i < rawPass.Length; i++) { pass.AppendChar(rawPass[i]); } pass.MakeReadOnly(); if (masterNodeKey == null) { var key = _keyStore.GenerateKey(pass); if (key.Item2.ResultType == ResultType.Failure) { var msg = $"Cannot create key, error: {key.Item2.Error}"; _logger.Error(msg); throw new Exception(msg); } masterNodeKey = new NodeId(key.PrivateKey.PublicKey); } MasterNode = _nodeFactory.CreateNode(masterNodeKey, _configurationProvider.MasterHost, _configurationProvider.MasterPort); _logger.Info($"Created MasterNode: {MasterNode}"); for (var i = 0; i < Buckets.Length; i++) { Buckets[i] = new NodeBucket(i, _configurationProvider.BucketSize); } }
/// <summary> /// Create root node from collection of nodes /// </summary> /// <param name="objects">Prototypes</param> /// <param name="factory">Factory</param> /// <returns>Root node</returns> public static INode CreateRootNode(ICollection objects, INodeFactory factory) { INode root = null; Hashtable hash = new Hashtable(); ArrayList nodes = new ArrayList(); foreach (object o in objects) { try { INode node = factory.CreateNode(o); nodes.Add(node); hash[node.Id] = node; } catch (Exception e) { throw e; } } foreach (INode node in nodes) { object p = node.ParentId; if (p == null) { root = node; } else if (p.Equals(node.Id)) { root = node; continue; } INode parent = hash[p] as INode; if (parent != null) { node.Parent = parent; } } if (root != null) { return(root); } if (root == null) { foreach (INode node in hash.Values) { if (node.Parent == null) { root = node; break; } } } return(root); }
public INodeLifecycleManager CreateNodeLifecycleManager(NodeId id, string host, int port) { if (DiscoveryManager == null) { throw new Exception($"{nameof(DiscoveryManager)} has to be set"); } var node = _nodeFactory.CreateNode(id, host, port); return(new NodeLifecycleManager(node, DiscoveryManager, _nodeTable, _logger, _configurationProvider, _discoveryMessageFactory, _evictionManager, _nodeStatsProvider.GetOrAddNodeStats(node))); }
/// <summary> /// Creates peer tree /// </summary> /// <param name="prototypeRoot">Root of prototype node</param> /// <param name="factory">Node factory</param> /// <returns>Root of prototype tree</returns> public static INode CreatePeerTree(INode prototypeRoot, INodeFactory factory) { INode root = factory.CreateNode(prototypeRoot); for (int i = 0; i < prototypeRoot.Count; i++) { INode n = prototypeRoot[i]; INode node = CreatePeerTree(n, factory); node.Parent = root; } return(root); }
/// <summary> /// Creates subtree /// </summary> /// <param name="node">Root</param> /// <param name="list">List of nodes</param> /// <param name="factory">Factory</param> /// <returns>Tree root</returns> public static INode CreateSubTree(INode node, ArrayList list, INodeFactory factory) { INode root = factory.CreateNode(node); for (int i = 0; i < node.Count; i++) { if (list.Contains(node[i])) { INode nod = CreateSubTree(node[i], list, factory); nod.Parent = root; } } return(root); }
private void GenerateDialogueNodes(GraphItem graphItem) { foreach (var node in graphItem.NodeData) { var tempNode = nodeFactory.CreateNode(node.nodeType, graphView); if (tempNode == null) { continue; } tempNode.nodeGuid = node.nodeGuid; tempNode.SetPosition(new Rect(node.position, graphView.DefaultNodeSize)); graphView.AddElement(tempNode); //tempNode.PopulateAdditionalData(node.additionalDataJSON); } }
/// <summary> /// Navigates to the given node. /// </summary> /// <param name="nodeFactory">Node factory class to create the node for the</param> /// <param name="nodeContext"></param> public void Navigate(INodeFactory nodeFactory, INodeContext nodeContext) { if (nodeFactory == null) { ExceptionManager.Throw(new ArgumentNullException("nodeFactory")); } if (nodeContext == null) { ExceptionManager.Throw(new ArgumentNullException("nodeContext")); } _currentNode = _navigationManager.GetCurrentNode(); INode currentNode = nodeFactory.CreateNode(nodeContext); NavigateToNode(currentNode); }
/// <summary> /// Create roots' nodes from collection of nodes /// </summary> /// <param name="objects">Prototypes</param> /// <param name="factory">Factory</param> /// <returns>Roots' nodes</returns> public static INode[] CreateRoots(ICollection objects, INodeFactory factory) { //INode root = null; Hashtable hash = new Hashtable(); ArrayList nodes = new ArrayList(); ArrayList roots = new ArrayList(); foreach (object o in objects) { try { INode node = factory.CreateNode(o); nodes.Add(node); hash[node.Id] = node; } catch (Exception e) { throw e; } } foreach (INode node in nodes) { object p = node.ParentId; if (p == null) { roots.Add(node); } else if (p.Equals(node.Id)) { roots.Add(node); continue; } INode parent = hash[p] as INode; if (parent != null) { node.Parent = parent; } } INode[] r = new INode[roots.Count]; for (int i = 0; i < r.Length; i++) { r[i] = roots[i] as INode; } return(r); }
public void ActiveStateTest() { var node = _nodeFactory.CreateNode(_host, _port); var manager = _discoveryManager.GetNodeLifecycleManager(node); Assert.AreEqual(NodeLifecycleState.New, manager.State); manager.ProcessPongMessage(new PongMessage { FarAddress = new IPEndPoint(IPAddress.Parse(_host), _port), FarPublicKey = _nodeIds[0].PublicKey }); Assert.AreEqual(NodeLifecycleState.Active, manager.State); }
/// <summary> /// Words to train the auto-complete engine on. /// </summary> /// <param name="passage">text that is processed to enhance predictions.</param> /// <param name="removePunctuation">removes punctuation before processing</param> /// <param name="caseSensitive">predicts words with case sensitivity</param> public void Train(string passage, bool removePunctuation = true, bool caseSensitive = false) { if (removePunctuation) { passage = _RemovePunctuation(passage); } var words = passage.Split(null /* whitespace */) .Where(word => !string.IsNullOrWhiteSpace(word)) .Select(word => { var modified = word; modified = word.Trim(); if (!caseSensitive) { modified = modified.ToLowerInvariant(); } return(_NodeFactory.CreateNode(modified, modified)); }); _Trie.AddRange(words); }
public INodeStats GetOrAddNodeStats(NodeId nodeId, string host, int port) { var node = _nodeFactory.CreateNode(nodeId, host, port); return(GetOrAddNodeStats(node)); }
private async Task <bool> InitializeBootnodes() { var bootNodes = _configurationProvider.BootNodes; if (bootNodes == null || !bootNodes.Any()) { if (_logger.IsWarnEnabled) { _logger.Warn("No bootnodes specified in configuration"); } return(false); } var managers = new INodeLifecycleManager[bootNodes.Length]; for (var i = 0; i < bootNodes.Length; i++) { var bootnode = bootNodes[i]; var node = bootnode.NodeId == null ? _nodeFactory.CreateNode(bootnode.Host, bootnode.Port) : _nodeFactory.CreateNode(new NodeId(new PublicKey(new Hex(bootnode.NodeId))), bootnode.Host, bootnode.Port, true); var manager = _discoveryManager.GetNodeLifecycleManager(node); managers[i] = manager; } //Wait for pong message to come back from Boot nodes var maxWaitTime = _configurationProvider.BootNodePongTimeout; var itemTime = maxWaitTime / 100; for (var i = 0; i < 100; i++) { if (managers.Any(x => x.State == NodeLifecycleState.Active)) { break; } if (_logger.IsDebugEnabled) { _logger.Debug($"Waiting {itemTime} ms for bootnodes to respond"); } await Task.Delay(1000); } var reachedNodeCounter = 0; for (var i = 0; i < managers.Length; i++) { var manager = managers[i]; if (manager.State != NodeLifecycleState.Active) { if (_logger.IsWarnEnabled) { _logger.Warn($"Cannot reach bootnode: {manager.ManagedNode.Host}:{manager.ManagedNode.Port}"); } } else { reachedNodeCounter++; } } return(reachedNodeCounter > 0); }