/// <summary>
/// Called to notify of a new connection
/// </summary>
/// <param name="socket"></param>
public void Connected(WebSocket socket)
{
socket.ConnectionClosed += OnConnectionClosed;
RpcConnection connection = new RpcConnection(socket);
lock (this)
{
m_connections.Add(socket, connection);
}
}
/// <summary>
/// Constructor with a socket
/// </summary>
/// <param name="socket"></param>
public RpcConnection(WebSocket socket)
{
m_socket = socket;
m_authenticated = false;
// Get references to the core components we need
m_builder = new MessageBuilder();
m_messagebus = Locator.Current.GetService<IMessageBus>();
m_mot = Locator.Current.GetService<MasterObjectTable>();
// Listen for incoming messages
m_socket.DataReceived += OnDataReceived;
}
/// <summary>
/// Close the connection
/// </summary>
/// <param name="socket"></param>
void OnConnectionClosed(WebSocket socket)
{
RpcConnection connection = null;
lock (this)
{
if (!m_connections.ContainsKey(socket))
return;
connection = m_connections[socket];
m_connections.Remove(socket);
}
connection.Close();
}
private async void _webSockets_MessageRecived(string guid, WebSocket socket, string message)
{
try
{
var recivedData = DeserializeObject<ServerMessage>(message);
await ProcessMessage(guid, recivedData);
}
catch (JsonReaderException e)
{
var messageErr = new ServerMessage()
{
ClientID = guid,
Command = "Error",
Value = "Wrong message's format"
};
_webSockets.SendMessage(guid, messageErr);
}
}
public void Connected(WebSocket socket)
{
var guid = Guid.NewGuid().ToString();
_webSockets.Add(guid, socket);
socket.DataReceived += (webSocket, frame) => MessageRecived?.Invoke(_webSockets.First(x => x.Value == webSocket).Key,webSocket, frame);
socket.ConnectionClosed += (webSocket) =>
{
var connection = _webSockets.First(s => s.Value == webSocket);
_webSockets.Remove(connection.Key);
};
if (_portMappings.IsBindingPosible())
{
_portMappings.Bind(guid);
var message = new ServerMessage()
{
ClientID = guid,
Command = "Init",
Value = _portMappings.CheckBinding(guid).ToString()
};
SendMessage(guid, message);
}
else
{
var message = new ServerMessage()
{
ClientID = guid,
Command = "Init",
Value = "Max Number Of Clients Reached. Please close connection"
};
SendMessage(guid, message);
}
}
/// <summary>
/// Handle the HTTP connection
///
/// This implementation doesn't support keep alive so each HTTP session
/// consists of parsing the request, dispatching to a handler and then
/// sending the response before closing the connection.
/// </summary>
/// <param name="server"></param>
/// <param name="input"></param>
/// <param name="output"></param>
public void ProcessHttpRequest(Stream input, Stream output)
{
// Set up state
HttpRequest request = null;
HttpResponse response = null;
HttpException parseError = null;
// Process the request
try
{
request = ParseRequest(input);
if ((request == null) || !m_connected)
return; // Nothing we can do, just drop the connection
// Do we have any content in the body ?
if (request.Headers.ContainsKey(HttpHeaders.ContentType))
{
if (!request.Headers.ContainsKey(HttpHeaders.ContentLength))
throw new HttpLengthRequiredException();
int length;
if (!int.TryParse(request.Headers[HttpHeaders.ContentLength], out length))
throw new HttpLengthRequiredException();
request.ContentLength = length;
if (length > MaxRequestBody)
throw new HttpRequestEntityTooLargeException();
// Read the data in
MemoryStream content = new MemoryStream();
while (m_connected && (content.Length != length))
{
ReadData(input);
content.Write(m_buffer, 0, m_index);
ExtractBytes(m_index);
}
// Did the connection drop while reading?
if (!m_connected)
return;
// Reset the stream location and attach it to the request
content.Seek(0, SeekOrigin.Begin);
request.Content = content;
}
// Process the cookies
if (request.Headers.ContainsKey(HttpHeaders.Cookie))
{
string[] cookies = request.Headers[HttpHeaders.Cookie].Split(CookieSeparator);
foreach (string cookie in cookies)
{
string[] parts = cookie.Split(CookieValueSeparator);
Cookie c = new Cookie();
c.Name = parts[0].Trim();
if (parts.Length > 1)
c.Value = parts[1].Trim();
request.Cookies.Add(c);
}
}
// We have at least a partial request, create the matching response
HttpContext context = new HttpContext();
response = new HttpResponse();
// Apply filters
m_server.ApplyFilters(request, response, context);
// TODO: Check for WebSocket upgrade
IWebSocketRequestHandler wsHandler = UpgradeToWebsocket(request, response);
if (wsHandler!=null)
{
// Write the response back to accept the connection
response.Send(output);
output.Flush();
// Now we can process the websocket
WebSocket ws = new WebSocket(input, output);
wsHandler.Connected(ws);
ws.Run();
// Once the websocket connection is finished we don't need to do anything else
return;
}
// Dispatch to the handler
string partialUri;
IHttpRequestHandler handler = m_server.GetHandlerForUri(request.URI, out partialUri);
if (handler == null)
throw new HttpNotFoundException();
handler.HandleRequest(partialUri, request, response, context);
}
catch (HttpException ex)
{
parseError = ex;
}
catch (Exception)
{
parseError = new HttpInternalServerErrorException();
}
// Do we need to send back an error response ?
if (parseError != null)
{
// TODO: Clear any content that might already be added
response.ResponseCode = parseError.ResponseCode;
response.ResponseMessage = parseError.Message;
}
// Write the response
response.Send(output);
output.Flush();
}
void OnDataReceived(WebSocket socket, string frame)
{
socket.Send(frame);
}
public void Connected(WebSocket socket)
{
socket.DataReceived += OnDataReceived;
}
/// <summary>
/// Invoked when a new frame is recieved from the client
/// </summary>
/// <param name="socket"></param>
/// <param name="frame"></param>
void OnDataReceived(WebSocket socket, string frame)
{
// Decode the frame
IDictionary<string, object> data = ObjectPacker.UnpackRaw(frame);
if (data == null)
return;
// Is it a message ?
if (ContainsKeys(data, MessageTopic, MessagePayload))
ProcessMessage(data);
else if (ContainsKeys(data, FunctionSequence, FunctionName, FunctionParameters))
ProcessRpcCall(data);
}
