/// <summary> /// Waits until an event is recieved by some client and it is returned with information about this client. /// </summary> /// <returns></returns> public async Task <InfoControllerEvent> RecieveEventAsync() { InfoControllerEvent result = default; while (true) { // Waits for first user. while (_events.Count == 0) { await Task.Delay(25); } int index = -1; try { index = Task.WaitAny(_events.ToArray(), _src.Token); } catch (OperationCanceledException) { _src = new CancellationTokenSource(); continue; } result = await _events[index]; if (GetClient(result.Sender).IsConnected) { _events[index] = GetClient(result.Sender).ReceiveAsync(); break; } else { lock (_playersLock) _events.RemoveAt(index); OnClientDisconnect?.Invoke(GetClient(result.Sender)); if (RemoveClientsAfterDisconnect) { await RemoveClient(result.Sender); } } } return(result); }
private void AcceptCallback(IAsyncResult ar) { CancellationToken cancellationToken = (CancellationToken)ar.AsyncState; _waiterConnection.Release(); Socket handler = _listenerSocket.EndAccept(ar); _logger.LogDebug($"Client connected - Handle: " + handler.Handle); var connection = _container.Resolve <TCPConnection>(new TypedParameter(typeof(Socket), handler)); _connections.TryAdd(handler.Handle, connection); connection.OnReceivePacket += (s, e) => OnClientData?.Invoke(this, new Message((IConnection)s, e)); connection.OnDisconnect += (s, e) => OnClientDisconnect?.Invoke(this, (IConnection)s); OnClientConnect?.Invoke(this, connection); connection.StartListenData(cancellationToken, _options.Source, true); }
/// <summary> /// An internal callback triggered when a client connects to the server. /// </summary> /// <param name="async"></param> private void OnReceiveConnection(IAsyncResult async) { try { lock (WorkerSockets) { Interlocked.Increment(ref _currentClientNumber); // Thread Safe var us = new UserSock(_currentClientNumber, _mainSocket.EndAccept(async)); WorkerSockets.Add(_currentClientNumber, us); } OnClientConnect?.Invoke(_currentClientNumber); WaitForData(_currentClientNumber); _mainSocket.BeginAccept(OnReceiveConnection, null); } catch (ObjectDisposedException) { Console.WriteLine(@"OnClientConnection: Socket has been closed"); } catch (SocketException se) { //Console.WriteLine("SERVER EXCEPTION in OnReceiveConnection: " + se.Message); Debug.WriteLine("SERVER EXCEPTION in OnReceiveConnection: " + se.Message); //pe 4-22-2015 if (WorkerSockets.ContainsKey(_currentClientNumber)) { Console.WriteLine(@"RemoteEndPoint: " + WorkerSockets[_currentClientNumber].UserSocket.RemoteEndPoint); Console.WriteLine(@"LocalEndPoint: " + WorkerSockets[_currentClientNumber].UserSocket.LocalEndPoint); Console.WriteLine(@"Closing socket from OnReceiveConnection"); } //Socket gets closed and removed from OnClientDisconnect OnClientDisconnect?.Invoke(_currentClientNumber); } }
/// <summary> /// Handle an incoming message from a remote client. /// </summary> /// <param name="msg">Incoming message.</param> private void HandleIncomingMessage(NetIncomingMessage msg) { switch (msg.MessageType) { case NetIncomingMessageType.ConnectionApproval: HandleIncomingConnection(msg); break; case NetIncomingMessageType.StatusChanged: switch (msg.SenderConnection.Status) { case NetConnectionStatus.Disconnected: if (OnClientDisconnect != null) { OnClientDisconnect.Invoke( msg.SenderConnection, null); } break; case NetConnectionStatus.Connected: if (OnClientConnect != null) { OnClientConnect.Invoke( msg.SenderConnection, null ); } break; } break; case NetIncomingMessageType.Data: if (OnClientMessageReceived != null) { OnClientMessageReceived.Invoke( msg.SenderConnection, msg ); } break; } }
public void Publish(GameEvent gameEvent) { _logger.LogDebug("Handling publishing event of type {EventType}", gameEvent.Type); try { if (gameEvent.Type == GameEvent.EventType.Connect) { OnClientConnect?.Invoke(this, gameEvent); } if (gameEvent.Type == GameEvent.EventType.Disconnect) { OnClientDisconnect?.Invoke(this, gameEvent); } } catch (Exception ex) { _logger.LogError(ex, "Could not publish event of type {EventType}", gameEvent.Type); } }
public void Disconnect() { OnClientDisconnect?.Invoke(this); isDisconnectRequested = true; }
private void SetOnClientDisconnect(Operation Client, string Reason) { OnClientDisconnect?.Invoke(Client, Reason); }
bool IServerTransportLayer.Init(int channelId, OnClientConnect connectCallback, OnReceiveMessage messageCallback, OnClientDisconnect disconnectCallback) { _connection = new MiniUDP.NetCore(ConnectionToken, true); _channelId = channelId; _clients = new Dictionary <int, MiniUDP.NetPeer>(); _nextId = 0; _connection.PeerConnected += (peer, token) => { _clients.Add(_nextId, peer); var id = new PerChannelID(channelId, _nextId++); connectCallback.Invoke(peer.EndPoint.Address, id); peer.PayloadReceived += (netPeer, data, length) => { if (data.Length != length) { Array.Resize(ref data, length); } messageCallback.Invoke(data, id); }; }; _connection.PeerClosed += (peer, reason, kickReason, error) => { var id = _clients.FirstOrDefault(i => i.Value == peer).Key; disconnectCallback.Invoke(new PerChannelID(_channelId, id)); _clients.Remove(id); }; return(true); }
/// <summary> /// An internal callback triggered when the server recieves data from a client. /// </summary> /// <param name="async"></param> private void OnDataReceived(IAsyncResult async) { var socketData = (Packet)async.AsyncState; try { var dataSize = socketData.CurrentSocket.EndReceive(async); if (dataSize.Equals(0)) { if (WorkerSockets.ContainsKey(socketData.ClientNumber)) { if (WorkerSockets[socketData.ClientNumber].ZeroDataCount++ == 10) { OnClientDisconnect?.Invoke(socketData.ClientNumber); } } } else { OnReceiveData(socketData.ClientNumber, socketData.DataBuffer, dataSize); WorkerSockets[socketData.ClientNumber].ZeroDataCount = 0; } WaitForData(socketData.ClientNumber); } catch (ObjectDisposedException) { Console.WriteLine(@"OnDataReceived: Socket has been closed"); //Socket gets closed and removed from OnClientDisconnect OnClientDisconnect?.Invoke(socketData.ClientNumber); } catch (SocketException se) { if (se.ErrorCode == 10054 || se.ErrorCode == 10060) //10054 - Error code for Connection reset by peer { try { Debug.WriteLine( $"SERVER EXCEPTION in OnClientDataReceived, ServerObject removed:({se.ErrorCode}) {socketData.ClientNumber}, (happens during a normal client exit)"); Debug.WriteLine("RemoteEndPoint: " + WorkerSockets[socketData.ClientNumber].UserSocket .RemoteEndPoint); Debug.WriteLine("LocalEndPoint: " + WorkerSockets[socketData.ClientNumber].UserSocket .LocalEndPoint); } catch { // ignored } //Socket gets closed and removed from OnClientDisconnect OnClientDisconnect?.Invoke(socketData.ClientNumber); Console.WriteLine(@"Closing socket from OnDataReceived"); } else { string mess = "CONNECTION BOOTED for reason other than 10054: code = " + se.ErrorCode.ToString() + ", " + se.Message; Console.WriteLine(mess); ToFile(mess); } } }
private void OnClientClose(Client client) { Interlocked.Decrement(ref _activeConnectionCount); OnClientDisconnect?.Invoke(client, EventArgs.Empty); }
public void DispatchEventDisconnect(GameClient client) { OnClientDisconnect?.Invoke(client); }
private void ExtendedClientLeftView(object sender, ClientLeftView eventArgs) { clientbufferOutdated = true; OnClientDisconnect?.Invoke(sender, eventArgs); }
bool IServerTransportLayer.Init(int channelId, OnClientConnect connectionCallback, Generic.Server.OnReceiveMessage messageCallback, OnClientDisconnect disconnectCallback) { _server = new Telepathy.Server(); _channelId = channelId; _serverConnectionCallback = connectionCallback; _serverMessageCallback = messageCallback; _serverDisconnectCallback = disconnectCallback; SetupLogger(); return(true); }