private static void OnIncomingMsg(IMcdrFromAdmin[] msgs) { try { foreach (var msg in msgs) { if (msg is McdrSessionUp) { try { _clientSessionKey = ((McdrSessionUp)msg).SessionKey; _IsMcsdSessionUp = true; } catch (Exception ex) { Console.WriteLine(ex.ToString()); } } } } catch (Exception exp) { SystemLogger.LogErrorAsync("Failed to handle received MCSD from Admin Message . Error : " + exp.ToString()); } }
public void Handle(AllocRes msg) { if (msg != null) { switch (msg.ResType) { case ALLOC_RES_TYPES.ALLOC_ACCEPTED_RES: case ALLOC_RES_TYPES.ALLOC_UPDATED_RES: HandleUpdatedAllocation(msg); break; case ALLOC_RES_TYPES.ALLOC_REFUSED_RES: case ALLOC_RES_TYPES.ALLOC_UPDATE_REFUSED_RES: HandleRejectAllocation(msg); break; default: // log here. SystemLogger.LogErrorAsync(string.Format("Unhandled message type received from MCSD : ", msg.ResType)); break; } } }
//timer to check connectivity with MCSD should be added to establish connection with MCSD if it went down during the session. #endregion #region Constructor #endregion #region private members private static void InitializeDeclerations() { try { m_MCSDresponseQueueIP = SystemConfigurations.GetAppSetting("MCSDresponseQueueIP"); m_MCSDresponseQueueName = SystemConfigurations.GetAppSetting("MCSDresponseQueueName"); m_MCSDUserName = SystemConfigurations.GetAppSetting("MCSD_UserName"); m_MCSD_Password = SystemConfigurations.GetAppSetting("MCSD_Password"); m_OverrideMCSDQueue = Boolean.Parse(SystemConfigurations.GetAppSetting("OverrideMCSDQueue")); m_FlushMCSDUpdatesOffline = Boolean.Parse(SystemConfigurations.GetAppSetting("FlushMCSDUpdatesOffline")); _McsdServicePingIntervals = int.Parse(SystemConfigurations.GetAppSetting("McsdServicePingIntervals")); m_IncomingMessageDelegate = new IMCDSCallbackHandler.IncomingMessageDelegate(OnIncomingMsg); m_callbackHandler = new IMCDSCallbackHandler(m_IncomingMessageDelegate); m_InstanceContext = new InstanceContext(m_callbackHandler); m_factory = new DuplexChannelFactory <IMcdrAdmin>(m_InstanceContext, "netTcpBinding_IMcdrAdmin"); subRequest = new MCDR.Contract.Entities.ToAdmin.subReq(); } catch (Exception exp) { SystemLogger.LogErrorAsync("MCSDManager Constructor Error: " + exp.ToString()); } }
private static void Unsubscribe() { try { m_clientMcsd.Unsubscribe(); } catch (Exception exp) { SystemLogger.LogErrorAsync("Unsubscribtion from MCSD Service Failed. Error : " + exp.ToString()); SystemLogger.WriteOnConsoleAsync(true, "Unsubscribtion from MCSD Service Failed. Error : " + exp.ToString(), ConsoleColor.Red, ConsoleColor.Black, true); } }
private static void PingMCSDService() { try { while (_IsPingToMcsdStarted) { m_clientMcsd.Ping(); System.Threading.Thread.Sleep(_McsdServicePingIntervals); } } catch (Exception exp) { SystemLogger.LogErrorAsync("Pinging MCSD Service Failed. Error : " + exp.ToString()); } }
private static void HandleReceivedMSCDMessages() { MessageQueue m_msgSenderQueue = new MessageQueue(string.Format(@"Formatname:DIRECT=TCP:{0}\private$\{1}", m_MCSDresponseQueueIP, m_MCSDresponseQueueName)); XmlMessageFormatter formatter = new XmlMessageFormatter(new Type[] { typeof(McdrTestReq), typeof(AllocRes) }); while (true) { try { System.Messaging.Message msg = (System.Messaging.Message)m_msgSenderQueue.Receive(); if (msg == null) { continue; } object recievedMsg = formatter.Read(msg); if (recievedMsg.GetType() == typeof(McdrTestReq)) { try { IMcdrToAdmin msgTo = new McdrTestRes() { TestKey = ((McdrTestReq)recievedMsg).TestKey }; m_clientMcsd.HandleMsg(msgTo); } catch (Exception ex) { Console.Write(ex.ToString()); } } else if (recievedMsg.GetType() == typeof(AllocRes)) { AllocRes respMsg = (AllocRes)recievedMsg; m_mcsdRouter.PushMessage(respMsg); } } catch (Exception exp) { SystemLogger.LogErrorAsync("Error while handling MCSD Message. Error : " + exp.ToString()); continue; } } }
static void MCSDManager_Closed(object sender, EventArgs e) { try { _IsMcsdSessionUp = false; SystemLogger.LogErrorAsync("MCSD Session Closed"); } catch (Exception exp) { SystemLogger.LogErrorAsync(exp.ToString()); } finally { // try to connect again. //Subscribe(); taskReSubscribe = new Thread(new ThreadStart(Subscribe)); taskReSubscribe.IsBackground = true; taskReSubscribe.Start(); } }
public void Handle(QuickFix.Message msg) { long orderID = -1; // check message type tag, if execution report then push execution report update QuickFix.MsgType msgType = new QuickFix.MsgType(); string msgTypeString = msg.getHeader().getField(m_msgTypeTag); if (msgTypeString == m_MsgTypeTagValueToHandle) { Counters.IncrementCounter(CountersConstants.OrderCancelRejectRspMsgs); //SystemLogger.WriteOnConsole(true, string.Format("new message recieved, Type: {0}, Message: '{1}'", msgTypeString, msg.ToXML()), ConsoleColor.Cyan, ConsoleColor.Black, false); SingleOrder order = null; // get order id if (msg.isSetField(11)) { orderID = long.Parse(msg.getField(11).Split(new char[] { '-' })[0]); try { order = OrdersManager.GetOrder(orderID); } catch (Exception ex) // order not found { // get borse order id string bourseOrderID = msg.getField(37); order = OrdersManager.GetOrder(bourseOrderID); if (order == null) { SystemLogger.WriteOnConsoleAsync(true, string.Format("order BourseOrderID {0} not found !", bourseOrderID), ConsoleColor.Red, ConsoleColor.Black, true); return; } } } // then search by borse order id else if (msg.isSetField(37)) { string bourseOrderID = msg.getField(37); order = OrdersManager.GetOrder(bourseOrderID); if (order == null) { SystemLogger.WriteOnConsoleAsync(true, string.Format("order BourseOrderID {0} not found !", bourseOrderID), ConsoleColor.Red, ConsoleColor.Black, true); return; } } lock (order) { string reason = string.Empty; if (msg.isSetField(102)) { try { reason = Lookups.GetOrderCancelRejectReasonsLookup(msg.getField(102)).MessageEn + " ,"; } catch (Exception ex) { Counters.IncrementCounter(CountersConstants.ExceptionMessages); SystemLogger.WriteOnConsoleAsync(true, string.Format("Error getting order cancel reject reason: {0}", ex.Message), ConsoleColor.Red, ConsoleColor.Black, false); } } if (msg.isSetField(58)) { reason += msg.getField(58) + " "; } Nullable <DateTime> transactionDateTime = null; if (msg.isSetField(60)) { transactionDateTime = msg.getUtcTimeStamp(60); } LookupItem statusLookup = Lookups.GetOrderStatusLookup(msg.getField(39)); string status = statusLookup.CodeValue; Guid requesterOrderID = (Guid)order[SingleOrderProperties.RequesterOrderID]; // find subscribed callbacks //order[SingleOrderProperties.OrderStatus] = status; bool isPendingCancel = false; bool isPendingReplace = false; string orderNote = string.Empty; if (order[SingleOrderProperties.OrderStatus].ToString() == ORD_STATUS.PendingCancel) { isPendingCancel = true; orderNote = "Order cancel has been refused by bourse: " + reason; } else if (order[SingleOrderProperties.OrderStatus].ToString() == ORD_STATUS.PendingReplace) { // handle diff allocation cancellation isPendingReplace = true; orderNote = "Order replace has been refused by bourse: " + reason; #region Handle Mcsd Reset Allocation try { if (order[SingleOrderProperties.IsMcsdAllocRequired] != null) { if (Convert.ToBoolean(order[SingleOrderProperties.IsMcsdAllocRequired]) == true) { order[SingleOrderProperties.ActionOnAllocResponse] = ActionOnAllocResponse.DoNothing; int mcsdQty = Convert.ToInt32(order[SingleOrderProperties.McsdrAllocQty]); // orderid = Convert.ToInt64(order[SingleOrderProperties.OrderID]); OrdersManager.HandleRejectedOrderAllocation(orderID, mcsdQty); } } } catch (Exception exp) { Counters.IncrementCounter(CountersConstants.ExceptionMessages); SystemLogger.LogErrorAsync(string.Format("Error, Reset MCSD allocation of Order {0}, Error : {1}", orderID, exp.ToString())); } #endregion } else { orderNote = "Order cancel/replace has been refused by bourse: " + reason; } // create IResponseMessage string username = OrdersManager.GetOrdSessionIfAvailable((long)order[SingleOrderProperties.OrderID]); if (username != null) { try { if (isPendingCancel) { Sessions.Push(username, new IResponseMessage[] { new Fix_OrderCancelRejected() { Message = reason, RequesterOrderID = requesterOrderID, OrderStatus = order[SingleOrderProperties.OriginalOrderStatus].ToString() } }); } else if (isPendingReplace) { Sessions.Push(username, new IResponseMessage[] { new Fix_OrderReplaceRejected() { Message = reason, RequesterOrderID = requesterOrderID, OrderStatus = order[SingleOrderProperties.OriginalOrderStatus].ToString() } }); } else { Sessions.Push(username, new IResponseMessage[] { new Fix_OrderReplaceCancelReject() { Message = reason, RequesterOrderID = requesterOrderID, OrderStatus = order[SingleOrderProperties.OriginalOrderStatus].ToString() } }); } } catch (Exception ex) { Counters.IncrementCounter(CountersConstants.ExceptionMessages); SystemLogger.WriteOnConsoleAsync(true, string.Format("error sending order cancel reject to clients: {0}", ex.Message), ConsoleColor.Red, ConsoleColor.Black, true); } } // update databse try { DatabaseMethods db = new DatabaseMethods(); order[SingleOrderProperties.OrderStatus] = order[SingleOrderProperties.OriginalOrderStatus]; order[SingleOrderProperties.IsPending] = false; order[SingleOrderProperties.Note] = order[SingleOrderProperties.Note2] = "Action Status: " + status; order[SingleOrderProperties.ModifiedDateTime] = transactionDateTime == null ? DateTime.Now : transactionDateTime; Dictionary <string, object> orders_Columns = new Dictionary <string, object>(); orders_Columns.Add(SingleOrderProperties.OrderStatus, order[SingleOrderProperties.OriginalOrderStatus]); orders_Columns.Add(SingleOrderProperties.Note, order[SingleOrderProperties.Note]); orders_Columns.Add(SingleOrderProperties.Note2, order[SingleOrderProperties.Note2]); orders_Columns.Add(SingleOrderProperties.ActionOnAllocResponse, ActionOnAllocResponse.DoNothing); orders_Columns.Add(SingleOrderProperties.ModifiedDateTime, transactionDateTime == null ? DateTime.Now : transactionDateTime); orders_Columns.Add(SingleOrderProperties.IsPending, false); Dictionary <string, object> orders_Filters = new Dictionary <string, object>(); orders_Filters.Add(SingleOrderProperties.OrderID, order[SingleOrderProperties.OrderID]); Dictionary <string, object> ordersDetails_Columns = new Dictionary <string, object>(); ordersDetails_Columns.Add(SingleOrdDetailsProps.OrderID, order[SingleOrderProperties.OrderID]); ordersDetails_Columns.Add(SingleOrdDetailsProps.ClOrderID, order[SingleOrderProperties.ClOrderID]); ordersDetails_Columns.Add(SingleOrdDetailsProps.OrigClOrdID, order[SingleOrderProperties.OrigClOrdID]); ordersDetails_Columns.Add(SingleOrdDetailsProps.ExecutionMsgType, msgTypeString); ordersDetails_Columns.Add(SingleOrdDetailsProps.AvgPrice, order[SingleOrderProperties.AvgPrice]); ordersDetails_Columns.Add(SingleOrdDetailsProps.CurrentPrice, order[SingleOrderProperties.CurrentPrice]); ordersDetails_Columns.Add(SingleOrdDetailsProps.ExecPrice, order[SingleOrderProperties.LastExecPrice]); ordersDetails_Columns.Add(SingleOrdDetailsProps.CurrentQuantity, order[SingleOrderProperties.CurrentQuantity]); ordersDetails_Columns.Add(SingleOrdDetailsProps.ExecutedQuantity, order[SingleOrderProperties.ExecutedQuantity]); ordersDetails_Columns.Add(SingleOrdDetailsProps.LastExecQuantity, order[SingleOrderProperties.LastExecQuantity]); ordersDetails_Columns.Add(SingleOrdDetailsProps.RemainingQuantity, order[SingleOrderProperties.RemainingQuantity]); ordersDetails_Columns.Add(SingleOrdDetailsProps.ExecType, order[SingleOrderProperties.ExecType]); ordersDetails_Columns.Add(SingleOrdDetailsProps.OrderStatus, order[SingleOrderProperties.OrderStatus]); ordersDetails_Columns.Add(SingleOrdDetailsProps.Note, order[SingleOrderProperties.Note]); ordersDetails_Columns.Add(SingleOrdDetailsProps.OrderType, order[SingleOrderProperties.OrderType]); ordersDetails_Columns.Add(SingleOrdDetailsProps.TimeInForce, order[SingleOrderProperties.TimeInForce]); ordersDetails_Columns.Add(SingleOrdDetailsProps.IsResponse, true); if (order[SingleOrderProperties.OrderStatus].ToString() == ORD_STATUS.PendingCancel) { ordersDetails_Columns.Add(SingleOrdDetailsProps.IsCancelResponse, true); } else if (order[SingleOrderProperties.OrderStatus].ToString() == ORD_STATUS.PendingReplace) { ordersDetails_Columns.Add(SingleOrdDetailsProps.IsModifyResponse, true); } else { ordersDetails_Columns.Add(SingleOrdDetailsProps.IsModifyResponse, true); ordersDetails_Columns.Add(SingleOrdDetailsProps.IsCancelResponse, true); } ordersDetails_Columns.Add(SingleOrdDetailsProps.DateTime, DateTime.Now); ordersDetails_Columns.Add(SingleOrdDetailsProps.ExecutionDate, transactionDateTime == null ? DateTime.Now : transactionDateTime); ordersDetails_Columns.Add(SingleOrdDetailsProps.ExecutionRecievedDateTime, DateTime.Now); db.UpdateOrderDetails(orders_Columns, orders_Filters, ordersDetails_Columns); db = null; } catch (Exception ex) { Counters.IncrementCounter(CountersConstants.ExceptionMessages); SystemLogger.WriteOnConsoleAsync(true, string.Format("error updating order cancel reject into the db error: {0}", ex.Message), ConsoleColor.Red, ConsoleColor.Black, true); } } } }
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); } }
public static void Initialize() { _key_Session = new Dictionary <Guid, SessionInfo>(); _username_Session = new Dictionary <string, SessionInfo>(); //m_iUpdateMessageDelegate = new IUpdateMessageDelegate(UpdateClientInternal); DateTime dtNow = DateTime.Now; FixDbEntities dbContext = new FixDbEntities(); // remove old sessions IQueryable <Session> sessionsToDelete = dbContext.Sessions.Select(s => s); foreach (Session s in sessionsToDelete) { if (s.ConnectionDateTime.Date != DateTime.Now.Date) { dbContext.SessionsHistories.Add(CreateHistory(s)); dbContext.Sessions.Remove(s); } } dbContext.SaveChanges(); // remove unsubscribed sessions IQueryable <Session> unSubSessions = dbContext.Sessions.Where(s => !s.IsSubscribed); foreach (Session s in unSubSessions) { dbContext.SessionsHistories.Add(CreateHistory(s)); dbContext.Sessions.Remove(s); } dbContext.SaveChanges(); IQueryable <Session> sessions = dbContext.Sessions.Where(s => s.IsSubscribed == true).OrderByDescending(d => d.ConnectionDateTime); foreach (Session sub in sessions) { try { // if not today subscriber or there are a double record for same session key if (_key_Session.ContainsKey(sub.SessionKey) || sub.ConnectionDateTime.Date != DateTime.Now.Date) { dbContext.SessionsHistories.Add(CreateHistory(sub)); dbContext.Sessions.Remove(sub); continue; } // make sure that you have only one record for each session sub.IsOnline = false; SessionInfo details = new SessionInfo() { SessionKey = sub.SessionKey, Callback = null, // waiting for reactivation FlushUpdatesOffline = sub.FlushUpdatesOffline, IsOnline = false, QueueMachine = sub.QueueIP, QueueName = sub.QueueName, QueuePath = sub.QueuePath, Queue = new MessageQueue(sub.QueuePath) }; Login login = dbContext.Logins.SingleOrDefault(l => l.UserName == sub.UserName); if (login == null) { continue; } details.LoginInfo = new LoginInfo() { Username = login.UserName, CanPlaceOrder = login.CanPlaceOrder, CanReplicate = login.CanReplicate }; _key_Session.Add(sub.SessionKey, details); _username_Session.Add(login.UserName, details); } catch (Exception ex) { SystemLogger.LogErrorAsync("Error while retriving subscribers from database: " + ex.ToString()); } } dbContext.SaveChanges(); _updater = new Thread(new ThreadStart(CheckEndOfSession)); _updater.IsBackground = true; _updater.Start(); }
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); } }