/// <summary> /// Constructor /// </summary> /// <param name="config">Network configuration</param> /// <param name="aclLoader">ACL loader to define access</param> /// <param name="peerFactory">Factory to create peers from endpoints</param> /// <param name="peerListener">Listener to accept peer connections</param> /// <param name="peerMessageListener">PeerMessageListener</param> /// <param name="serverContext">Server context</param> /// <param name="serverProcesses">Server processes</param> /// <param name="logger">Logger</param> public Server( NetworkConfig config, INetworkAclLoader aclLoader, IPeerFactory peerFactory, IPeerListener peerListener, IPeerMessageListener peerMessageListener, IServerContext serverContext, IEnumerable <IServerProcess> serverProcesses, ILogger <Server> logger) { if (config == null) { throw new ArgumentNullException(nameof(config)); } _peerFactory = peerFactory ?? throw new ArgumentNullException(nameof(peerFactory)); _peerListener = peerListener ?? throw new ArgumentNullException(nameof(peerListener)); if (aclLoader == null) { throw new ArgumentNullException(nameof(aclLoader)); } _acl = aclLoader.Load(config.AclConfig) ?? NetworkAcl.Default; _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _peerMessageListener = peerMessageListener ?? throw new ArgumentNullException(nameof(peerMessageListener)); _serverContext = serverContext ?? throw new ArgumentNullException(nameof(serverContext)); _serverProcesses = serverProcesses ?? throw new ArgumentNullException(nameof(serverProcesses)); _peerListener.OnPeerConnected += PeerConnected; // TODO #364: Change after port forwarding implementation _peerEndPoints = config.PeerEndPoints; }
public Server( NetworkConfig config, IPeerFactory peerFactory, IPeerListener peerListener, IMessageHandler <Message> messageHandler, ILogger <Server> logger) { _config = config ?? throw new ArgumentNullException(nameof(config)); _peerFactory = peerFactory ?? throw new ArgumentNullException(nameof(peerFactory)); _peerListener = peerListener ?? throw new ArgumentNullException(nameof(peerListener)); _messageHandler = messageHandler; _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _peerListener.OnPeerConnected += PeerConnected; _connectedPeers = new ConcurrentBag <IPeer>(); _failedPeers = new List <IPEndPoint>(); // TODO: Change after port forwarding implementation _port = _config.Port; Version = 2; var r = new Random(Environment.TickCount); Nonce = (uint)r.Next(); _userAgent = $"/NEO:{Assembly.GetExecutingAssembly().GetName().Version.ToString(3)}/"; }
/// <summary> /// Constructor /// </summary> /// <param name="config">Network configuration</param> /// <param name="aclLoader">ACL loader to define access</param> /// <param name="peerFactory">Factory to create peers from endpoints</param> /// <param name="peerListener">Listener to accept peer connections</param> /// <param name="peerMessageListener">PeerMessageListener</param> /// <param name="logger">Logger</param> public Server( NetworkConfig config, INetworkAclLoader aclLoader, IPeerFactory peerFactory, IPeerListener peerListener, IPeerMessageListener peerMessageListener, ILogger <Server> logger) { if (config == null) { throw new ArgumentNullException(nameof(config)); } _peerFactory = peerFactory ?? throw new ArgumentNullException(nameof(peerFactory)); _peerListener = peerListener ?? throw new ArgumentNullException(nameof(peerListener)); if (aclLoader == null) { throw new ArgumentNullException(nameof(aclLoader)); } _acl = aclLoader.Load(config.AclConfig) ?? NetworkAcl.Default; _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _peerMessageListener = peerMessageListener ?? throw new ArgumentNullException(nameof(peerMessageListener)); _peerListener.OnPeerConnected += PeerConnected; _connectedPeers = new ConcurrentBag <IPeer>(); _failedPeers = new List <IPEndPoint>(); // TODO: Change after port forwarding implementation _peerEndPoints = config.PeerEndPoints; }
public PeerBase(IPeerListener peerListener, bool batch) { m_batch = batch; m_peerListener = peerListener; m_peerSession = null; m_sendBufferQueue = new Queue <StreamBuffer>(); m_sendBufferLenght = 0; }
/// <summary>Create a local peer and start connecting to an active remote host.</summary> /// <param name="remote">Remote address to connect to.</param> /// <param name="config">Peer configuration values. If null, default is used.</param> /// <param name="listener">Peer listener to use. If null, <see cref="PeerEvents"/> is used.</param> /// <param name="message">Connect message to use.</param> /// <returns>Local peer that attempts to connect.</returns> public Peer Connect(IPEndPoint remote, PeerConfig config, IPeerListener listener, IWritable message = null) { // Validate if (Disposed) { throw new ObjectDisposedException(GetType().FullName); } else if (remote == null) { throw new ArgumentNullException(nameof(remote), "Remote connect address is null"); } // Map address if (remote.AddressFamily != Socket.AddressFamily) { if (remote.AddressFamily == AddressFamily.InterNetwork) { remote = new IPEndPoint(remote.Address.MapToIPv6(), remote.Port); } else if (remote.Address.IsIPv4MappedToIPv6) { remote = new IPEndPoint(remote.Address.MapToIPv4(), remote.Port); } else { throw new ArgumentException(string.Format("Bad peer address {0}", remote), nameof(remote)); } } // Create peer Peer peer = null; try { PeersLock.EnterWriteLock(); Peers.TryGetValue(remote, out peer); if (peer == null || peer.Disposed) { peer = new Peer(this, remote, config, listener); Peers[remote] = peer; } else { // Peer already exists } } finally { PeersLock.ExitWriteLock(); } // Start connecting peer.Connect(message); // Return peer return(peer); }
public TPeer(IPeerListener peerListener, bool batch = false) : base(peerListener, batch) { this.m_sendPingTime = System.DateTime.Now; this.m_recPingTime = System.DateTime.Now; this.m_sendPingTimeout = 0.0f; this.m_recPingTimeout = 0.0f; this.m_bHeartBeat = false; this.m_connected = false; this.m_csHeartBeat = 0x50a0005; this.m_scHeartBeat = 0x70a0005; }
public PeerBase(IPeerListener listener, string address, int port) { lastPingResult = Environment.TickCount; EnqueueLock = new object(); this.listener = listener; outgoingStream = new List <byte[]>(); incomingList = new Queue <byte[]>(); ActionQueue = new Queue <Action>(); this.ServerAddress = address; this.ServerPort = port; this.sock = new SocketTcp(this); }
public ClientEngine(EngineSettings settings, IPeerListener listener, IPieceWriter writer) { Check.Settings(settings); Check.Listener(listener); Check.Writer(writer); // This is just a sanity check to make sure the ReusableTasks.dll assembly is // loadable. GC.KeepAlive(ReusableTasks.ReusableTask.CompletedTask); PeerId = GeneratePeerId(); Listener = listener ?? throw new ArgumentNullException(nameof(listener)); Settings = settings ?? throw new ArgumentNullException(nameof(settings)); allTorrents = new List <TorrentManager> (); publicTorrents = new List <TorrentManager> (); Torrents = new ReadOnlyCollection <TorrentManager> (publicTorrents); DiskManager = new DiskManager(Settings, writer); ConnectionManager = new ConnectionManager(PeerId, Settings, DiskManager); DhtEngine = new NullDhtEngine(); listenManager = new ListenManager(this); PortForwarder = new MonoNatPortForwarder(); MainLoop.QueueTimeout(TimeSpan.FromMilliseconds(TickLength), delegate { if (IsRunning && !Disposed) { LogicTick(); } return(!Disposed); }); downloadLimiter = new RateLimiter(); downloadLimiters = new RateLimiterGroup { new DiskWriterLimiter(DiskManager), downloadLimiter, }; uploadLimiter = new RateLimiter(); uploadLimiters = new RateLimiterGroup { uploadLimiter }; listenManager.Register(listener); if (SupportsLocalPeerDiscovery) { RegisterLocalPeerDiscovery(new LocalPeerDiscovery(Settings)); } }
public Server( IBlockchain blockchain, NetworkConfig config, IPeerFactory peerFactory, IPeerListener peerListener, IMessageHandler <Message> messageHandler, ILogger <Server> logger, NetworkACLFactory aclFactory) { if (config == null) { throw new ArgumentNullException(nameof(config)); } this._blockchain = blockchain ?? throw new ArgumentNullException(nameof(blockchain)); this._peerFactory = peerFactory ?? throw new ArgumentNullException(nameof(peerFactory)); this._peerListener = peerListener ?? throw new ArgumentNullException(nameof(peerListener)); this._logger = logger ?? throw new ArgumentNullException(nameof(logger)); if (aclFactory == null) { throw new ArgumentNullException(nameof(aclFactory)); } this._messageHandler = messageHandler; this._acl = aclFactory.CreateNew(); this._acl?.Load(config?.ACL); this._peerListener.OnPeerConnected += PeerConnected; this._connectedPeers = new ConcurrentBag <IPeer>(); this._failedPeers = new List <IPEndPoint>(); // TODO: Change after port forwarding implementation this._port = config.Port; ProtocolVersion = 2; var r = new Random(Environment.TickCount); Nonce = (uint)r.Next(); this._peerEndPoints = config.PeerEndPoints; this._userAgent = $"/NEO:{Assembly.GetExecutingAssembly().GetName().Version.ToString(3)}/"; }
public ClientEngine(EngineSettings settings, IPeerListener listener, IPieceWriter writer) { Check.Settings(settings); Check.Listener(listener); Check.Writer(writer); PeerId = GeneratePeerId(); Listener = listener ?? throw new ArgumentNullException(nameof(listener)); Settings = settings ?? throw new ArgumentNullException(nameof(settings)); torrents = new List <TorrentManager>(); Torrents = new ReadOnlyCollection <TorrentManager> (torrents); DiskManager = new DiskManager(Settings, writer); ConnectionManager = new ConnectionManager(PeerId, Settings, DiskManager); DhtEngine = new NullDhtEngine(); listenManager = new ListenManager(this); MainLoop.QueueTimeout(TimeSpan.FromMilliseconds(TickLength), delegate { if (IsRunning && !Disposed) { LogicTick(); } return(!Disposed); }); downloadLimiter = new RateLimiter(); downloadLimiters = new RateLimiterGroup { new DiskWriterLimiter(DiskManager), downloadLimiter, }; uploadLimiter = new RateLimiter(); uploadLimiters = new RateLimiterGroup { uploadLimiter }; listenManager.Register(listener); if (SupportsLocalPeerDiscovery) { RegisterLocalPeerDiscovery(new LocalPeerDiscovery(Settings)); } }
public ClientEngine(EngineSettings settings, IPeerListener listener, PieceWriter writer) { Check.Settings(settings); Check.Listener(listener); Check.Writer(writer); this.Listener = listener; this.Settings = settings; this.ConnectionManager = new ConnectionManager(this); DhtEngine = new NullDhtEngine(); this.DiskManager = new DiskManager(this, writer); this.listenManager = new ListenManager(this); MainLoop.QueueTimeout(TimeSpan.FromMilliseconds(TickLength), delegate { if (IsRunning && !Disposed) { LogicTick(); } return(!Disposed); }); this.torrents = new List <TorrentManager>(); this.torrentsReadonly = new ReadOnlyCollection <TorrentManager> (torrents); downloadLimiter = new RateLimiterGroup { new DiskWriterLimiter(DiskManager), new RateLimiter() }; uploadLimiter = new RateLimiter(); this.PeerId = GeneratePeerId(); localPeerListener = new LocalPeerListener(); localPeerListener.PeerFound += HandleLocalPeerFound; localPeerManager = new LocalPeerManager(); LocalPeerSearchEnabled = SupportsLocalPeerDiscovery; listenManager.Register(listener); }
public void Unregister(IPeerListener listener) { listener.ConnectionReceived -= ConnectionReceived; Listeners.Remove(listener); }
public void Register(IPeerListener listener) { Listeners.Add(listener); listener.ConnectionReceived += ConnectionReceived; }
public void SetPeerListener(IPeerListener listener) { m_listener = listener != null ? listener : s_nullPeerListener; }
public ReliableOrderServerPeer(IGameSession iSession, IPeerListener peerListener) : base(iSession, peerListener) { }
/// <summary>Accept the request, create a new peer and establish a connection.</summary> /// <param name="config">Peer configuration values. If null, default is used.</param> /// <param name="listener">Peer listener. If null, event based listener is created.</param> /// <returns>The created peer.</returns> public Peer Accept(PeerConfig config, IPeerListener listener) { return(Host.Accept(this, config, listener)); }
/// <summary>Accept a connection request and return a connected local peer.</summary> /// <param name="request">Connection request to accept.</param> /// <param name="config">Peer configuration values. If null, default is used.</param> /// <param name="listener">Peer listener to use. If null, event based listener is created.</param> /// <returns>Connected local peer.</returns> public Peer Accept(ConnectionRequest request, PeerConfig config, IPeerListener listener) { // Validate request if (Disposed) { throw new ObjectDisposedException(GetType().FullName); } else if (request == null) { throw new ArgumentNullException(nameof(request), "Connection request is null"); } else if (request.Host != this) { throw new ArgumentException("Connection request host mismatch", nameof(request)); } else if (request.Disposed) { throw new InvalidOperationException(string.Format( "Connection request from {0} is disposed", request.Remote )); } else if (config.RemotePublicKey != null) { throw new ArgumentException(string.Format( "Connection request from {0} cannot be authenticated", request.Remote ), nameof(config)); } else if (request.Key.Count > 0 && request.Key.Count != ExchangerKeyLength) { throw new InvalidOperationException(string.Format( "Connection request from {0} has {1} exchanger bytes", request.Remote, request.Key.Count )); } else if (request.Random.Count > 0 && request.Random.Count != Authenticator.SignatureLength) { throw new InvalidOperationException(string.Format( "Connection request from {0} has {1} random bytes", request.Remote, request.Random.Count )); } else if (request.Random.Count > 0 && Config.PrivateKey == null) { throw new InvalidOperationException(string.Format( "Connection request from {0} has authentication", request.Remote )); } // Create peer Peer peer = null; try { PeersLock.EnterWriteLock(); Peers.TryGetValue(request.Remote, out peer); if (peer == null || peer.Disposed) { peer = new Peer(this, request.Remote, config, listener); Peers[request.Remote] = peer; } else { // Peer already exists } } finally { PeersLock.ExitWriteLock(); } // Accept the request peer.Accept(request); // Return peer return(peer); }
protected void SetPeerListener(IPeerListener peerListener) { m_peerListener = peerListener; }
public ReliableOrderPeer(IPeerListener peerListener, bool batch = false) : base(peerListener, batch) { InitPeer(null); }
public void Setup() { listener = new PeerListener(endpoint); listener.Start(); }
protected ReliableOrderPeer(IGameSession iSession, IPeerListener peerListener, bool batch = false) : base(peerListener, batch) { InitPeer(iSession); }
public ClientEngine(EngineSettings settings, IPeerListener listener) : this(settings, listener, new DiskWriter()) { }
public void StartServerPeer(IPeerListener peerListener) { SetPeerListener(peerListener); ((ServerSession)m_peerSession).SessionReceive(this); }
public void SetListener(IPeerListener listener) { Listener.ConnectionReceived -= ConnectionReceived; Listener = listener ?? new NullPeerListener(); Listener.ConnectionReceived += ConnectionReceived; }
public ClientPeer(IPeerListener listener, ConnectionProtocol protocolType = ConnectionProtocol.Tcp) { PeerListener = listener; UsedProtocol = protocolType; }