public async Task Invoke(HttpContext context) { try { if (!context.WebSockets.IsWebSocketRequest) { try { await _next.Invoke(context); } catch {} return; } QuantApp.Kernel.User quser = null; string cokey = context.Request.Cookies["coflows"]; if (cokey == null && context.Request.Query.ContainsKey("_session")) { cokey = context.Request.Query["_session"]; } if (!context.User.Identity.IsAuthenticated) { if (cokey != null) { if (CoFlows.Server.Controllers.AccountController.sessionKeys.ContainsKey(cokey)) { quser = QuantApp.Kernel.User.FindUserBySecret(CoFlows.Server.Controllers.AccountController.sessionKeys[cokey]); if (quser == null) { await _next.Invoke(context); return; } } else { await _next.Invoke(context); return; } } else { await _next.Invoke(context); return; } } var queryString = context.Request.QueryString; var path = context.Request.Path.ToString() + queryString; var headers = new List <KeyValuePair <string, string> >(); foreach (var head in context.Request.Headers) { foreach (var val in head.Value) { try { headers.Add(new KeyValuePair <string, string>(head.Key, val.Replace("%7C", "|"))); } catch {} } } var socket = await context.WebSockets.AcceptWebSocketAsync(); var id = _socketManager.AddSocket(socket); var address = context.Connection.RemoteIpAddress; if (path.StartsWith("/lab/")) { var wid = path.Replace("/lab/", ""); wid = wid.Substring(0, wid.IndexOf("/")); int labPort = CoFlows.Server.Controllers.LabController.LabDB[cokey + wid]; var client = ProxyConnection.Client(socket, path); client.Connect("ws://localhost:" + labPort, headers); var _socket = client.ClientWebSocket; _proxies.TryAdd(socket.GetHashCode() + path, client); } if (WebSocketListner.registered_address.ContainsKey(id)) { WebSocketListner.registered_address[id] = address; } else { WebSocketListner.registered_address.TryAdd(id, address); } if (WebSocketListner.registered_sockets.ContainsKey(id)) { WebSocketListner.registered_sockets[id] = socket; } else { WebSocketListner.registered_sockets.TryAdd(id, socket); } await Receive(socket, async (result, length, buffer) => { if (quser != null) { QuantApp.Kernel.User.ContextUser = quser.ToUserData(); } if (result.MessageType == WebSocketMessageType.Close) { await _socketManager.RemoveSocket(id); QuantApp.Kernel.User.ContextUser = new UserData(); return; } else if (result.MessageType == WebSocketMessageType.Text) { string userMessage = Encoding.UTF8.GetString(buffer, 0, length); WebSocketListner.appServer_NewMessageReceived(socket, userMessage, path, headers); QuantApp.Kernel.User.ContextUser = new UserData(); return; } else { Console.WriteLine("REC BIN1: " + result.MessageType); } QuantApp.Kernel.User.ContextUser = new UserData(); }); } catch (Exception e) { Console.WriteLine("Invoke " + e); Console.WriteLine(e.StackTrace); } }
public static void appServer_NewMessageReceived(WebSocket session, string message_string, string path, List <KeyValuePair <string, string> > headers) { try { string skey = manager == null ? null : manager.GetId(session); if (!string.IsNullOrWhiteSpace(message_string)) { DateTime t1 = DateTime.Now; QuantApp.Kernel.RTDMessage message = null; if (path.StartsWith("/lab/")) { var sessionID = session.GetHashCode() + path; if (RTDSocketMiddleware._proxies.ContainsKey(sessionID)) { var _client = RTDSocketMiddleware._proxies[sessionID]; _client.Send(message_string); } else { Console.WriteLine("Socket Not Found(" + path + "): " + message_string); } } else { try { message = JsonConvert.DeserializeObject <QuantApp.Kernel.RTDMessage>(message_string); } catch {} if (message != null) { if (message.Type == QuantApp.Kernel.RTDMessage.MessageType.Subscribe) { try { string contract = message.Content.ToString(); if (contract.StartsWith("$")) { contract = contract.Substring(1, contract.Length - 1); if (!traders.ContainsKey(contract)) { traders.TryAdd(contract, skey); Send(session, message_string); } } if (!subscriptions.ContainsKey(contract)) { subscriptions.TryAdd(contract, new ConcurrentDictionary <string, WebSocket>()); } if (!subscriptions[contract].ContainsKey(skey)) { subscriptions[contract].TryAdd(skey, session); } if (!users.ContainsKey(contract)) { users.TryAdd(contract, new ConcurrentDictionary <string, QuantApp.Kernel.UserData>()); } if (!users[contract].ContainsKey(skey)) { users[contract].TryAdd(skey, QuantApp.Kernel.User.ContextUser); } // Console.WriteLine("Subscribed: " + skey + " -- " + contract); } catch (Exception e) { Console.WriteLine("Subsribe Exception: " + e + " " + skey); } } else if (message.Type == QuantApp.Kernel.RTDMessage.MessageType.SaveM) { try { string mid = message.Content.ToString(); M m = M.Base(mid); m.Save(); } catch (Exception e) { Console.WriteLine("SaveM Exception: " + e + " " + skey); } } else if (message.Type == QuantApp.Kernel.RTDMessage.MessageType.PING) { try { DateTime stamp = (DateTime)message.Content; var response = JsonConvert.SerializeObject(new QuantApp.Kernel.RTDMessage() { Type = QuantApp.Kernel.RTDMessage.MessageType.PING, Content = DateTime.Now }); Send(session, response); } catch (Exception e) { Console.WriteLine("MarketData Exception: " + e + " " + skey); } } else if (message.Type == QuantApp.Kernel.RTDMessage.MessageType.UpdateQueue) { QuantApp.Kernel.QueueMessage qm = JsonConvert.DeserializeObject <QuantApp.Kernel.QueueMessage>(message.Content.ToString()); QuantApp.Kernel.RTDEngine.UpdateQueue(qm); Share(session, qm.TopicID, message_string); } else if (message.Type == QuantApp.Kernel.RTDMessage.MessageType.CRUD) { QuantApp.Kernel.RTDMessage.CRUDMessage qm = JsonConvert.DeserializeObject <QuantApp.Kernel.RTDMessage.CRUDMessage>(message.Content.ToString()); try { var type = Type.GetType(qm.ValueType); if (type == null) { Assembly assembly = QuantApp.Kernel.M._systemAssemblies.ContainsKey(qm.ValueType) ? QuantApp.Kernel.M._systemAssemblies[qm.ValueType] : (QuantApp.Kernel.M._compiledAssemblies.ContainsKey(qm.ValueType) ? QuantApp.Kernel.M._compiledAssemblies[qm.ValueType] : System.Reflection.Assembly.Load(qm.ValueAssembly)); type = assembly.GetType(QuantApp.Kernel.M._systemAssemblyNames.ContainsKey(qm.ValueType) ? QuantApp.Kernel.M._systemAssemblyNames[qm.ValueType] : (QuantApp.Kernel.M._compiledAssemblyNames.ContainsKey(qm.ValueType) ? QuantApp.Kernel.M._compiledAssemblyNames[qm.ValueType] : qm.ValueType)); } string filtered_string = qm.Value.ToString().Replace((char)27, '"').Replace((char)26, '\''); if (filtered_string.StartsWith("\"") && filtered_string.EndsWith("\"")) { filtered_string = filtered_string.Substring(1, filtered_string.Length - 2).Replace("\\\"", "\""); } if (type == typeof(string) || qm.ValueType == null || type == typeof(Nullable)) { qm.Value = filtered_string; } else if (type != null) { qm.Value = JsonConvert.DeserializeObject(filtered_string, type); } } catch {} if (qm.Class == QuantApp.Kernel.M.CRUDClass) { QuantApp.Kernel.M.Base(qm.TopicID).Process(qm); } Share(session, qm.TopicID, message_string); } else if (message.Type == QuantApp.Kernel.RTDMessage.MessageType.ProxyOpen) { var pd = JsonConvert.DeserializeObject <HttpProxyRequest>(message.Content.ToString()); var client = ProxyConnection.Client(session, pd.Url); client.Connect(pd.Content, pd.Headers); } else if (message.Type == QuantApp.Kernel.RTDMessage.MessageType.ProxyContent) { var pd = JsonConvert.DeserializeObject <HttpProxyRequest>(message.Content.ToString()); var sessionId = session.GetHashCode() + pd.Url; if (RTDSocketMiddleware._proxies.ContainsKey(sessionId)) { var client = RTDSocketMiddleware._proxies[sessionId]; client.Send(pd.Content); } else { var client = ProxyConnection.Client(session, pd.Url); client.Send(pd.Content); } } else if (RTDMessageFunction != null) { var mess = RTDMessageFunction(message_string); if (mess != null) { Share(session, mess.Item1, mess.Item2); } } } else { Console.WriteLine("UNKNOWN(" + path + "): " + message_string); } } counter++; } else { Console.WriteLine("--------------EMPTY STRING: " + path); } } catch (Exception e) { Console.WriteLine("Server Receive Message Exception: " + e); } }