/// <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);
}
