public void Handle(QuickFix.Message msg)
{
// 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.RejectionMsgs);
string txt = string.Empty;
if (msg.isSetField(58))
{
txt = msg.getField(58);
}
try
{
if (msg.isSetField(373))
{
string rejectReasonValue = string.Empty;
rejectReasonValue = msg.getField(373);
txt += ", " + Lookups.GetSessionRejectReason(rejectReasonValue).MessageEn;
}
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error getting reason of rejected message: {0}", ex.Message), ConsoleColor.Red, ConsoleColor.Black, false);
}
// create IResponseMessage
SystemLogger.WriteOnConsoleAsync(true, string.Format("Order Rejected, Details {0} , Reason: {1} ", msg.ToXML(), txt), ConsoleColor.Red, ConsoleColor.White, false);
}
}
private void Route(Message message)
{
try
{
string msgTypeString = message.getHeader().getField(m_msgTypeTag);
// if you can extract the key (ClOrdID here)
// then let specific processor to handle this msg by orderid
if (message.isSetField(11))
{
string orderID = message.getField(11).Split(new char[] { '-' })[0];
_router.PushMessage(orderID, message);
}
else // if not then send to next processor
{
_router.PushMessage(message);
}
//else if (msgTypeString == "9" || msgTypeString == "8")
//{
// string orderID = message.getField(11).Split(new char[] { '-' })[0];
// _router.PushMessage(orderID, message);
//}
}
catch (Exception ex)
{
_router.PushMessage(message);
SystemLogger.WriteOnConsoleAsync(true, "error while routing response: " + ex.Message, ConsoleColor.Red, ConsoleColor.Black, true);
}
}
private static void UpdateClientInternal(IReplicationResponse update)
{
//for (int i = 0; i < 10; i++)
//{
try
{
ReplicatedSessionSubscriberDetails user = null;
try
{
user = GetDetails(update.ClientKey);
}
catch (Exception inex)
{
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error UpdateClientInternal {0} , Error: {1}, Retrying to send, you will get the same error if retrial failed", update.ClientKey.ToString(), inex.Message), ConsoleColor.Red, ConsoleColor.Black, true);
user = GetDetails(new Guid(update.ClientKey.ToString()));
}
user.SessionRemoteQueue.Send(update);
//break;
//SystemLogger.WriteOnConsole(true, string.Format("Message sent of type ({0}) to client {1}", update.GetType().ToString(), update.ClientKey), ConsoleColor.Cyan, ConsoleColor.Black, false);
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error UpdateClientInternal: {0}", ex.Message), ConsoleColor.Red, ConsoleColor.Black, true);
}
// }
}
internal static void ReplicateFixMessage(QuickFix.Message msg)
{
try
{
lock (m_LockedObj)
{
string msgTypeString = msg.getHeader().getField(m_msgTypeTag);
Guid[] subscribersKeys = GetFixMsgSubscribers(msgTypeString);
if (subscribersKeys != null && subscribersKeys.Length > 0)
{
foreach (Guid key in subscribersKeys)
{
PushUpdates(new IReplicationResponse[] { new ReplicatedFixMsg()
{
ClientKey = key, FixMessage = msg.ToString(), ResponseDateTime = DateTime.Now, FixVersion = msg.getHeader().getField(m_fixMsgVersionTag)
} });
}
}
}
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, string.Format("ReplicateFixMessage, Error: {0} ", ex.Message), ConsoleColor.Red, ConsoleColor.Black, true);
}
}
internal static void RouteFixMessageToClient(string sessionCode, string ordID, Message message)
{
try
{
// get fix client session by registered ClientAllocID
// overwrite sender and target with clients data
// overwrite ClientAllocId (Tag 11)
// route to client
lock (_lockObj)
{
if (!_sessionCode_sessionDetails.ContainsKey(sessionCode))
{
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error routing fix msg! Session {0} not found!", sessionCode), ConsoleColor.Red, ConsoleColor.White, false);
return;
}
// get rep session except the session that need it as a reply
SessionID session = _sessionCode_sessionDetails[sessionCode].Session;
message.removeField(49);
message.removeField(56);
message.removeField(34);
message.removeField(10);
SystemLogger.WriteOnConsoleAsync(true, string.Format("Routing Fix Message To Client {0}", session.ToString()), ConsoleColor.Blue, ConsoleColor.White, false);
Session.sendToTarget(message, session);
Replicate(message, sessionCode);
}
}
catch (Exception ex)
{
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error routing fix msg ClientAllocID {0} : {1}", ordID, ex.ToString()), ConsoleColor.Red, ConsoleColor.Black, true);
}
}
public static void InitializeServer(string settingsPath)
{
try
{
_targetCompID_SessionCode = new Dictionary <string, string>();
_sessionCode_sessionDetails = new Dictionary <string, SessionInfo>();
_sessionID_sessionCode = new Dictionary <string, string>();
_sessionsCodesToRep = new List <string>();
using (DataLayer.DatabaseMethods db = new DataLayer.DatabaseMethods())
{
foreach (DataRow row in db.GetTable("FixSessionCode").Rows)
{
string targetCompID = row["TargetCompID"].ToString();
string code = row["Code"].ToString();
bool isRep = Convert.ToBoolean(row["IsRep"]);
_targetCompID_SessionCode.Add(targetCompID, code);
if (isRep)
{
_sessionsCodesToRep.Add(code);
}
}
}
SessionSettings settings = new SessionSettings(settingsPath);
_acceptor = new SocketAcceptor(new SvcFixServer(), new FileStoreFactory(settings), settings, new FileLogFactory(settings), new DefaultMessageFactory());
_acceptor.start();
SystemLogger.WriteOnConsoleAsync(true, string.Format("Fix Server Started Up !"), ConsoleColor.Green, ConsoleColor.Black, false);
}
catch (Exception e)
{
SystemLogger.WriteOnConsoleAsync(true, string.Format("InitializeServer Error, Error {0}", e.ToString()), ConsoleColor.Red, ConsoleColor.Black, true);
}
}
internal static void Replicate(Message message, string exceptSessionCode = null)
{
List <string> repSessionCodes = null;
if (exceptSessionCode != null)
{
repSessionCodes = _sessionsCodesToRep.Where(y => y != exceptSessionCode).ToList();
}
else
{
repSessionCodes = _sessionsCodesToRep.ToList();// new instance
}
repSessionCodes.ForEach(code =>
{
SessionID session = _sessionCode_sessionDetails[code].Session;
message.removeField(49);
message.removeField(56);
message.removeField(34);
message.removeField(10);
SystemLogger.WriteOnConsoleAsync(true, string.Format("Replicating Fix Message To Client {0}", session.ToString()), ConsoleColor.Blue, ConsoleColor.White, false);
Session.sendToTarget(message, session);
});
repSessionCodes.Clear();
repSessionCodes = null;
}
public void onLogon(SessionID sessionID)
{
_senderCompID = sessionID.getSenderCompID();
_targetCompID = sessionID.getTargetCompID();
_FixSessionStatusChangedDelegate(Beltone.Services.Fix.Entities.FixSessionStatus.Connected);
SystemLogger.WriteOnConsoleAsync(true, "Logged In: session id " + sessionID.ToString(), ConsoleColor.Green, ConsoleColor.Yellow, false);
}
public void onLogon(QuickFix.SessionID value)
{
//_loggedOn = true;
_sessionID = value;
SystemLogger.WriteOnConsoleAsync(true, "Client Logged In" + value.ToString(), ConsoleColor.Green, ConsoleColor.Yellow, false);
//Console.WriteLine("OnLogon" + value.toString());
}
private void HandleUpdatedAllocation(AllocRes msg)
{
// update might be new,increase or decrease update
// search order
SingleOrder foundOrd = OrdersManager.GetOrder(msg.ReqID);
if (foundOrd == null)
{
SystemLogger.WriteOnConsoleAsync(true, string.Format("Allocation Response not handled because Order ReqID [{0}] not found!"), ConsoleColor.Red, ConsoleColor.White, false);
return;
}
lock (foundOrd)
{
// check status
// switch btw
// if PendingNew then send new order
string actionOnAllocResponse = foundOrd.Data[SingleOrderProperties.ActionOnAllocResponse].ToString();
switch (actionOnAllocResponse)
{
case ActionOnAllocResponse.SendNewOrder:
OrdersManager.HandleAllocationNewOrderAccepted(foundOrd, Fix.Entities.McsdSourceMessage.McsdAccepted);
break;
case ActionOnAllocResponse.ModifyOrder:
OrdersManager.HandleAllocationUpdateOrderAccepted(foundOrd, Fix.Entities.McsdSourceMessage.McsdAccepted);
break;
case ActionOnAllocResponse.CancelOrder:
OrdersManager.HandleAllocationCancelOrderAccepted(foundOrd);
break;
case ActionOnAllocResponse.DoNothing:
SystemLogger.WriteOnConsoleAsync(true, string.Format("Do nothing Allocation Response not handled ReqID [{0}] ResponseType is {1}", msg.ReqID, msg.ResType), ConsoleColor.Red, ConsoleColor.White, false);
break;
default:
SystemLogger.WriteOnConsoleAsync(true, string.Format("Allocation Response not handled ReqID [{0}] ResponseType is {1} ", msg.ReqID, msg.ResType), ConsoleColor.Red, ConsoleColor.White, false);
break;
}
//if (status == ORD_STATUS.PendingNew)
// OrdersManager.HandleAllocationNewOrderAccepted(foundOrd, Fix.Entities.McsdSourceMessage.McsdAccepted);
//else if (status == ORD_STATUS.Canceled)
// OrdersManager.HandleAllocationCancelOrderAccepted(foundOrd);
//else if (isActive)
// OrdersManager.HandleAllocationUpdateOrderAccepted(foundOrd, Fix.Entities.McsdSourceMessage.McsdAccepted);
//else
// SystemLogger.WriteOnConsoleAsync(true, string.Format("Allocation Response not handled ReqID [{0}] status [{1}] IsActive [{2}]", msg.ReqID, status, isActive), ConsoleColor.Red, ConsoleColor.White, false);
}
}
private static void CheckCallbacksAlive()
{
lock (m_LockedObj)
{
List <Guid> callbacksToDelete = new List <Guid>();
foreach (KeyValuePair <Guid, ReplicatedSessionSubscriberDetails> callback in m_sessions)
{
// remove who didnt response for configured time
TimeSpan diff = callback.Value.LastHeartBeatResponse > callback.Value.LastHeartBeatRequest ? callback.Value.LastHeartBeatResponse - callback.Value.LastHeartBeatRequest : callback.Value.LastHeartBeatRequest - callback.Value.LastHeartBeatResponse;
if (diff.TotalMilliseconds > m_SessionReqResHeartBeatDiffInMilliSec)
{
callbacksToDelete.Add(callback.Key);
}
// now check the callbacks alive
if (!callbacksToDelete.Contains(callback.Key))
{
try
{
callback.Value.SessionRemoteQueue.Send(new ReplicationSessionAreYouAlive()
{
ClientKey = callback.Key, ResponseDateTime = DateTime.Now
});
callback.Value.LastHeartBeatRequest = DateTime.Now;
}
catch (Exception ex)
{
callback.Value.LastHeartBeatRequest = DateTime.Now;
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error sending HeartBeat to callback : {0}, Error: {1}", callback.Key, ex.Message), ConsoleColor.Red, ConsoleColor.Black, true);
}
}
}
if (callbacksToDelete.Count > 0)
{
foreach (Guid callbackKey in callbacksToDelete)
{
RemoveCallback(callbackKey);
SystemLogger.WriteOnConsoleAsync(true, "replication session removed " + callbackKey.ToString(), ConsoleColor.Magenta, ConsoleColor.Black, false);
}
}
}
//lock (m_callbacks)
//{
// foreach (IETF_Callback callback in m_callbacks.Values.Select(b => b.Callback))
// {
// ICommunicationObject commObj = callback as ICommunicationObject;
// if (commObj != null && (commObj.State == CommunicationState.Closed || commObj.State == CommunicationState.Faulted))
// {
// // Code to remove callback channel from any internal lists you might have, other processing
// }
// }
//}
}
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);
}
}
public void Handle(QuickFix.Message msg)
{
// check message type tag
QuickFix.MsgType msgType = new QuickFix.MsgType();
string msgTypeString = msg.getHeader().getField(m_msgTypeTag);
if (msgTypeString == m_MsgTypeTagValueToHandle)
{
SystemLogger.WriteOnConsoleAsync(true, string.Format("new message recieved, Type: {0}, Message: '{1}'", msgTypeString, msg.ToXML()), ConsoleColor.Cyan, ConsoleColor.Black, false);
// create IResponseMessage
}
}
private static void OnClientUpdate(IAsyncResult res)
{
try
{
m_iReplicatedMessageDelegate.EndInvoke(res);
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error OnClientUpdate: {0}", ex.Message), ConsoleColor.Cyan, ConsoleColor.Black, false);
}
}
public void Handle(QuickFix.Message msg)
{
// 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.BusinessRejectRspMsgs);
SystemLogger.WriteOnConsoleAsync(true, string.Format("new message recieved, Type: {0}, Message: '{1}'", msgTypeString, msg.ToXML()), ConsoleColor.Cyan, ConsoleColor.Black, false);
// create IResponseMessage
}
}
static void sh_Closed(object sender, EventArgs e)
{
try
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
string[] cc = SystemConfigurations.GetAppSetting("SupportMailCC").Split(',');
NotificationSender.Send(true, true, false, SystemConfigurations.GetAppSetting("SupportMailFrom"), SystemConfigurations.GetAppSetting("SupportMailTo"), cc, "Fix Orders Service Closed", "Fix Orders Service Closed",
string.Format("Fix Orders Service has been closed on machine {0} at {1}", SystemConfigurations.GetMachineIP(), DateTime.Now.ToString()), null);
}
catch (Exception ex)
{
SystemLogger.WriteOnConsoleAsync(true, "Sending Mail Error: " + ex.Message, ConsoleColor.Red, ConsoleColor.Black, true);
}
}
static void m_callbacksAliveChecker_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
try
{
CheckCallbacksAlive();
}
catch (Exception ex)
{
if (!m_sessionAliveChecker.Enabled)
{
m_sessionAliveChecker.Start();
}
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error m_callbacksAliveChecker_Elapsed, Error: {0}", ex.Message), ConsoleColor.Red, ConsoleColor.Black, true);
}
}
public void Process(object msg)
{
//ReplicationSessionSubscribersList.ReplicateFixMessage((QuickFix.Message)msg);
foreach (IResponseMcsdMessageHandler <AllocRes> handler in m_McsdresponseHandlers)
{
try
{
handler.Handle((AllocRes)msg);
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error handling mcsd response message of type {0}, Error: {1}", msg.GetType(), ex.ToString()), ConsoleColor.Red, ConsoleColor.Black, true);
}
}
}
private static void InitializeService()
{
AdminSvcHost = new ServiceHost(typeof(FixAdminSvc));
AdminSvcHost.Closed += new EventHandler(shAdmin_Closed);
AdminSvcHost.Faulted += new EventHandler(shAdmin_Faulted);
AdminSvcHost.Open();
SystemLogger.WriteOnConsoleAsync(true, "Admin Service started up successfully!", ConsoleColor.Green, ConsoleColor.Black, false);
OrdSvcHost = new ServiceHost(typeof(FixOrdSvc));
OrdSvcHost.Opened += new EventHandler(sh_Opened);
OrdSvcHost.Closed += new EventHandler(sh_Closed);
OrdSvcHost.Faulted += new EventHandler(sh_Faulted);
OrdSvcHost.UnknownMessageReceived += new EventHandler <UnknownMessageReceivedEventArgs>(sh_UnknownMessageReceived);
OrdSvcHost.Open();
SystemLogger.WriteOnConsoleAsync(true, "Orders Service started up successfully!", ConsoleColor.Green, ConsoleColor.Black, false);
}
private void Route(Message message)
{
// Route To WCF Client or FIX Client
try
{
// if you can extract the OrdID (Tag 11)
if (message.isSetField(11))
{
bool isWcf = true;
string[] msgArr = message.getField(11).Split(new string[] { _msgSplit }, StringSplitOptions.None);
string prefix = msgArr[0];
if (prefix == _fixPrefixCode)
{
isWcf = false;
}
//else(prefix == _wcfPrefixCode)
message.removeField(11);
if (!isWcf)
{
// Ex: F-A-101
string sessionCode = msgArr[1];
string ordID = msgArr[2];
message.setField(11, ordID);
RouteDirectFixClient(sessionCode, ordID, message);
}
else
{
// Ex: F-101
string ordID = msgArr[1];
message.setField(11, ordID);
SvcFixServer.Replicate(message);
RouteToWcfClient(ordID, message);
}
}
else // if not then send to next processor
{
_router.PushMessage(message);
}
}
catch (Exception ex)
{
//_router.PushMessage(message);
SystemLogger.WriteOnConsoleAsync(true, string.Format("error while routing response OrdIDID [{0}] : {1}", message.isSetField(11) ? message.getField(11) : "Not Found In Fix Msg", ex.Message), ConsoleColor.Red, ConsoleColor.Black, true);
}
}
public void onLogout(SessionID sessionID)
{
lock (_lockObj)
{
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///// you should keep sending the messages even if the initiator logged out, so quickfix will send the previous message in case re-logged in
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//m_sessionIDs.Remove(sessionID);
//SystemLogger.WriteOnConsoleAsync(true, string.Format("removed sessionID: {0} ", sessionID.ToString()), ConsoleColor.Magenta, ConsoleColor.Black, false);
}
SystemLogger.WriteOnConsoleAsync(true, string.Format("loggedout sessionID: {0} ", sessionID.ToString()), ConsoleColor.DarkYellow, ConsoleColor.White, false);
}
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();
}
}
}
private void ReadingPushedMsgs()
{
while (true)
{
try
{
object msg = _queue.Dequeue();
_msgProcessor.Process(msg);
}
catch (Exception ex)
{
SystemLogger.WriteOnConsoleAsync(true, "Error reading msg Error: " + ex.Message, ConsoleColor.Red, ConsoleColor.Black, true);
}
finally
{
}
}
}
public void onLogon(SessionID sessionID)
{
lock (_lockObj)
{
if (!_targetCompID_SessionCode.ContainsKey(sessionID.getTargetCompID()))
{
SystemLogger.WriteOnConsoleAsync(true, string.Format("kicked sessionID: {0} because not found in database", sessionID.ToString()), ConsoleColor.White, ConsoleColor.Red, false);
Session.lookupSession(sessionID).logout();
return;
}
//sessionID.getSenderCompID();
//FixSessions.Add(sessionID.ToString(), sessionID);
SystemLogger.WriteOnConsoleAsync(true, string.Format("loggedin sessionID: {0} ", sessionID.ToString()), ConsoleColor.DarkMagenta, ConsoleColor.White, false);
}
// test send
//SendFixMessageToAllConnections(new QuickFix44.ExecutionReport(new OrderID("324"),new ExecID("234"), new ExecType(ExecType.FILL), new OrdStatus(OrdStatus.FILLED), new Side(Side.BUY), new LeavesQty(324), new CumQty(123), new AvgPx(12)));
}
public static void BroadcastAdminMsg(IFromAdminMsg[] msgs)
{
foreach (KeyValuePair <Guid, SessionInfo> callback in _key_Session)
{
try
{
IFixAdminCallback cb = callback.Value.Callback;
if (cb == null || !callback.Value.IsOnline) // admin msgs dont need to be flushed as offline updates
{
continue;
}
cb.PushAdminMsg(msgs);
}
catch (Exception inex)
{
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error BroadcastAdminMsg , Error: {0}", inex.Message), ConsoleColor.Red, ConsoleColor.Black, true);
}
}
}
void RecievingMsgs()
{
while (true)
{
try
{
object[] msg = (object[])_routerQueue.Dequeue();
Route(msg[0], msg[1]);
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, "Reading Routed Msg Error: " + ex.Message, ConsoleColor.Red, ConsoleColor.Black, true);
}
finally
{
}
}
}
public void Process(object msg)
{
foreach (IRequestMessageHandler <IRequestMessage> handler in m_requestHandlers)
{
try
{
if (handler.Handle((IRequestMessage)msg))
{
break;
}
//SystemLogger.WriteOnConsole(true, string.Format("Couldn't find handler for message type", msg.GetType()), ConsoleColor.Red, ConsoleColor.Black, true);
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error handling request message of type {0}, Error: {1}", msg.GetType(), ex.ToString()), ConsoleColor.Red, ConsoleColor.Black, true);
}
}
}
private void HandleRejectAllocation(AllocRes msg)
{
// update might be new,increase or decrease update
// search order
SingleOrder foundOrd = OrdersManager.GetOrder(msg.ReqID);
if (foundOrd == null)
{
SystemLogger.WriteOnConsoleAsync(true, string.Format("Allocation Response not handled because Order ReqID [{0}] not found!"), ConsoleColor.Red, ConsoleColor.White, false);
return;
}
lock (foundOrd)
{
string actionOnAllocResponse = foundOrd.Data[SingleOrderProperties.ActionOnAllocResponse].ToString();
switch (actionOnAllocResponse)
{
case ActionOnAllocResponse.SendNewOrder:
OrdersManager.HandleAllocationNewOrderRefused(msg, foundOrd);
break;
case ActionOnAllocResponse.ModifyOrder:
OrdersManager.HandleAllocationUpdateOrderRefused(msg, foundOrd);
break;
case ActionOnAllocResponse.CancelOrder:
OrdersManager.HandleAllocationCancelOrderRefused(msg, foundOrd);
break;
case ActionOnAllocResponse.DoNothing:
SystemLogger.WriteOnConsoleAsync(true, string.Format("Do nothing Allocation Response not handled ReqID [{0}] ResponseType is {1}", msg.ReqID, msg.ResType), ConsoleColor.Red, ConsoleColor.White, false);
break;
default:
SystemLogger.WriteOnConsoleAsync(true, string.Format("Allocation Response not handled ReqID [{0}] ResponseType is {1} ", msg.ReqID, msg.ResType), ConsoleColor.Red, ConsoleColor.White, false);
break;
}
}
}
public void fromApp(Message message, SessionID sessionID)
{
//SystemLogger.WriteOnConsoleAsync(true, string.Format("fromApp: {0} ", message.ToString()), ConsoleColor.Green, ConsoleColor.Black, false);
//SystemLogger.LogEventAsync(string.Format("fromApp: {0} ", message.ToString()));
//crack(message, sessionID);
// extract clientAllocID
// check max char length
// prefix clientAllocID with "F" stand for "Fix Connection"
// add to current cache
// update db
// send to MCDR
try
{
lock (_lockObj)
{
if (message.isSetField(11))
{
string target = sessionID.getTargetCompID();
if (!_targetCompID_SessionCode.ContainsKey(target))
{
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error recieveing fix msg from Target {0} Not FOund! : ", target), ConsoleColor.White, ConsoleColor.Red, true);
return;
}
string msgKey = message.getField(11);
string sessionCode = _targetCompID_SessionCode[target];
string mapKey = string.Format("{0}{1}{2}{3}", _fixPrefix, sessionCode, _msgSplit, msgKey);
message.removeField(11);
message.setField(11, mapKey);
MarketFixClient.SendDirectFix(message);
}
}
}
catch (Exception ex)
{
SystemLogger.WriteOnConsoleAsync(true, "Error recieveing fix msg from Target : " + ex.ToString(), ConsoleColor.Red, ConsoleColor.Black, true);
}
}
internal static void HandleSubscriberRequest(IReplicationRequest req)
{
try
{
Type msgType = req.GetType();
if (typeof(IReplicationRequest).IsAssignableFrom(msgType))
{
if (typeof(ReplicationSessionAmAlive) == msgType)
{
ReplicationSessionAmAlive alive = (ReplicationSessionAmAlive)req;
GetDetails(alive.ClientKey).LastHeartBeatResponse = DateTime.Now;
//SystemLogger.WriteOnConsole(true, string.Format("Client {0} is alive @ {1} el7amdolelah!", alive.ClientKey, DateTime.Now), ConsoleColor.Gray, ConsoleColor.Black, false);
}
}
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error setting client LastHeartBeatResponse, Error: {0} ", ex.Message), ConsoleColor.Cyan, ConsoleColor.Black, true);
}
}
