private static void Subscribe()
{
try
{
Console.WriteLine("Try connect to MCSDR .....");
// if(m_clientMcsd == null)
subRequest.Username = m_MCSDUserName;
subRequest.Password = m_MCSD_Password;
subRequest.QueueName = m_MCSDresponseQueueName;
subRequest.QueueIP = m_MCSDresponseQueueIP;
subRequest.FlushUpdatesOffline = false;
m_clientMcsd = m_factory.CreateChannel();
adminMsg = m_clientMcsd.Subscribe(subRequest);
_IsMcsdSessionUp = true;
((ICommunicationObject)m_clientMcsd).Closed += MCSDManager_Closed;
((ICommunicationObject)m_clientMcsd).Faulted += MCSDManager_Faulted;
((ICommunicationObject)m_clientMcsd).Opened += McsdGatwayManager_Opened;
SystemLogger.LogEventAsync("Connected to MCSD successfully !");
SystemLogger.WriteOnConsoleAsync(true, "Connected to MCSD successfully !", ConsoleColor.Green, ConsoleColor.Black, false);
}
catch (Exception exp)
{
//SystemLogger.LogErrorAsync("Subscribtion to MCSD Service Failed. Error : " + exp.ToString());
SystemLogger.WriteOnConsoleAsync(true, "Subscribtion to MCSD Service Failed. Error : " + exp.Message, ConsoleColor.Red, ConsoleColor.Black, false);
}
finally
{
if (_IsMcsdSessionUp == false)
{
System.Threading.Thread.Sleep(3000);
Subscribe();
}
}
}
public static void Push(string username, IFromAdminMsg[] msgs)
{
try
{
if (!_username_Session.ContainsKey(username))
{
return;
}
SessionInfo session = _username_Session[username];
if (session.Callback != null && session.IsOnline)
{
session.Callback.PushAdminMsg(msgs);
}
}
catch (Exception inEx)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.LogEventAsync(string.Format("Error sending admin msg to session {0}, Error: {1}", username, inEx.Message));
}
}
public bool Handle(IRequestMessage msg)
{
Type msgType = msg.GetType();
if (typeof(IRequestMessage).IsAssignableFrom(msgType))
{
if (typeof(CancelSingleOrder) == msgType)
{
CancelSingleOrder cancelOrder = (CancelSingleOrder)msg;
if (cancelOrder.ClientKey == Guid.Empty || cancelOrder.ClientKey == null)
{
SystemLogger.LogEventAsync(string.Format("ClientKey[0] not valid! ", cancelOrder.ClientKey.ToString()));
return(true);
}
string username = Sessions.GetUsername(cancelOrder.ClientKey);
if (!Sessions.IsSubscribedToSendMsg(username))
{
SystemLogger.LogEventAsync(string.Format("ClientKey not subscribed", cancelOrder.ClientKey));
return(true);
}
SingleOrder order = OrdersManager.GetOrder(cancelOrder.RequesterOrderID);
if (order == null)
{
Sessions.Push(Sessions.GetUsername(cancelOrder.ClientKey), new IResponseMessage[] { new Fix_OrderCancelRefusedByService()
{
ClientKey = cancelOrder.ClientKey, Message = "order not found", RequesterOrderID = cancelOrder.RequesterOrderID, OrderStatus = "Order Not Found"
} });
SystemLogger.LogEventAsync(string.Format("Order Not Found RequesterID {0} ", cancelOrder.RequesterOrderID));
return(true);
}
lock (order)
{
string status = order[SingleOrderProperties.OrderStatus].ToString();
// check ispending before isactive becoz a pendingnew order might be not isactive but ispending
bool isPending, isMcsdPending = false;
isPending = Convert.ToBoolean(order[SingleOrderProperties.IsPending]);
isMcsdPending = Convert.ToBoolean(order[SingleOrderProperties.IsPendingMcsd]);
if (bool.TryParse(order[SingleOrderProperties.IsPending].ToString(), out isPending))
{
if (isPending || isMcsdPending)
{
Sessions.Push(Sessions.GetUsername(cancelOrder.ClientKey), new IResponseMessage[] { new Fix_OrderCancelRefusedByService()
{
ClientKey = cancelOrder.ClientKey, Message = !isMcsdPending ? "Order is in pending request" : "Awaiting for allocation response", RequesterOrderID = cancelOrder.RequesterOrderID, OrderStatus = status
} });
return(true);
}
}
bool isActive = false;
if (bool.TryParse(order[SingleOrderProperties.IsActive].ToString(), out isActive))
{
if (!isActive)
{
Sessions.Push(Sessions.GetUsername(cancelOrder.ClientKey), new IResponseMessage[] { new Fix_OrderCancelRefusedByService()
{
ClientKey = cancelOrder.ClientKey, Message = "Order not active anymore", RequesterOrderID = cancelOrder.RequesterOrderID, OrderStatus = status
} });
return(true);
}
}
try
{
OrdersManager.HandleCancelOrder(username, cancelOrder.ClientKey, (Guid)order[SingleOrderProperties.RequesterOrderID], (long)order[SingleOrderProperties.OrderID], msg.OptionalParam);
Counters.IncrementCounter(CountersConstants.ClientsCancelOrderReqs);
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.LogEventAsync(string.Format("Error cancelling order {0}, Error: {1}", order[SingleOrderProperties.OrderID], ex.ToString()));
}
return(true);
}
}
}
return(false);
}
public bool Handle(IRequestMessage msg)
{
try
{
Type msgType = msg.GetType();
if (typeof(IRequestMessage).IsAssignableFrom(msgType))
{
if (typeof(NewSingleOrder) == msgType)
{
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
Counters.IncrementCounter(CountersConstants.ClientsNewOrderReqs);
NewSingleOrder order = (NewSingleOrder)msg;
#region validate client key
if (order.ClientKey == Guid.Empty || order.ClientKey == null)
{
SystemLogger.LogEventAsync(string.Format("ClientKey [{0}] not valid! ", order.ClientKey.ToString()));
return(true);
}
string username = Sessions.GetUsername(order.ClientKey);
if (!Sessions.IsSubscribedToSendMsg(username))
{
SystemLogger.LogEventAsync(string.Format("ClientKey [{0}] not subscribed", order.ClientKey));
return(true);
}
#endregion validate client key
#region validate stock group
Stock stock = StocksDefinitions.GetStockByCode(order.SecurityID);
if (stock == null)
{
Sessions.Push(Sessions.GetUsername(order.ClientKey), new IResponseMessage[] { new Fix_OrderRefusedByService()
{
ClientKey = order.ClientKey, RefuseMessage = "Stock Not Found!", RequesterOrderID = order.RequesterOrderID
} });
}
#endregion validate stock group
#region validate currency
CurrencyItem currency = Currencies.GetCurrencyByCode(stock.CurrencyCode);
#endregion validate currency
#region validate order details
string validation = ValidateOrder(username, order);
#endregion validate order details
#region not valid order
if (validation != "valid")
{
try
{
SystemLogger.LogEventAsync(string.Format("OrderRefusedByService RequesterOrderID: {0}, Reason: {1}", order.RequesterOrderID, validation));
Sessions.Push(Sessions.GetUsername(order.ClientKey), new IResponseMessage[] { new Fix_OrderRefusedByService()
{
ClientKey = order.ClientKey, RefuseMessage = validation, RequesterOrderID = order.RequesterOrderID
} });
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.LogEventAsync(string.Format("Error sending refused order to the client, ClientKey {0}, Error: {1}", order.ClientKey, ex.Message));
}
return(true);
}
#endregion not valid order
OrdersManager.HandleNewSingleOrder(username, order.ClientKey, order.RequesterOrderID, order.ClientID, order.CustodyID, order.SecurityID, order.OrderSide, Math.Round(order.Price, m_orderPriceDigitsRounding), order.Quantity, order.OrderType, DateTime.Now, order.TimeInForce, currency, order.ExchangeID, order.DateTime, stock.GroupID, stock.MarketID, order.HandleInst, order.ExpirationDateTime, order.OptionalParam);
sw.Stop();
SystemLogger.LogEventAsync(string.Format("new order handled in {0} ms ", sw.ElapsedMilliseconds));
sw = null;
return(true);
}
}
return(false);
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.LogErrorAsync("NewSingleOrderHandler Error: " + ex.Message);
return(true);
}
}
protected void OnStartInternally(object arguments)
{
string[] args = (string[])arguments;
try
{
/*if (!IsAdministrator())
* {
* // Restart program and run as admin
* var exeName = System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName;
* ProcessStartInfo startInfo = new ProcessStartInfo(exeName);
* startInfo.Verb = "runas";
* System.Diagnostics.Process.Start(startInfo);
* Environment.Exit(0);
* return;
* }*/
// check multiple processes
//commented by khazbak to avoid requirement to start in admin mode
/*
* if (bool.Parse(SystemConfigurations.GetAppSetting("CheckMultipleInstances")))
* {
* string currProcName = Process.GetCurrentProcess().ProcessName;
* int currProcID = Process.GetCurrentProcess().Id;
* Process[] processes = Process.GetProcessesByName(currProcName);
* if (processes.Length > 1)
* {
* foreach (Process p in processes)
* {
* if (p.Id != currProcID)
* {
* int id = p.Id;
* p.Kill();
* SystemLogger.WriteOnConsoleAsync(true, "Process has been killed ID: " + id, ConsoleColor.Gray, ConsoleColor.White, false);
* }
* }
* }
* }*/
Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory);
SystemLogger.LogEventAsync("Starting FIX Service...");
try
{
if (bool.Parse(SystemConfigurations.GetAppSetting("ReinitializeCounters")))
{
Counters.ReInitialize();
}
else
{
Counters.Initialize();
}
}
catch (Exception ex)
{
SystemLogger.WriteOnConsoleAsync(true, "Error initializing counters, Error: " + ex.ToString(), ConsoleColor.Red, ConsoleColor.Black, true);
}
DatabaseMethods db = new DatabaseMethods();
if (!db.IsTodaySequenceReset()) // reset the counters only if the service starts for first time today
{
Counters.ResetCounters();
}
// Check queue existance
if (bool.Parse(SystemConfigurations.GetAppSetting("CheckQueueExistance")))
{
CheckAndSetPermissionsToQueues();
}
FixExchangesInfo.Initialize();
Currencies.Initialize();
StocksDefinitions.Initialize();
Lookups.Initialize();
string seqFilePath = SystemConfigurations.GetAppSetting("SequenceFilePath");
if (!db.IsTodaySequenceReset())
{
SystemLogger.LogEventAsync("Resetting FIX sequence..");
db.UpdateTodaySequenceReset();
SystemLogger.LogEventAsync("Sequence reset successfully");
//try
//{
// System.IO.File.Delete(seqFilePath);
//}
//catch (Exception ex)
//{
// Counters.IncrementCounter(CountersConstants.ExceptionMessages);
// SystemLogger.WriteOnConsoleAsync(true, "Deleting Sequence File Error: " + ex.Message, ConsoleColor.Red, ConsoleColor.Black, true);
//}
}
Router responsesRouter = new Router(typeof(ResponsesProcessor), int.Parse(SystemConfigurations.GetAppSetting("ResponsesRouterProcessorsNum")));
m_FixSessionStatusChangedDelegate = new FixSessionStatusChangedDelegate(OnFixStatusChange);
bool AllowMcsdAllocation = Convert.ToBoolean(SystemConfigurations.GetAppSetting("AllowMcsdAllocation")); // maghrabi
if (AllowMcsdAllocation) //MCSD
{
Router mcsdResponsesRouter = new Router(typeof(ResponsesProcessorMcsd), int.Parse(SystemConfigurations.GetAppSetting("McsdResponsesRouterProcessorsNum")));
McsdGatwayManager.Initialize(mcsdResponsesRouter); // maghrabi
McsdGatwayManager.LoginToMCSD(); // maghrabi
}
string fixClientSettings = Environment.CurrentDirectory + @"\" + SystemConfigurations.GetAppSetting("FixClientSettingsFile");
string fixServerSettings = Environment.CurrentDirectory + @"\" + SystemConfigurations.GetAppSetting("FixServerSettingsFile");
MarketFixClient.Initialize(fixClientSettings, responsesRouter, m_FixSessionStatusChangedDelegate);
SvcFixServer.InitializeServer(fixServerSettings);
OrdersManager.Initialize();
Sessions.Initialize();
//RepSessions.Initialize();
InitializeService();
if (_resetSequenceNumber)
{
// MarketFixClient.ResetSequence();
}
MarketFixClient.Logon();
SystemLogger.WriteOnConsoleAsync(true, "Awaiting for Fix server response ...", ConsoleColor.Yellow, ConsoleColor.Black, false);
System.Windows.Forms.Application.Run(new frmMonitor()); //maghrabi
//while (true) { Console.ReadKey(); }
//StopService();
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, "Main Error: " + ex.ToString(), ConsoleColor.Red, ConsoleColor.Black, true);
try
{
string[] cc = SystemConfigurations.GetAppSetting("SupportMailCC").Split(',');
NotificationSender.Send(true, true, false, SystemConfigurations.GetAppSetting("SupportMailFrom"), SystemConfigurations.GetAppSetting("SupportMailTo"), cc, "Fix Service Down", "Fix Service Down",
string.Format("Service startup error state on machine {0} at {1}, Error : {2}", SystemConfigurations.GetMachineIP(), DateTime.Now.ToString(), ex.ToString()), null);
}
catch (Exception inex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, "Sending Mail Error: " + inex.Message, ConsoleColor.Red, ConsoleColor.Black, false);
}
//Console.ReadKey();
}
}
public bool Handle(IRequestMessage msg)
{
try
{
Type msgType = msg.GetType();
if (typeof(IRequestMessage).IsAssignableFrom(msgType))
{
if (typeof(ModifyCancelOrder) == msgType)
{
Counters.IncrementCounter(CountersConstants.ClientsReplaceOrderReqs);
ModifyCancelOrder modifyOrder = (ModifyCancelOrder)msg;
SingleOrder order = OrdersManager.GetOrder(modifyOrder.RequesterOrderID);
#region order existanse validation
if (order == null)
{
Sessions.Push(Sessions.GetUsername(modifyOrder.ClientKey), new IResponseMessage[] { new Fix_OrderReplaceRefusedByService()
{
ClientKey = modifyOrder.ClientKey, RefuseReason = "Order Not Found!", RequesterOrderID = modifyOrder.RequesterOrderID
} });
SystemLogger.LogEventAsync(string.Format("Order Not Found RequesterID {0} ", modifyOrder.RequesterOrderID));
return(true);
}
#endregion order existanse validation
lock (order)
{
#region check order activation
// check ispending before isactive becoz a pendingnew order might be not isactive but ispending
bool isPending, isMcsdPending = false;
isPending = Convert.ToBoolean(order[SingleOrderProperties.IsPending]);
isMcsdPending = Convert.ToBoolean(order[SingleOrderProperties.IsPendingMcsd]);
if (isPending || isMcsdPending)
{
Sessions.Push(Sessions.GetUsername(modifyOrder.ClientKey), new IResponseMessage[] { new Fix_OrderReplaceRefusedByService()
{
ClientKey = modifyOrder.ClientKey, RefuseReason = !isMcsdPending ? "Order is in pending request" : "Awaiting for allocation response", RequesterOrderID = modifyOrder.RequesterOrderID
} });
return(true);
}
bool isActive = false;
isActive = Convert.ToBoolean(order[SingleOrderProperties.IsActive]);
if (!isActive)
{
Sessions.Push(Sessions.GetUsername(modifyOrder.ClientKey), new IResponseMessage[] { new Fix_OrderReplaceRefusedByService()
{
ClientKey = modifyOrder.ClientKey, RefuseReason = "Order not active any more", RequesterOrderID = modifyOrder.RequesterOrderID
} });
return(true);
}
#endregion check order activation
#region order validation
// ValidateOrder
string validation = ValidateOrder(modifyOrder, order);
if (validation != "valid")
{
Sessions.Push(Sessions.GetUsername(modifyOrder.ClientKey), new IResponseMessage[] { new Fix_OrderReplaceRefusedByService()
{
ClientKey = modifyOrder.ClientKey, RefuseReason = validation, RequesterOrderID = modifyOrder.RequesterOrderID
} });
return(true);
}
#endregion order validation
// handle ClOrderID and OrigClOrdID
OrdersManager.HandleModifyOrder(Sessions.GetUsername(modifyOrder.ClientKey), modifyOrder.ClientKey, modifyOrder.RequesterOrderID, (long)order[SingleOrderProperties.OrderID], modifyOrder.Quantity, Math.Round(modifyOrder.Price, m_orderPriceDigitsRounding), modifyOrder.OrderType, modifyOrder.TimeInForce, modifyOrder.OptionalParam);
return(true);
}
}
}
return(false);
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.LogErrorAsync("ModifyCancelOrderHandler Error: " + ex.Message);
return(true);
}
}
