static void socketServer_NewSessionConnected(WebSocketSession session)
{
string name = "null", data = string.Empty;
int ifor = 0;
int.TryParse(session.Host[0].ToString(), out ifor);
msgFor mfor = (msgFor)ifor;
switch (mfor)
{
case msgFor.API:
case msgFor.EVENT:
data = session.Origin;
session.Close();
db.process_MSG(mfor, data);
break;
default:
m_Sessions.Add(session);
name = session.Cookies["name"] == null?Guid.NewGuid().ToString().Substring(0, 8) : session.Cookies["name"];
//SendToAll(name + ": " + e);
SendToAll("System: " + name + " connected");
break;
}
}
private void CloseConnection()
{
_connectionState = ConnectionState.Disconnected;
OnDisconnect?.Invoke(_webSocketSession);
_webSocketSession.Close();
}
protected void WebSocketServer_NewMessageReceived(WebSocketSession session, string e)
{
try
{
var data = JsonConvert.DeserializeObject <UniversalFileToPrinter.Models.FilePrintRequest>(e);
if (!FilePrintHelper.Checklisence())
{
session.Close();
return;
}
switch (data.action)
{
case "HandShake":
session.Send(JsonConvert.SerializeObject(data));
break;
case "Print":
if (!string.IsNullOrEmpty(data.dataSTR))
{
data.dataBin = Convert.FromBase64String(data.dataSTR);
}
_printHelper.Print(data.type, data.extension, data.printer, data.fileUrl, data.dataBin, data.info, session);
break;
case "ListPrinters":
session.Send(JsonConvert.SerializeObject(new
{
list = _printHelper.ListPrinters(),
isError = false,
action = "ListPrinters"
}));
break;
case "Stop":
session.Close();
_printHelper.StopAndClose();
break;
}
}
catch (Exception ex)
{
Logger.Error("WebSocketServer_NewMessageReceived", ex);
}
}
static void appServer_SessionClosed(WebSocketSession session, CloseReason closeRs)
{
session.Close();
Console.WriteLine("客户端" + session.RemoteEndPoint.Port + "断开了连接！");
ClientNum -= 1;
Console.WriteLine("客户端数目" + ClientNum.ToString());
}
/// <summary>
/// Sends xml data coded in Unicode to session
/// and closes it
/// </summary>
private static void Send_Xml(WebSocketSession session, XElement body)
{
Log.WriteLine("Send_Xml " + session + ". body: " + body, typeof(AccountsServerSend));
var bytes = Encoding.Unicode.GetBytes(body.ToString());
session.Send(bytes, 0, bytes.Length);
session.Close();
}
/// <summary>
/// Called when a WebSocket session is connected.
/// </summary>
/// <param name="session">The session.</param>
private void OnNewSessionConnected(WebSocketSession session)
{
Logger.Info($"Handling WebSocket request from {session.RemoteEndPoint}.");
var ws = new EtpServerWebSocket {
WebSocketSession = session
};
_webSockets[session.SessionID] = ws;
var headers = new Dictionary <string, string>();
foreach (var item in session.Items)
{
headers[item.Key.ToString()] = item.Value.ToString();
}
var version = EtpWebSocketValidation.GetEtpVersion(session.SubProtocol.Name);
var encoding = EtpWebSocketValidation.GetEtpEncoding(headers);
if (!Details.IsVersionSupported(version))
{
Logger.Debug($"Sub protocol not supported: {session.SubProtocol.Name}");
session.Close(CloseReason.ApplicationError);
return;
}
if (encoding == null)
{
Logger.Debug($"Error getting ETP encoding.");
session.Close(CloseReason.ApplicationError);
return;
}
if (!Details.IsEncodingSupported(encoding.Value))
{
Logger.Debug($"Encoding not supported: {encoding.Value}");
session.Close(CloseReason.ApplicationError);
return;
}
var server = ServerManager.CreateServer(ws, version, encoding.Value, headers);
server.Start();
}
public MultiServerClient(MasterHandler handler, ClientInfo info, WebSocketSession session)
{
this.handler = handler;
this.info = info;
this.session = session;
timeoutTimer = new Timer(x =>
{
if (status == ClientWorkerStatus.Connecting)
{
session.Close(SuperSocket.SocketBase.CloseReason.TimeOut);
}
}, null, 2000, Timeout.Infinite);
keepAliveSw = new Stopwatch();
keepAliveTimer = new Timer(x =>
{
if (!session.Connected)
{
return;
}
lock (keepAliveSw)
{
if (!keepAliveSw.IsRunning)
{
keepAliveSw.Start();
}
if (keepAliveSw.ElapsedMilliseconds > 5000)
{
handler.Logger.Log($"Client {session.SessionID} is disconnected with idle of {keepAliveSw.ElapsedMilliseconds}");
keepAliveSw.Stop();
handler.RemoveClient(session.SessionID);
session.Close();
status = ClientWorkerStatus.None;
keepAliveTimer.Change(Timeout.Infinite, Timeout.Infinite);
return;
}
}
SendPacket(new SimplePacket()
{
Data = new byte[0],
Type = PacketType.Nop
});
}, null, 0, 1000);
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources.
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected override void Dispose(bool disposing)
{
if (disposing)
{
Close("Shutting down");
_session?.Close();
}
base.Dispose(disposing);
_session = null;
}
void socketServer_NewMessageReceived(WebSocketSession session, string msg)
{
////string name = session.Cookies["name"] == null ? "" : session.Cookies["name"].ToString();
//string name = Guid.NewGuid().ToString();
//SendToAll(name + ": " + msg);
//Debug.WriteLine()
switch (msg)
{
case "FILE_DELETE":
fileDelete();
session.Send("FILE_DELETE_SUCCESS");
break;
case "SENDING_COMPLETE":
bool ok = saveFile(session.SessionID);
if (ok)
{
session.Send("UPLOAD_SUCCESS");
}
else
{
session.Send("UPLOAD_FAIL");
}
session.Close();
break;
default:
// Begin receive buffer of the files
if (msg[0] == '{' && msg[msg.Length - 1] == '}')
{
try
{
oFile fi = JsonConvert.DeserializeObject <oFile>(msg);
if (files.ContainsKey(session.SessionID))
{
files[session.SessionID] = fi;
}
else
{
files.TryAdd(session.SessionID, fi);
}
var stream = new MemoryStream();
streams.TryAdd(session.SessionID, stream);
session.Send("SOCKET_BUFFERING_START");
}
catch { }
}
break;
}
}
protected void AppServerNewSessionConnected(WebSocketSession session)
{
// The server will only maintain one connection. Whenever a new session is trying to connect, the previous
// session will be closed.
if (currentSession != null)
{
currentSession.SendCloseHandshakeResponse(0);
currentSession.Close();
}
Console.WriteLine("Client Connected. IP " + session.RemoteEndPoint.Address.ToString() + " Port " + session.RemoteEndPoint.Port.ToString());
FileLogger.Instance.LogMessage("Client Connected. IP " + session.RemoteEndPoint.Address.ToString() + " Port " + session.RemoteEndPoint.Port.ToString());
currentSession = session;
}
private static void ProcessCommand(WebSocketSession session, string value)
{
Command command = JsonConvert.DeserializeObject <Command>(value);
if (command.Token != Bus.AuthToken)
{
BusLogger.LogException(new InvalidAuthTokenException("INVALID AUTHENTICATION TOKEN ERROR"));
session.Send(JsonConvert.SerializeObject(CommandProcessor.CommandCallback("error_message", "An incorrect authentication key was provided")));
return;
}
session.Send(CommandProcessor.RunCommand(command));
session.Close();
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources.
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected override void Dispose(bool disposing)
{
if (disposing)
{
Logger.Verbose($"[{SessionKey}] Disposing EtpServer for {GetType().Name}");
CloseWebSocket("Shutting down");
_session?.Close();
Logger.Verbose($"[{SessionKey}] Disposed EtpServer for {GetType().Name}");
}
base.Dispose(disposing);
_session = null;
}
/// <summary>
/// 关闭服务器与客户端的会话连接
/// </summary>
/// <param name="appSession"></param>
/// <param name="MsgText"></param>
void CloseClientConnection(WebSocketSession appSession, string MsgText)
{
appSession.Close(CloseReason.ServerClosing);
appSession.CloseWithHandshake(200, MsgText);
return;
}
private static void appServer_SessionClosed(WebSocketSession session, SuperSocket.SocketBase.CloseReason value)
{
//sessionManager.Remove(session.SessionID.ToString());
session.Close();
}
public override void ExecuteCommand(WebSocketSession session, SubRequestInfo requestInfo)
{
session.Close();
}
protected override void OnSessionNewMessage(WebSocketSession session, WebSocketMessage message)
{
if (message.Opcode == WebSocketOpcode.Text)
{
string m = Encoding.UTF8.GetString(message.Message);
ChatProtocol chatMessage = JsonConvert.DeserializeObject <ChatProtocol>(m);
if (string.IsNullOrEmpty(chatMessage.UserName))
{
session.Close("UserName missed", WebSocketCloseStatusCode.InternalServerError);
Sessions.Remove(session.SessionID);
return;
}
if (chatMessage.CommandType == "Login")
{
if (Room.ContainsUser(chatMessage.UserName))
{
chatMessage.CommandType = "Error";
chatMessage.Message = "User have been already in chatroom";
session.Close("User have already logined", WebSocketCloseStatusCode.InternalServerError);
Sessions.Remove(session.SessionID);
return;
}
else
{
Room.AddUser(chatMessage.UserName, session.RemoteEndpoint);
var remotelist = Room.RemoteEndpointList;
foreach (var remote in remotelist)
{
WebSocketSession s = Sessions[remote];
if (s != null)
{
if (!s.Send(m))
{
Sessions.Remove(session.SessionID);
string user = Room.GetUser(remote);
if (!string.IsNullOrEmpty(user))
{
Room.RemoveUser(user);
}
}
}
}
return;
}
}
else if (chatMessage.CommandType == "Message")
{
var remotelist = Room.RemoteEndpointList;
foreach (var remote in remotelist)
{
WebSocketSession s = Sessions[remote];
if (s != null)
{
if (!s.Send(m))
{
Sessions.Remove(session.SessionID);
string user = Room.GetUser(remote);
if (!string.IsNullOrEmpty(user))
{
Room.RemoveUser(user);
}
}
}
}
}
else
{
return;
}
}
}
void ProcessMessage(WebSocketSession session,string type,string[] args)
{
switch(type){
case "join":
var result=CheckJoinRequset(session,args);
session.Send(CreateMessage(new[]{"joinres",(string)result.IsSucceeded.ToString(),(string)result.Message}));
if(result.IsSucceeded){
if(NewUserAdded!=null){
sessions.Add(args[0],session);
NewUserAdded(session,new UserEventArgs(args[0]));
}
}else session.Close();
break;
case "message":
var name=sessions.FirstOrDefault(pair=>pair.Value==session).Key;
if(name!=""&&args.Length>0&&MessageReceived!=null)
MessageReceived(session,new MessageReceivedEventArgs(name,args[0]));
break;
case "screenshotres":
name=sessions.FirstOrDefault(pair=>pair.Value==session).Key;
if(name!=""&&args.Length>0){
ThreadPool.QueueUserWorkItem((arg)=>{
var data=ConvertData(arg as string);
if(ScreenShotReceived!=null)
ScreenShotReceived(session,new ScreenShotReceivedEventArgs(name,data));
},args[0]);
}
break;
default:
break;
}
}
static void socketServer_NewSessionConnected(WebSocketSession session)
{
String acceptedOrigin = "http://192.168.31.68";
//Console.WriteLine(session.RemoteEndPoint.Address.ToString());
Console.WriteLine(session.Origin);
if (session.Origin.Equals(acceptedOrigin)) {
lock (m_SessionSyncRoot)
m_Sessions.Add (session);
SendToAll ("System: " + session.SessionID + " connected");
} else {
session.Close(CloseReason.SocketError);
}
}
public override void ExecuteCommand(WebSocketSession session, SubRequestInfo requestInfo)
{
session.Close();
}
//--------------------------------------------------------------------------------------------------
//--------------------------------WS --------------------------------------------------
//--------------------------------------------------------------------------------------------------
private static void socketServer_NewSessionConnected(WebSocketSession session)
{
var portName = session.Path.Replace("/", "");
if (portName != null && portName != "")
{
portName = portName.Replace("/", "");
Info("Sock client " + session.SessionID + " connected with path " + portName);
try
{
var cfg = PortOpen(portName, 0);
session.Send(JsonConvert.SerializeObject(cfg));
session.Path = portName;
return;
}
catch (Exception e){
session.Send("{ \"error\": \"" + e.Message + "\"}");
}
}
else
{
Info("Sock client " + session.SessionID + " connected without path ");
session.Send(JsonConvert.SerializeObject(ComPortConfigs));
}
session.Close();
}
public override void ExecuteCommand(WebSocketSession session, StringCommandInfo commandInfo)
{
session.Close();
}
public override void Dispose()
{
// TODO: Investigate the other Close methods that might let us transmit a last message saying that the server closed the connection on purpose.
socket.Close();
}
/// <summary>
/// indicates a string message received
/// </summary>
/// <param name="aSession">WebSocket session info</param>
/// <param name="aValue">message serialized to string</param>
void OnNewMessageReceived(WebSocketSession aSession, string aValue)
{
try
{
// 'test code' is usefull to test client's request.
#region test code
/*if (aValue == "L" || aValue == "l")
* {
* LoginRequest aRequest = new LoginRequest("DemoUser", "demo");
*
* aValue = JsonConvert.SerializeObject(aRequest);
* }
* else if (aValue == "O" || aValue == "o")
* {
* LogoutRequest aRequest = new LogoutRequest();
*
* aValue = JsonConvert.SerializeObject(aRequest);
* }
* else if (aValue == "S" || aValue == "s")
* {
* SubscribeRequest aRequest = new SubscribeRequest(new SymbolItem() { Symbol = "MSFT", DataFeed = "Simulation DataFeed", Exchange = String.Empty, Type = 1 });
*
* aValue = JsonConvert.SerializeObject(aRequest);
* }
* else if (aValue == "U" || aValue == "u")
* {
* UnsubscribeRequest aRequest = new UnsubscribeRequest(new SymbolItem() { Symbol = "MSFT", DataFeed = "Simulation DataFeed", Exchange = String.Empty, Type = 1 });
*
* aValue = JsonConvert.SerializeObject(aRequest);
* }
* else if (aValue == "HD" || aValue == "hd")
* {
* HistoryRequest aRequest = new HistoryRequest()
* {
* Selection = new HistoryParameters()
* {
* Symbol = new SymbolItem() { Symbol = "MSFT", DataFeed = "DDF", Exchange = String.Empty, Type = 1 },
* Periodicity = CommonObjects.Periodicity.Day,
* Interval = 1,
* Id = Guid.NewGuid().ToString("N"),
* BarsCount = 100,
* From = new DateTime(DateTime.MinValue.Ticks, DateTimeKind.Utc),
* To = new DateTime(DateTime.MinValue.Ticks, DateTimeKind.Utc)
* }
* };
* aValue = JsonConvert.SerializeObject(aRequest);
* }
* //else if (aValue == "HM" || aValue == "hm")
* //{
* // HistoryRequest aRequest = new HistoryRequest()
* // {
* // Selection = new HistoryParameters()
* // {
* // Symbol = new SymbolItem() { Symbol = "MSFT", DataFeed = "DDF", Exchange = String.Empty, Type = 1 },
* // Periodicity = CommonObjects.Periodicity.Minute,
* // Interval = 1,
* // Id = Guid.NewGuid().ToString("N"),
* // BarsCount = 1000,
* // From = new DateTime(DateTime.MinValue.Ticks, DateTimeKind.Utc),
* // To = new DateTime(DateTime.MinValue.Ticks, DateTimeKind.Utc)
* // }
* // };
* // aValue = JsonConvert.SerializeObject(aRequest);
* //}
* else if (aValue == "HM" || aValue == "hm")
* {
* HistoryRequest aRequest = new HistoryRequest()
* {
* Selection = new HistoryParameters()
* {
* Symbol = new SymbolItem() { Symbol = "MSFT", DataFeed = "DDF", Exchange = String.Empty, Type = 1 },
* Periodicity = CommonObjects.Periodicity.Minute,
* Interval = 1,
* Id = Guid.NewGuid().ToString("N"),
* BarsCount = 100,
* From = DateTime.UtcNow.Date.AddDays(-1),
* To = DateTime.UtcNow
* }
* };
* aValue = JsonConvert.SerializeObject(aRequest);
* }*/
#endregion
RequestMessage aBaseTypeReq = JsonConvert.DeserializeObject <RequestMessage>(aValue);
RequestMessage requestMessage = null;
if (aBaseTypeReq.MsgType == typeof(LoginRequest).Name)
{
LoginRequest aLoginRequest = JsonConvert.DeserializeObject <LoginRequest>(aValue);
if (DataServer.MessageRouter.gMessageRouter.Authenticate(aLoginRequest.Login, aLoginRequest.Password))
{
WebSocketUserInfo aUserInfo;
aUserInfo = new WebSocketUserInfo(aLoginRequest.Login, aSession);
lock (DataServer.MessageRouter.gMessageRouter)
{
DataServer.MessageRouter.gMessageRouter.AddSession(aUserInfo.ID, aUserInfo);
}
WriteToLog_Info(String.Format("Login succeeded: user = '******' id = '{1}'", aLoginRequest.Login, aUserInfo.ID), null);
//aSession.Send(JsonConvert.SerializeObject(new LoginResponse(aUserInfo.Login)));
aSession.Send(JsonConvert.SerializeObject(new LoginResponse()
{
Login = aLoginRequest.Login
}));
}
else
{
WriteToLog_Warning(String.Format("Login error: user = '******'", aLoginRequest.Login), null);
//aSession.Send(JsonConvert.SerializeObject(new LoginResponse() { Login = aLoginRequest.Login }));
aSession.Send(JsonConvert.SerializeObject(new LoginResponse()
{
Login = aLoginRequest.Login,
Error = String.Format("Logon error: {0} account is not validated", aLoginRequest.Login)
}));
//aSession.Send(JsonConvert.SerializeObject(new ErrorInfo(String.Format("Logon error: {0} account is not validated", aLoginRequest.Login))));
aSession.Close();
return;
}
}
else if (aBaseTypeReq.MsgType == typeof(LogoutRequest).Name)
{
var aLogoutRequest = JsonConvert.DeserializeObject <LogoutRequest>(aValue);
WriteToLog_Info(String.Format("Logout : id = '{0}'", aSession.SessionID), null);
aSession.Close();
}
else if (aBaseTypeReq.MsgType == typeof(RemoteNotificationRequest).Name)
{
if (DataServer.MessageRouter.gMessageRouter.RemoteNotificator != null)
{
var aRemoteNotificationRequest =
JsonConvert.DeserializeObject <RemoteNotificationRequest>(aValue);
lock (DataServer.MessageRouter.gMessageRouter)
{
string aCurrentUserName =
DataServer.MessageRouter.gMessageRouter.GetUserInfo(aSession.SessionID).Login;
try
{
DataServer.MessageRouter.gMessageRouter.RemoteNotificator.SetDeviceTokenAndTypeForUser(
aCurrentUserName, aRemoteNotificationRequest.DeviceToken,
aRemoteNotificationRequest.DeviceType);
}
catch
{
}
}
}
}
else if (aBaseTypeReq.MsgType == typeof(DataFeedListRequest).Name)
{
requestMessage = JsonConvert.DeserializeObject <DataFeedListRequest>(aValue);
}
else if (aBaseTypeReq.MsgType == typeof(SubscribeRequest).Name)
{
requestMessage = JsonConvert.DeserializeObject <SubscribeRequest>(aValue);
}
else if (aBaseTypeReq.MsgType == typeof(UnsubscribeRequest).Name)
{
requestMessage = JsonConvert.DeserializeObject <UnsubscribeRequest>(aValue);
}
else if (aBaseTypeReq.MsgType == typeof(HistoryRequest).Name)
{
requestMessage = JsonConvert.DeserializeObject <HistoryRequest>(aValue);
/*aHistoryRequest.Selection.From = aHistoryRequest.Selection.From.ToUniversalTime();
* aHistoryRequest.Selection.To = aHistoryRequest.Selection.To.ToUniversalTime();*/
}
else if (aBaseTypeReq.MsgType == typeof(AlertSubscribeRequest).Name)
{
requestMessage = JsonConvert.DeserializeObject <AlertSubscribeRequest>(aValue);
}
else if (aBaseTypeReq.MsgType == typeof(AlertUnsubscribeRequest).Name)
{
requestMessage = JsonConvert.DeserializeObject <AlertUnsubscribeRequest>(aValue);
}
else if (aBaseTypeReq.MsgType == typeof(AlertsHistoryRequest).Name)
{
requestMessage = JsonConvert.DeserializeObject <AlertsHistoryRequest>(aValue);
}
else if (aBaseTypeReq.MsgType == typeof(BacktestGetRequest).Name)
{
requestMessage = JsonConvert.DeserializeObject <BacktestGetRequest>(aValue);
}
else if (aBaseTypeReq.MsgType == typeof(L2SubscribeRequest).Name)
{
requestMessage = JsonConvert.DeserializeObject <L2SubscribeRequest>(aValue);
}
else if (aBaseTypeReq.MsgType == typeof(L2UnsubscribeRequest).Name)
{
requestMessage = JsonConvert.DeserializeObject <L2UnsubscribeRequest>(aValue);
}
else
{
///need implement
//throw new ApplicationException(String.Format("{0} message is unknown.", aBaseTypeReq.MsgType));
}
if (requestMessage != null)
{
lock (DataServer.MessageRouter.gMessageRouter)
{
WebSocketUserInfo aUserInfo = DataServer.MessageRouter.gMessageRouter.GetUserInfo(aSession.SessionID) as WebSocketUserInfo;
if (aUserInfo != null)
{
DataServer.MessageRouter.gMessageRouter.ProcessRequest(aUserInfo.ID, requestMessage);
}
}
}
}
catch (Exception e)
{
WriteToLog(aValue, e);
aSession.Send(JsonConvert.SerializeObject(new ErrorInfo("DataServer Error: unexpected message received")));
aSession.Close();
}
}
void appServer_SessionClosed(WebSocketSession session, SuperSocket.SocketBase.CloseReason value)
{
this.listBox1.Items.Add(value.ToString());
session.Close();
}
public void Close()
{
session.Close(SuperSocket.SocketBase.CloseReason.ClientClosing);
}
public void Disconnect()
{
m_WebSocketSession.Close();
}
private void OnMessageReceived(WebSocketSession session, string m)
{
try
{
var client = ClientsCollection.Get(session);
if (client == null)
{
return;
}
var r = JsonSerializeHelper.Deserialize <Message>(m);
switch (r.MsgType)
{
case "RegistrationRequest":
{
if (client.IsLoggedIn)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request")));
return;
}
var request = JsonSerializeHelper.Deserialize <RegistrationRequest>(m);
var responseString = "";
if (string.IsNullOrEmpty(request.Login) || string.IsNullOrEmpty(request.Password))
{
responseString = JsonSerializeHelper.Serialize(new ErrorResponse("Bad request"));
}
else if (DataProvider.IsUsernameExists(request.Login))
{
responseString = JsonSerializeHelper.Serialize(new RegistrationResponse
{
ReqID = request.ReqID,
Error = "Someone with this username already exists"
});
}
else
{
responseString = DataProvider.AddAccount(request.Login, request.Password, request.Email, request.Card)
? JsonSerializeHelper.Serialize(new RegistrationResponse {
ReqID = request.ReqID
})
: JsonSerializeHelper.Serialize(new RegistrationResponse {
ReqID = request.ReqID, Error = "Undefined error"
});
}
session.Send(responseString);
break;
}
case "LoginRequest":
{
if (client.IsLoggedIn)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("User Already logged in to server")));
return;
}
var request = JsonSerializeHelper.Deserialize <LoginRequest>(m);
var responseString = "";
if (DataProvider.ValidateUserCredentials(request.Login, request.Password))
{
client.Username = request.Login;
client.Password = request.Password;
client.IsLoggedIn = true;
client.AccountInfo = DataProvider.GetAccountInfo(client.Username);
responseString = JsonSerializeHelper.Serialize(new LoginResponse
{
ReqID = request.ReqID
});
_connectedUsers.Add(new UserSession()
{
UserName = client.Username
,
Session = session
});
}
else
{
responseString = JsonSerializeHelper.Serialize(new LoginResponse
{
ReqID = request.ReqID,
Error = "Invalid credentials"
});
}
session.Send(responseString);
break;
}
case "LogoutRequest":
{
var request = JsonSerializeHelper.Deserialize <LogoutRequest>(m);
var responseString = client.IsLoggedIn
? JsonSerializeHelper.Serialize(new LogoutResponse {
ReqID = request.ReqID
})
: JsonSerializeHelper.Serialize(new ErrorResponse("No user session availble with server"));
session.Send(responseString);
session.Close();
break;
}
case "QuotesSubscribeRequest":
{
if (!client.IsLoggedIn)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request")));
return;
}
var request = JsonSerializeHelper.Deserialize <QuotesSubscribeRequest>(m);
ClientsCollection.Get(session).Subscriptions.AddQuote(request.Symbol.Name);
break;
}
case "QuotesUnsubscribeRequest":
{
if (!client.IsLoggedIn)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request")));
return;
}
var request = JsonSerializeHelper.Deserialize <QuotesUnsubscribeRequest>(m);
ClientsCollection.Get(session).Subscriptions.RemoveQuote(request.Symbol.Name);
break;
}
case "AccountInfoGetRequest":
{
if (!client.IsLoggedIn)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request")));
return;
}
var request = JsonSerializeHelper.Deserialize <AccountInfoGetRequest>(m);
var response = new AccountInfoGetResponse
{
ReqID = request.ReqID,
AccountData = client.AccountInfo,
};
session.Send(JsonSerializeHelper.Serialize(response));
break;
}
case "AccountInfoSubscribeRequest":
{
if (!client.IsLoggedIn)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request")));
return;
}
var request = JsonSerializeHelper.Deserialize <AccountInfoSubscribeRequest>(m);
ClientsCollection.Get(session).Subscriptions.AccountInfo = true;
break;
}
case "AccountInfoUnsubscribeRequest":
{
if (!client.IsLoggedIn)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request")));
return;
}
var request = JsonSerializeHelper.Deserialize <AccountInfoUnsubscribeRequest>(m);
ClientsCollection.Get(session).Subscriptions.AccountInfo = false;
break;
}
case "AssetsGetRequest":
{
if (!client.IsLoggedIn)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request")));
return;
}
var request = JsonSerializeHelper.Deserialize <AssetsGetRequest>(m);
var response =
new AssetsGetResponse
{
ReqID = request.ReqID,
Assets = DataProvider.GetAssets()
};
session.Send(JsonSerializeHelper.Serialize(response));
break;
}
case "AssetsGetBySymbolRequest":
{
if (!client.IsLoggedIn)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request")));
return;
}
var request = JsonSerializeHelper.Deserialize <AssetsGetBySymbolRequest>(m);
var timestamp = (TimestampUtility.GetCurrentTimestamp() / 1000) + DataProvider.StopExpiryLimitinMinutes * 60;
var asset = DataProvider.GetAssets(request.Symbol);
Asset temp = new Asset();
if (asset != null)
{
temp.ID = asset.ID;
temp.Symbol = asset.Symbol;
temp.ExpiryTimeList = asset.ExpiryTimeList.Where(x => (x.ExpiryTimestamps / 1000) > timestamp)
.Take(4)
.ToList <ExpiryTime>();
}
var response =
new AssetsGetBySymbolResponse
{
ReqID = request.ReqID,
Assets = temp
};
session.Send(JsonSerializeHelper.Serialize(response));
break;
}
case "BarsSubscribeRequest":
{
if (!client.IsLoggedIn)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request")));
return;
}
var request = JsonSerializeHelper.Deserialize <BarsSubscribeRequest>(m);
ClientsCollection.Get(session).Subscriptions.AddBarSubscription(request.ID, request.Symbol.Name, request.Periodicity, request.Interval);
break;
}
case "BarsUnsubscribeRequest":
{
if (!client.IsLoggedIn)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request")));
return;
}
var request = JsonSerializeHelper.Deserialize <BarsUnsubscribeRequest>(m);
ClientsCollection.Get(session).Subscriptions.RemoveBarSubscription(request.ID);
break;
}
case "HistoryGetRequest":
{
if (!client.IsLoggedIn)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request")));
return;
}
var request = JsonSerializeHelper.Deserialize <HistoryGetRequest>(m);
var bars = request.BarsCount == 0
? DataProvider.GetHistory(request.Symbol, request.Periodicity, request.Interval, request.StartTimestamp)
: DataProvider.GetHistory(request.Symbol, request.Periodicity, request.Interval, request.BarsCount);
var response = new HistoryGetResponse(request.ReqID, bars);
session.Send(JsonSerializeHelper.Serialize(response));
break;
}
case "OrderPlaceRequest":
{
if (!client.IsLoggedIn)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request")));
return;
}
var request = JsonSerializeHelper.Deserialize <OrderPlaceRequest>(m);
string res = string.Empty;
var asset = DataProvider.GetAssetById(request.OptionID);
var valResult = DataProvider.ValidateOrder(client.AccountInfo, asset, request);
if (!String.IsNullOrEmpty(valResult))
{
var response = new OrderPlaceResponse
{
ReqID = request.ReqID,
ClOrdID = request.ClOrdID,
Error = valResult
};
res = JsonSerializeHelper.Serialize(response);
session.Send(res);
}
else
{
if (request.OptionType == Enums.OptionType.Express)
{
request.ExpiryTimestamp = DataProvider.GetCurrentTimestamp() + (request.ExpressExpiryInSeconds * 1000);
}
DateTime expiry = TimestampUtility.TimestampToDateTime(request.ExpiryTimestamp);
var order = DataProvider.PlaceOrder(client.AccountInfo, asset, request);
var response = new OrderPlaceResponse
{
ReqID = request.ReqID,
ClOrdID = request.ClOrdID,
SrvOrdID = order.ID,
Expiry = expiry
};
res = JsonSerializeHelper.Serialize(response);
session.Send(res);
sendSubcriptionNotification(session, client, order);
}
Logger.Log(client.Username, "OrderPlaceRequest", m, res, !String.IsNullOrEmpty(valResult));
break;
}
case "OrderCancelRequest":
{
if (!client.IsLoggedIn)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request")));
return;
}
var request = JsonSerializeHelper.Deserialize <OrderCancelRequest>(m);
var order = DataProvider.CancelOrder(client.AccountInfo, request.SrvOrdID);
if (order == null)
{
var response = new OrderCancelResponse
{
ReqID = request.ReqID,
SrvOrdID = request.SrvOrdID,
Error = "Error"
};
session.Send(JsonSerializeHelper.Serialize(response));
}
else
{
var response = new OrderCancelResponse
{
ReqID = request.ReqID,
SrvOrdID = request.SrvOrdID
};
session.Send(JsonSerializeHelper.Serialize(response));
//if (ClientsCollection.Get(session).Subscriptions.OpenOrders)
//{
// session.Send(JsonSerializeHelper.Serialize(new OpenOrdersSubscribeResponse
// {
// Orders = new List<Order> { order }
// }));
//}
//if (ClientsCollection.Get(session).Subscriptions.OrderHistory)
//{
// session.Send(JsonSerializeHelper.Serialize(new OrderHistorySubscribeResponse
// {
// Orders = new List<Order>{ order }
// }));
//}
//if (ClientsCollection.Get(session).Subscriptions.AccountInfo)
//{
// session.Send(JsonSerializeHelper.Serialize(new AccountInfoSubscribeResponse
// {
// AccountData = client.AccountInfo
// }));
//}
sendSubcriptionNotification(session, client, order);
}
break;
}
case "OpenOrdersGetRequest":
{
if (!client.IsLoggedIn)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request")));
return;
}
var request = JsonSerializeHelper.Deserialize <OpenOrdersGetRequest>(m);
var response = new OpenOrdersGetResponse
{
ReqID = request.ReqID,
Orders = DataProvider.GetOpenOrders(client.AccountInfo)
};
session.Send(JsonSerializeHelper.Serialize(response));
break;
}
case "OpenOrdersSubscribeRequest":
{
if (!client.IsLoggedIn)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request")));
return;
}
var request = JsonSerializeHelper.Deserialize <OpenOrdersSubscribeRequest>(m);
ClientsCollection.Get(session).Subscriptions.OpenOrders = true;
break;
}
case "OpenOrdersUnsubscribeRequest":
{
if (!client.IsLoggedIn)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request")));
return;
}
var request = JsonSerializeHelper.Deserialize <OpenOrdersUnsubscribeRequest>(m);
ClientsCollection.Get(session).Subscriptions.OpenOrders = false;
break;
}
case "OrderHistoryGetRequest":
{
if (!client.IsLoggedIn)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request")));
return;
}
var request = JsonSerializeHelper.Deserialize <OrderHistoryGetRequest>(m);
var response =
new OrderHistoryGetResponse
{
ReqID = request.ReqID,
Orders = DataProvider.GetOrderHistory(client.AccountInfo)
};
session.Send(JsonSerializeHelper.Serialize(response));
break;
}
case "OrderHistorySubscribeRequest":
{
if (!client.IsLoggedIn)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request")));
return;
}
var request = JsonSerializeHelper.Deserialize <OrderHistorySubscribeRequest>(m);
ClientsCollection.Get(session).Subscriptions.OrderHistory = true;
break;
}
case "OrderHistoryUnsubscribeRequest":
{
if (!client.IsLoggedIn)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request")));
return;
}
var request = JsonSerializeHelper.Deserialize <OrderHistoryUnsubscribeRequest>(m);
ClientsCollection.Get(session).Subscriptions.OrderHistory = false;
break;
}
default:
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request")));
break;
}
}
}
catch (Exception e)
{
session.Send(JsonSerializeHelper.Serialize(new ErrorResponse("Bad request : " + e.Message)));
}
}
public void NewMessageReceived(WebSocketSession session, string message)
{
session.Close();
}
public void OnMessage(byte[] data)
{
SimplePacket packet = StreamUtils.ReadPacket(data);
lock (keepAliveSw)
if (keepAliveSw.IsRunning)
{
keepAliveSw.Restart();
}
switch (packet.Type)
{
case PacketType.WorkerInfo:
if (Status == ClientWorkerStatus.Connecting)
{
return;
}
Packets.WorkerInfo info = new Packets.WorkerInfo(packet);
System = info.System;
switch (info.Status)
{
case Packets.WorkerStatus.Error:
LastProgress = 0;
errorCallback?.Invoke(ErrorType.WorkerError);
errorCallback = null;
progressChangeCallback = null;
workCallback = null;
break;
case Packets.WorkerStatus.Working:
LastProgress = info.OkPart;
status = ClientWorkerStatus.Working;
progressChangeCallback?.Invoke(info.OkPart);
break;
}
break;
case PacketType.TaskOutput:
if (status != ClientWorkerStatus.Working)
{
return;
}
LastProgress = 0;
workCallback?.Invoke(packet.Data);
errorCallback = null;
progressChangeCallback = null;
workCallback = null;
break;
case PacketType.WorkerAuth:
if (status != ClientWorkerStatus.Connecting)
{
return;
}
Packets.WorkerAuth response = new Packets.WorkerAuth(packet);
if (!response.CheckPassword(Encoding.UTF8.GetBytes(this.info.Config["password"].Value <string>())))
{
handler.RemoveClient(session.SessionID);
session.Close();
return;
}
status = ClientWorkerStatus.None;
break;
case PacketType.Signal:
Packets.Signal signal = new Packets.Signal(packet);
if (signal.Type == Packets.SignalEnum.Abort)
{
if (status != ClientWorkerStatus.Working)
{
return;
}
LastProgress = 0;
errorCallback?.Invoke(ErrorType.TaskAbort);
errorCallback = null;
progressChangeCallback = null;
workCallback = null;
}
break;
}
}
protected override async Task Inner_Disconnect()
{
Client.Close();
}
