public override void HandlePacket(Packet packet)
{
_client = packet.Client;
_authClient = packet.AuthClient;
_packet = packet;
_builder = new MessageBuilder(_authClient, _client, _packet.EndPoint, _packet.SyncKey);
switch (_packet.PacketType)
{
case PacketManager.PacketTypes.AddOrUpdateJob:
AddOrUpdateJob();
break;
case PacketManager.PacketTypes.RemoveJob:
RemoveJob();
break;
case PacketManager.PacketTypes.StopJobDaemon:
StopJobDaemon();
break;
case PacketManager.PacketTypes.StartJobDaemon:
StartJobDaemon();
break;
case PacketManager.PacketTypes.GetJobDaemonStatus:
GetJobDaemonStatus();
break;
case PacketManager.PacketTypes.GetJobContents:
GetJobContents();
break;
case PacketManager.PacketTypes.GetAllJobs:
GetAllJobs();
break;
}
}
public MessageBuilder(AuthClient authClient, WebSocket client, string endpoint, string syncKey)
{
_authClient = authClient;
_client = client;
Endpoint = endpoint;
synckey = syncKey;
}
public void AcceptMessage(WebSocket ws, Dictionary<string, dynamic> msgDict)
{
string msg = JsonConvert.SerializeObject(msgDict, Formatting.None);
this.messagelog += msg + "\n";
// Check if message is for server.
if (msgDict["msgType"] == "CreatureDied")
{
// Not doing anything with this yet.
}
else if (msgDict["msgType"] == "LifeReduced")
{
// Find the match and report that the ws said something about a reduced life.
this.LifeReduced(ws);
}
else if (msgDict["msgType"] == "RequestEntity")
{
// Find related match, relay message.
this.SendToOpponent(ws, msg);
int type = (int)msgDict["type"];
int x = (int)msgDict["location"]["x"];
int y = (int)msgDict["location"]["y"];
int parentId = (int)msgDict["parent_id"];
this.EntityRequested(ws, type, x, y, parentId);
}
else
{
// Find related match, relay message.
this.SendToOpponent(ws, msg);
}
}
public GameServerConnection(vtortola.WebSockets.WebSocket socket)
{
Socket = socket;
isReady = true;
SetupLoginHandler();
}
public WebSocketHandler(IServiceBus bus, WebSocket ws, IEventSerializator serializer, ILogger log)
{
_ws = ws;
_queue = bus;
_log = log;
_serializer = serializer;
}
public ClientConnection(vtortola.WebSockets.WebSocket socket)
{
Socket = socket;
isReady = true;
SetupLoginHandler();
}
/// <inheritdoc />
public async Task ConnectAsync(ISession session, CancellationToken ct = default(CancellationToken),
bool appearOnline = false, int connectTimeout = 5000)
{
if (_listener != null)
{
await _listener.CloseAsync();
_messageReplies.Clear();
_listener.Dispose();
_listener = null;
}
var addr = new UriBuilder(_baseUri)
{
Path = "/ws",
Query = string.Concat("lang=en&status=", appearOnline, "&token=", session.AuthToken)
};
var timeoutTask = Task.Delay(TimeSpan.FromMilliseconds(connectTimeout), ct);
var connectTask = _client.ConnectAsync(addr.Uri, ct);
// Limit time (msec) allowed for connect attempts.
if (await Task.WhenAny(connectTask, timeoutTask).ConfigureAwait(false) == timeoutTask)
{
throw new TimeoutException($"Socket connect timed out after '{connectTimeout}' milliseconds.");
}
_listener = await connectTask.ConfigureAwait(false);
ReadSocketAsync(ct);
WriteSocketAsync(ct);
}
public string Login(string password, WebSocket clientSocket)
{
var code = 3;
if (string.IsNullOrEmpty(password))
{
code = INVALID_PASSWORD;
}
using (var context = new PrincipalContext(ContextType.Machine))
{
code = context.ValidateCredentials(GetUsername(), password) ? 2 : 3;
}
var authenticated = code == AUTHENTICATED;
foreach (var client in TaskManagerServer.AllClients.Where(client => client.Value.Client == clientSocket))
{
if (code == INVALID_PASSWORD)
{
client.Value.Authenticated = false;
}
else if (code == AUTHENTICATED)
{
client.Value.Authenticated = true;
}
}
var authenticationData = new JavaScriptSerializer().Serialize(new
{
endpoint = "authentication",
results = new
{
authenticated,
message = authenticated ? "Login was successfull" : "Login was unsuccessful"
}
});
return authenticationData;
}
private async Task HandleWebSocketAsync(WebSocket websocket)
{
try
{
if (OnConnect != null)
OnConnect.Invoke(websocket);
while (websocket.IsConnected)
{
var message = await websocket.ReadStringAsync(CancellationToken.None)
.ConfigureAwait(false);
if (message != null && OnMessage != null)
OnMessage.Invoke(websocket, message);
}
if (OnDisconnect != null)
OnDisconnect.Invoke(websocket);
}
catch (Exception ex)
{
if (OnError != null)
OnError.Invoke(websocket, ex);
}
finally
{
websocket.Dispose();
}
}
private async void ListenForMessages(WebSocket socket)
{
TOP:
try
{
if (!socket.IsConnected)
return;
var message = await socket.ReadMessageAsync(_tokenSource.Token);
if (message != null)
{
using (var ms = new MemoryStream()) // length was throwing an exception
{
message.CopyTo(ms);
var segment = new ArraySegment<byte>(ms.GetBuffer(), 0, (int)ms.Length);
var args = new DataReceivedArgs { Data = segment, SessionID = socket };
Received.Invoke(this, args);
}
}
goto TOP;
}
catch (TaskCanceledException) { }
catch (Exception)
{
goto TOP;
}
}
public WebSocketHandler(IServiceBus bus, WebSocket ws, IEventSerializator serializer, ILogger log)
{
_ws = ws;
_queue = bus;
_log = log;
_serializer = serializer;
TerminalClients = new ConcurrentDictionary<string, AuthClient>();
}
private void Disconnect()
{
_websocket?.Dispose();
_websocket = null;
_websocketHandle?.Dispose();
_websocketHandle = null;
}
static Guid GetSessionId(WebSocket ws)
{
Guid sessionId = Guid.Empty;
Cookie cookie = ws.HttpRequest.Cookies[ConnectionManager.UserSessionCookieName] ?? ws.HttpResponse.Cookies[ConnectionManager.UserSessionCookieName];
if (cookie != null && Guid.TryParse(cookie.Value, out sessionId))
return sessionId;
else
throw new Exception("No session ID generated for this connection");
}
public Player(WebSocket ws, String username, String uniqueId)
{
// TODO: Actually write code that'll connect to a DB to see if we can pull rating information.
this.ws = ws;
this.username = username;
this.uniqueId = uniqueId;
this.rating = 0;
this.currentMatch = null;
}
public static Guid GetConnectionId(WebSocket clientSocket)
{
Guid connectionId;
var cookie = clientSocket.HttpRequest.Cookies["ConnectionId"] ??
clientSocket.HttpResponse.Cookies["ConnectionId"];
if (cookie == null || !Guid.TryParse(cookie.Value, out connectionId))
return Guid.Empty;
return connectionId;
}
private bool CanAcceptConnection(WebSocket con)
{
if (String.IsNullOrEmpty(_ipAddressStart))
return true;
if (IPAddress.IsLoopback(con.RemoteEndpoint.Address))
return true;
return con.RemoteEndpoint.Address.ToString().StartsWith(_ipAddressStart);
}
private static void HandleMessage(WebSocket websocket, string message)
{
foreach (var apiController in
ApiControllers.Select(controller => controller.Value)
.Where(apiController => apiController.Client == websocket))
{
var packet = new Packets(message);
apiController.HandlePacket(packet);
}
}
internal ServerWebSocketTransport(vtortola.WebSockets.WebSocket webSocket, IEnvelopeSerializer envelopeSerializer, ITraceWriter traceWriter = null)
{
if (webSocket == null)
{
throw new ArgumentNullException(nameof(webSocket));
}
_webSocket = webSocket;
_envelopeSerializer = envelopeSerializer;
_traceWriter = traceWriter;
_receiveSemaphore = new SemaphoreSlim(1);
_sendSemaphore = new SemaphoreSlim(1);
}
/// <summary>
/// Create a packet
/// </summary>
/// <param name="authClient"></param>
/// <param name="client"></param>
/// <param name="endPoint"></param>
/// <param name="syncKey"></param>
/// <param name="args"></param>
/// <param name="packetType"></param>
/// <param name="packetHandler"></param>
public Packet(AuthClient authClient, WebSocket client, string endPoint, string syncKey, List<object> args,
PacketTypes packetType,
Type packetHandler)
{
AuthClient = authClient;
Client = client;
EndPoint = endPoint;
SyncKey = syncKey;
Args = args;
PacketType = packetType;
_packetHandler = packetHandler;
}
public override void HandlePacket(Packet packet)
{
_client = packet.Client;
_authClient = packet.AuthClient;
_packet = packet;
_builder = new MessageBuilder(_authClient, _client, _packet.EndPoint, _packet.SyncKey);
switch (_packet.PacketType)
{
case PacketManager.PacketTypes.RequestCpuInformation:
GetCpuInformation();
break;
}
}
private static void HandleDisconnect(WebSocket clientSocket)
{
foreach (var client in AllClients)
{
if (client.Value.Client != clientSocket) continue;
AuthClient temp = null;
ApiController temp2 = null;
AllClients.TryRemove(client.Key, out temp);
ApiControllers.TryRemove(client.Key, out temp2);
Console.WriteLine("Disconnection from " + clientSocket.RemoteEndpoint);
Console.WriteLine(ApiControllers.Count);
}
}
internal void Open(IDisposable websocketHandle, WebSocket websocket, CancellationToken cancellationToken)
{
if (websocketHandle == null)
throw new ArgumentNullException(nameof(websocketHandle));
if (websocket == null)
throw new ArgumentNullException(nameof(websocket));
_websocketHandle = websocketHandle;
_websocket = websocket;
ReadWebSocketAsync(cancellationToken);
WriteWebSocketAsync(cancellationToken);
}
private static void HandleConnect(WebSocket clientSocket)
{
Console.WriteLine("Connection from " + clientSocket.RemoteEndpoint);
var client = new AuthClient(clientSocket);
var apiController = new ApiController(clientSocket)
{
//set the auth Client so we can use it later
authClient = client
};
AllClients.AddOrUpdate(client.GetHashCode().ToString(), client, (key, value) => value);
ApiControllers.AddOrUpdate(apiController.authClient.GetHashCode().ToString(), apiController,
(key, value) => value);
SendWelcomeMessage(clientSocket);
}
public override void HandlePacket(Packet packet)
{
_client = packet.Client;
_authClient = packet.AuthClient;
_packet = packet;
_builder = new MessageBuilder(_authClient, _client, _packet.EndPoint, _packet.SyncKey);
switch (_packet.PacketType)
{
case PacketManager.PacketTypes.InvalidOrEmptyPacket:
InvalidPacket();
break;
case PacketManager.PacketTypes.NoAuth:
NoAuth();
break;
}
}
public override void HandlePacket(Packet packet)
{
_client = packet.Client;
_authClient = packet.AuthClient;
_packet = packet;
_builder = new MessageBuilder(_authClient, _client, _packet.EndPoint, _packet.SyncKey);
switch (_packet.PacketType)
{
case PacketManager.PacketTypes.SaveSettings:
SaveSettings();
break;
case PacketManager.PacketTypes.GetCurrentSettings:
GetCurrentSettings();
break;
}
}
private static async Task EchoAllIncomingMessagesAsync(WebSocket webSocket, CancellationToken cancellation)
{
Console.WriteLine("Client '" + webSocket.RemoteEndpoint + "' connected.");
var sw = new Stopwatch();
try
{
while (webSocket.IsConnected && !cancellation.IsCancellationRequested)
{
try
{
var messageText = await webSocket.ReadStringAsync(cancellation).ConfigureAwait(false);
if (messageText == null)
{
break; // webSocket is disconnected
}
Console.WriteLine("Client '" + webSocket.RemoteEndpoint + "' recived: " + messageText + ".");
sw.Restart();
messageText = WebSocketHandler(messageText);
await webSocket.WriteStringAsync(messageText, cancellation).ConfigureAwait(false);
Console.WriteLine("Client '" + webSocket.RemoteEndpoint + "' sent: " + messageText + ".");
sw.Stop();
}
catch (TaskCanceledException)
{
break;
}
catch (Exception readWriteError)
{
Console.WriteLine("An error occurred while reading/writing echo message.", readWriteError);
await webSocket.CloseAsync().ConfigureAwait(false);
}
}
}
finally
{
webSocket.Dispose();
Console.WriteLine("Client '" + webSocket.RemoteEndpoint + "' disconnected.");
}
}
public async void PushBinary(WebSocket client, string endpoint, string syncKey, byte[] data)
{
try
{
using (var messageWriter = client.CreateMessageWriter(WebSocketMessageType.Binary))
{
using (var stream = new MemoryStream(data))
{
await stream.CopyToAsync(messageWriter);
}
}
}
catch (Exception)
{
//should never happen
}
}
public override void HandlePacket(Packet packet)
{
_client = packet.Client;
_authClient = packet.AuthClient;
_packet = packet;
_builder = new MessageBuilder(_authClient, _client, _packet.EndPoint, _packet.SyncKey);
switch (_packet.PacketType)
{
case PacketManager.PacketTypes.RequestOsInformation:
GetOperatingSystemInformation();
break;
case PacketManager.PacketTypes.GetEventLogs:
// GetEventLogs();
break;
}
}
public async void EntityRequested(WebSocket ws, int EntityType, int x, int y, int parentId)
{
this.entityCounter++;
int delay = 0;
if (ws == this.attacker.getSocket())
{
delay = Match.AttackerDelay;
}
else
{
delay = Match.DefenderDelay;
}
await Task.Delay(delay);
MsgObjects.NewEntity temp = new MsgObjects.NewEntity(EntityType, this.entityCounter, x, y, parentId);
this.SendMessage(null, temp.ToJSON());
}
private async Task <bool> InternalAssertConnected(CancellationToken cancellationToken)
{
if (this.client != null &&
this.wsClient != null &&
this.wsClient.IsConnected &&
!this.receiveMessagesCts.IsCancellationRequested)
{
Logger.Trace("Already connected");
return(false);
}
var retryCount = 0;
do
{
try
{
this.receiveMessagesCts.Cancel();
await this.messageLoopTask;
Logger.Trace("Message loop task finished");
this.receiveMessagesCts = new CancellationTokenSource();
this.client = new WebSocketClient(this.options);
this.wsClient = await this.client.ConnectAsync(this.Endpoint, cancellationToken);
this.messageLoopTask = Task.Run(() => ReceiveMessagesLoop(this.receiveMessagesCts.Token), cancellationToken);
Logger.Log("Connected to server");
return(true);
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
Logger.Warn($"Connection failed, retry {++retryCount}/10");
Logger.Debug($"{ex}");
await Task.Delay(2000, cancellationToken);
}
} while (retryCount < 10);
throw new WebsocketConnectionFailedException();
}
private Boolean TryAddWebSocketToPool(WebSocket con)
{
try
{
_semaphore.EnterWriteLock();
if (_connections.Count >= _maxConnectedClients)
return false;
var ws = new WebSocketWrapper(con);
_connections.Add(ws);
Task.Run(() => AcceptWebSocketCommands(ws));
return true;
}
finally
{
_semaphore.ExitWriteLock();
}
}
public void Serialize(WebSocket client, string endpoint, string syncKey, object data, bool binary = false)
{
var serializer = new JavaScriptSerializer {MaxJsonLength = int.MaxValue};
var json = serializer.Serialize(new
{
endpoint,
syncKey,
results = data
});
if (binary)
{
PushFile(client, "");
}
else
{
Push(client, json);
}
}
private async void ReadSocketAsync(CancellationToken ct)
{
try
{
OnConnect?.Invoke(this, EventArgs.Empty);
while (!ct.IsCancellationRequested && _listener.IsConnected)
{
var readStream = await _listener.ReadMessageAsync(ct).ConfigureAwait(false);
if (readStream == null)
{
continue; // NOTE does stream need to be consumed?
}
using (var reader = new StreamReader(readStream, true))
{
var message = await reader.ReadToEndAsync().ConfigureAwait(false);
if (Trace)
{
Logger.DebugFormat("Socket read message: '{0}'", message);
}
var envelope = message.FromJson <WebSocketMessageEnvelope>();
ProcessMessageAsync(envelope, message);
}
}
OnDisconnect?.Invoke(this, EventArgs.Empty);
}
catch (OperationCanceledException e)
{
if (Trace)
{
Logger.DebugFormat("Socket operation cancelled: '{0}'", e.Message);
}
_listener.Dispose();
_listener = null;
}
}
public override void HandlePacket(Packet packet)
{
_client = packet.Client;
_authClient = packet.AuthClient;
_packet = packet;
_builder = new MessageBuilder(_authClient, _client, _packet.EndPoint, _packet.SyncKey);
switch (_packet.PacketType)
{
case PacketManager.PacketTypes.ChangeDisplayResolution:
ChangeScreenResolution();
break;
case PacketManager.PacketTypes.RotateDisplay:
RotateDisplay();
break;
case PacketManager.PacketTypes.SetPrimaryDisplay:
SetPrimaryDisplay();
break;
case PacketManager.PacketTypes.GetEventLogs:
// GetEventLogs();
break;
}
}
static async Task HandleConnectionAsync(WebSocket ws, CancellationToken cancellation)
{
try
{
while (ws.IsConnected && !cancellation.IsCancellationRequested)
{
String msg = await ws.ReadStringAsync(cancellation).ConfigureAwait(false);
Log("Message: " + msg);
ws.WriteString(msg);
}
}
catch (Exception aex)
{
Log("Error Handling connection: " + aex.GetBaseException().Message);
try { ws.Close(); }
catch { }
}
finally
{
ws.Dispose();
}
}
private static void DisconnectWebSocket(WebSocket con)
{
Task.Run(() => con.Dispose());
}
public async void PushFile(WebSocket client, string filePath)
{
using (var messageWriter = client.CreateMessageWriter(WebSocketMessageType.Binary))
using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
await fs.CopyToAsync(messageWriter);
}
}
