public virtual async ValueTask BindAsync(EndPoint endpoint, CancellationToken cancellationToken = default) { if (endpoint is IPEndPoint ipEndpoint) { _ipEndpoint = ipEndpoint; } else { throw new NotSupportedException("Only IPEndPoint are currently supported by inline sockets."); } _logger.BindListenSocket(_ipEndpoint); _listener = _networkProvider.CreateListener(new NetworkListenerSettings { IPEndPoint = _ipEndpoint, AllowNatTraversal = _options.AllowNatTraversal, ExclusiveAddressUse = _options.ExclusiveAddressUse, ListenerBacklog = _options.ListenBacklog, NoDelay = _options.NoDelay, }); // the only way to cancel a call to accept a socket is to stop the listener. // this is okay, because this call is cancelled only when the listener is about to be // unbound and disposed anyway. _listenerCancellationCallback = _listener.Stop; _listener.Start(); }
public void Start() { listener.Start(); logger.Info("ChannelListener accepting connections on port " + Port); running = true; listenerThread = new Thread(Run) { IsBackground = false, Name = "ChannelListener", Priority = ThreadPriority.AboveNormal }; listenerThread.Start(); }
/// <summary> /// Start the network service /// </summary> public void Start() { if (Interlocked.CompareExchange(ref _state, (int)ServiceState.RunPending, (int)ServiceState.Stopped) == (int)ServiceState.Stopped) { try { _listener.Start(); _state = (int)ServiceState.Running; } catch (Exception ex) { _state = (int)ServiceState.Stopped; throw new NetServiceException(CANAPE.Net.Properties.Resources.NetworkServiceBase_CouldNotStartService, ex); } } }
public virtual async ValueTask BindAsync(EndPoint endpoint, CancellationToken cancellationToken = default) { _endpoint = endpoint; _logger.BindListenSocket(_endpoint); _listener = _networkProvider.CreateListener(new NetworkListenerSettings { EndPoint = _endpoint, AllowNatTraversal = _options.AllowNatTraversal, ExclusiveAddressUse = _options.ExclusiveAddressUse, ListenerBacklog = _options.ListenBacklog, NoDelay = _options.NoDelay, }); // the only way to cancel a call to accept a socket is to stop the listener. // this is okay, because this call is cancelled only when the listener is about to be // unbound and disposed anyway. _listenerCancellationCallback = _listener.Stop; _listener.Start(); }
private void ServerMain() { listener.Start(); while (!IsStopped) { try { INetworkTransport client = listener.AcceptClient(); if (client != null) { ClientConnection channel = ClientConnection.CreateClientConnection( new ProtoBuffEnvelope(registry), client); channel.ClientId = Guid.NewGuid(); Logger.Info("New connection from : " + client.RemoteEndPoint); lock (clientSync) { _connectionList.Add(channel.ClientId, channel); } OnClientConnected(channel.ClientId, channel, client.RemoteEndPoint.ToString()); channel.ClientClosed += OnClientDisconnected; channel.MessageReceived += OnMessageReceived; } } catch (SocketException) { // This is here because AcceptTcpClient throws an exception when we tell it // stop listening. Logger.Debug("SocketServer shutdown. No longer accepting connections"); } } }
/// <summary> /// Start the listener /// </summary> public void Start() { _left.Start(); _right.Start(); }