public void Handle(PeerConnected data) { OmnibusStateEntry entry; if (byPeer.TryGetValue(data.Peer, out entry) == false) { entry = new OmnibusStateEntry(data.Peer); byPeer.Add(data.Peer, entry); } entry.State = new PeerState(); }
/// <inheritdoc/> public void OnPeerConnected(NetPeer peer) { if (masterPeer == null) { masterPeer = new LiteNetLibPeerManager(peer); } else if (!Equals(masterPeer.PeerEndPoint, peer.EndPoint)) { throw new ArgumentException("Client can be connected only to a single peer."); } PeerConnected?.Invoke(masterPeer); }
private async Task ConnectAndHandshake(Peer peer) { peer.OnDisconnect += DisconnectPeer; if (peer.IsIncoming) { Interlocked.Increment(ref this.incomingCount); } // connect await peer.ConnectAsync(); // notify peer is connected PeerConnected?.Invoke(peer); // setup task to wait for verack var verAckTask = peer.Receiver.WaitForMessage(x => x.Command == "verack", HANDSHAKE_TIMEOUT_MS); // setup task to wait for version var versionTask = peer.Receiver.WaitForMessage(x => x.Command == "version", HANDSHAKE_TIMEOUT_MS); // start listening for messages after tasks have been setup peer.Receiver.Listen(); // send our local version var nodeId = random.NextUInt64(); //TODO should be generated and verified on version message var currentHeight = this.coreDaemon.CurrentChain.Height; await peer.Sender.SendVersion(Messaging.GetExternalIPEndPoint(), peer.RemoteEndPoint, nodeId, (UInt32)currentHeight); // wait for our local version to be acknowledged by the remote peer // wait for remote peer to send their version await Task.WhenAll(verAckTask, versionTask); //TODO shouldn't have to decode again var versionMessage = versionTask.Result; var versionPayload = NetworkEncoder.DecodeVersionPayload(versionMessage.Payload.ToArray(), versionMessage.Payload.Length); var remoteAddressWithTime = new NetworkAddressWithTime ( Time: DateTimeOffset.Now, NetworkAddress: new NetworkAddress ( Services: versionPayload.LocalAddress.Services, IPv6Address: versionPayload.LocalAddress.IPv6Address, Port: versionPayload.LocalAddress.Port ) ); // acknowledge their version await peer.Sender.SendVersionAcknowledge(); }
/// <inheritdoc/> public void OnPeerConnected(NetPeer peer) { if (MasterPeer != null) { activeConnections.Remove(peer.EndPoint); return; } if (!activeConnections.TryGetValue(peer.EndPoint, out masterPeer)) { masterPeer = new LiteNetLibPeerManager(peer); activeConnections.Add(peer.EndPoint, MasterPeer); } Log.Info($"{GetType().Name} has connected to the master peer '{MasterPeer.PeerEndPoint}'."); PeerConnected?.Invoke(MasterPeer); }
protected virtual void HandleConnect(int connectionID) { if (NetLogFilter.logDebug) { Debug.LogFormat("Connection ID: {0} Connected", connectionID); } var peer = new Peer(connectionID) { IsConnected = true }; connectedPeers[peer.connectionID] = peer; PeerConnected?.Invoke(peer); }
public async void Initialize() { if (Conntype == ConnectionType.Server) { tcpListener = new TcpListener(iPAddress, Port); listenThread = new Thread(tcpListener.Start); listenThread.Start(); Connect(); } else { tcpClient = new TcpClient(); await tcpClient.ConnectAsync(iPAddress, Port); PeerConnected?.Invoke(null, null); } }
private void Connected(IPeer peer) { // Listen to messages peer.MessageReceived += OnMessageReceived; // Save the peer _connectedPeers[peer.Id] = peer; // Create the security extension var extension = peer.AddExtension(new PeerSecurityExtension()); // Set default permission level extension.PermissionLevel = 0; _logger.Info($"New Peer connected. ID: {peer.Id}"); // Invoke the event PeerConnected?.Invoke(peer); }
/// <summary> /// Handles message if it contains heartbeat. /// </summary> /// <param name="msg">The MSG.</param> private void HandleIfHeartbeat(Message msg) { var heartbeat = msg.Content as Heartbeat; if (heartbeat != null) { _peerHeartbeatDeadlines.AddOrUpdate(heartbeat.Identity, identity => { var deadline = new Deadline(TimeSpan.FromMilliseconds(HeatbeatDeadline)); foreach (var handler in PeerConnected?.GetInvocationList().ToArray() ?? new Delegate[0]) { ((Action <PeerIdentity>)handler)?.Invoke(heartbeat.Identity); } return(deadline); }, (identity, deadline) => new Deadline(TimeSpan.FromMilliseconds(HeatbeatDeadline))); } }
public void PollEvents() { while (controller.TryReceiveEvent(out NetEvent evnt)) { var peer = evnt.Peer; // No events should fire if the user closed the peer if (peer.ClosedByUser == false) { switch (evnt.EventType) { case NetEventType.PeerConnected: peer.SetCore(this); peer.OnPeerConnected(); PeerConnected?.Invoke(peer, peer.Token); break; case NetEventType.PeerClosed: peer.OnPeerClosed(evnt.CloseReason, evnt.UserKickReason, evnt.SocketError); PeerClosed?.Invoke(peer, evnt.CloseReason, evnt.UserKickReason, evnt.SocketError); break; case NetEventType.Payload: peer.OnPayloadReceived(evnt.EncodedData, evnt.EncodedLength); PeerPayload?.Invoke(peer, evnt.EncodedData, evnt.EncodedLength); break; case NetEventType.Notification: peer.OnNotificationReceived(evnt.EncodedData, evnt.EncodedLength); PeerNotification?.Invoke(peer, evnt.EncodedData, evnt.EncodedLength); break; default: throw new NotImplementedException(); } } controller.RecycleEvent(evnt); } }
/// <summary> /// Adds the specified peer to the list of connected peer. /// </summary> /// <param name="event">The event.</param> private void AddConnectedPeer(PeerConnected @event) { IPEndPoint ipEndPoint = @event.PeerContext.RemoteEndPoint.EnsureIPv6(); if (@event.PeerContext.Direction == PeerConnectionDirection.Outbound) { lock (_connectionLock) { if (attemptingConnections.Remove(ipEndPoint)) { _logger.LogDebug("EndPoint {RemoteEndPoint} Connected!. Removed from attemptingConnections list.", ipEndPoint); } else { _logger.LogDebug("EndPoint {RemoteEndPoint} Connected!. Not found in attemptingConnections list (shouldn't happen, need investigation)", ipEndPoint); } } } ConcurrentDictionary <string, IPeerContext> container = @event.PeerContext.Direction == PeerConnectionDirection.Inbound ? inboundPeers : outboundPeers; container[@event.PeerContext.PeerId] = @event.PeerContext; _logger.LogDebug("Connected to {RemoteEndPoint}, peer {PeerId} added to the list of connected peers.", ipEndPoint, @event.PeerContext.PeerId); }
internal void RaisePeerConnected(PeerConnectedEventArgs args) { PeerConnected?.InvokeAsync(this, args); }
/// <summary> /// Adds the specified peer to the list of connected peer. /// </summary> /// <param name="event">The event.</param> private void AddConnectedPeer(PeerConnected @event) { _connectedPeers[@event.PeerContext.PeerId] = new PeerScore(@event.PeerContext, INITIAL_SCORE); _logger.LogDebug("Added peer {PeerId} to the list of PeerBehaviorManager connected peers", @event.PeerContext.PeerId); }
protected void OnConnected(ConnectionEventArgs args) { PeerConnected?.Invoke(this, args); }
internal void OnPeerConnected(PeerConnectedArgs e) { Logger.Debug($"[{nameof(IpcServerService)}] PeerConnected PeerName={e.PeerName} {e.Ack}"); PeerConnected?.Invoke(this, e); }
protected void OnPeerConnected(Peer peer) { PeerConnected?.Invoke(this, (peer)); }
internal void OnPeerConnected() { PeerConnected?.Invoke(this, token); }
internal void OnPeerConnected(object?sender, IpcInternalPeerConnectedArgs e) { Logger.Debug($"[{nameof(IpcServerService)}] PeerConnected PeerName={e.PeerName} {e.Ack}"); PeerConnected?.Invoke(sender, e); }