/// <summary>
/// Sends Locate Response to OEE
/// </summary>
/// <param name="locateResponse">TradeHub LocateResponse for the Locate Message</param>
public bool SendLocateResponse(LocateResponse locateResponse)
{
try
{
if (_asyncClassLogger.IsDebugEnabled)
{
_asyncClassLogger.Debug("New locate response received: " + locateResponse, _type.FullName, "SendLocateResponse");
}
// Check if OEE-Client is connected to OEE
if (_isConnected)
{
// Send Locate Response to OEE-Server
_executionEngineClient.SendLocateResponse(locateResponse);
return(true);
}
if (_asyncClassLogger.IsDebugEnabled)
{
_asyncClassLogger.Debug("Request not sent to OEE as OEE-Client is not connected.", _type.FullName, "SendLocateResponse");
}
return(false);
}
catch (Exception exception)
{
_asyncClassLogger.Error(exception, _type.FullName, "SendLocateResponse");
return(false);
}
}
/// <summary>
/// Handles New Locate response messages from Applications
/// </summary>
/// <param name="locateResponse">TradeHub LocateResponse</param>
/// <param name="appId">Unique Application ID</param>
public void LocateResponseReceived(LocateResponse locateResponse, string appId)
{
try
{
if (Logger.IsInfoEnabled)
{
Logger.Info(
"Locate Response received from: " + appId + " for: " + locateResponse.OrderExecutionProvider,
_type.FullName, "LocateResponseReceived");
}
IOrderExecutionProvider orderExecutionProvider;
if (_providersMap.TryGetValue(locateResponse.OrderExecutionProvider, out orderExecutionProvider))
{
// Send Locate Response to Execution Provider
orderExecutionProvider.LocateMessageResponse(locateResponse);
}
else
{
if (Logger.IsInfoEnabled)
{
Logger.Info(
"Order Execution Provider module not available for: " + locateResponse.OrderExecutionProvider,
_type.FullName, "LocateResponseReceived");
}
}
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "LocateResponseReceived");
}
}
/// <summary>
/// Sends Locate message Accepted/Rejected response to Broker
/// </summary>
/// <param name="locateResponse"> </param>
/// <returns></returns>
public bool LocateMessageResponse(LocateResponse locateResponse)
{
try
{
return(true);
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "LocateMessageResponse");
return(false);
}
}
/// <summary>
/// Sends Locate Response to the Order Execution Engine
/// </summary>
/// <param name="locateResponse">TradeHub Locate Response object</param>
public void SendLocateResponse(LocateResponse locateResponse)
{
try
{
// Add Unique Application level ID to help identify the application from which the LocateResponse is generated
locateResponse.StrategyId = _appId + "|" + locateResponse.OrderId;
if (_asyncClassLogger.IsDebugEnabled)
{
_asyncClassLogger.Debug("Sending locate response: " + locateResponse, _type.FullName, "SendLocateResponse");
}
// Send message though the Mq Server
_mqServer.SendLocateResponse(locateResponse);
}
catch (Exception exception)
{
_asyncClassLogger.Error(exception, _type.FullName, "SendCancelOrderRequest");
}
}
/// <summary>
/// Sends Locate message Accepted/Rejected response to Broker
/// </summary>
/// <param name="locateResponse">TradeHub LocateResponse containing Acceptence/Rejection Info</param>
/// <returns></returns>
public bool LocateMessageResponse(LocateResponse locateResponse)
{
try
{
// Check whether the Order Execution session is connected or not
if (IsConnected())
{
BWOrder locateMsg;
if (_locateOrders.TryRemove(locateResponse.OrderId, out locateMsg))
{
if (locateResponse.Accepted)
{
_locateOrdersToLocalIdsMap.AddOrUpdate(locateMsg.Symbol, locateResponse.StrategyId,
(key, value) => locateResponse.StrategyId);
// Accept Locate Message
locateMsg.AcceptLocate();
if (Logger.IsInfoEnabled)
{
Logger.Info("Accepted locate message: " + locateMsg.ToString(), _type.FullName, "LocateMessageResponse");
}
return(true);
}
else
{
if (Logger.IsInfoEnabled)
{
Logger.Info("Rejected locate message: " + locateMsg.ToString(), _type.FullName, "LocateMessageResponse");
}
return(true);
}
}
}
return(false);
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "LocateMessageResponse");
return(false);
}
}
/// <summary>
/// Sends Locate message Accepted/Rejected response to Broker
/// </summary>
/// <param name="locateResponse"> </param>
/// <returns></returns>
public bool LocateMessageResponse(LocateResponse locateResponse)
{
try
{
if (Logger.IsInfoEnabled)
{
Logger.Info("Locate Response received: " + locateResponse, _type.FullName, "LocateMessageResponse");
}
LimitOrder locateMsg;
if (_locateOrders.TryRemove(locateResponse.OrderId, out locateMsg))
{
if (locateResponse.Accepted)
{
_locateOrdersToLocalIdsMap.AddOrUpdate(locateMsg.Security.Symbol, locateResponse.StrategyId,
(key, value) => locateResponse.StrategyId);
if (Logger.IsInfoEnabled)
{
Logger.Info("Accepted locate message: " + locateMsg.ToString(), _type.FullName, "LocateMessageResponse");
}
return(true);
}
else
{
if (Logger.IsInfoEnabled)
{
Logger.Info("Rejected locate message: " + locateMsg.ToString(), _type.FullName, "LocateMessageResponse");
}
return(true);
}
}
return(true);
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "LocateMessageResponse");
return(false);
}
}
/// <summary>
/// Called when LocateMessage is received from OEE
/// </summary>
/// <param name="locateMessage">TradeHub LimitOrder containing details for the LocateMessage</param>
public override void OnLocateMessageArrived(LimitOrder locateMessage)
{
try
{
ConsoleWriter.WriteLine(ConsoleColor.Green, "Locate messaeg received : " + locateMessage);
if (Logger.IsInfoEnabled)
{
Logger.Info("Locate messaeg received : " + locateMessage, _type.FullName, "OnLocateMessageArrived");
}
// Create LocateRespone object
LocateResponse locateResponse = new LocateResponse(locateMessage.OrderID, _orderExecutionProvider, true);
// Sends Locate Response to OEP
SendLocateResponse(locateResponse);
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "OnLocateMessageArrived");
}
}
public bool LocateMessageResponse(LocateResponse locateResponse)
{
throw new NotImplementedException();
}
public bool LocateMessageResponse(LocateResponse locateResponse)
{
//not provided by Tradier
throw new NotImplementedException();
}
public void LocateMessageTestCase()
{
bool logonArrived = false;
bool logoutArrived = false;
bool connected = false;
bool locateArrived = false;
ManualResetEvent manualLogonEvent = new ManualResetEvent(false);
ManualResetEvent manualLogoutEvent = new ManualResetEvent(false);
ManualResetEvent manualConnectedEvent = new ManualResetEvent(false);
ManualResetEvent manualLocateEvent = new ManualResetEvent(false);
_executionEngineClient.ServerConnected += delegate()
{
connected = true;
_executionEngineClient.SendLoginRequest(new Login()
{
OrderExecutionProvider = TradeHubConstants.OrderExecutionProvider.Simulated
});
manualConnectedEvent.Set();
};
_executionEngineClient.LogonArrived +=
delegate(string obj)
{
logonArrived = true;
manualLogonEvent.Set();
};
_executionEngineClient.LocateMessageArrived +=
delegate(LimitOrder obj)
{
locateArrived = true;
LocateResponse locateResponse = new LocateResponse(obj.OrderID, TradeHubConstants.OrderExecutionProvider.Simulated, true);
_executionEngineClient.SendLocateResponse(locateResponse);
_executionEngineClient.SendLogoutRequest(new Logout {
OrderExecutionProvider = TradeHubConstants.OrderExecutionProvider.Simulated
});
manualLocateEvent.Set();
};
_executionEngineClient.LogoutArrived +=
delegate(string obj)
{
logoutArrived = true;
manualLogoutEvent.Set();
};
_executionEngineClient.Start();
manualConnectedEvent.WaitOne(30000, false);
manualLogonEvent.WaitOne(30000, false);
manualLocateEvent.WaitOne(30000, false);
manualLogoutEvent.WaitOne(30000, false);
Thread.Sleep(1000);
Assert.AreEqual(true, logonArrived, "Logon Arrived");
Assert.AreEqual(true, locateArrived, "Locate Arrived");
Assert.AreEqual(true, logoutArrived, "Logout Arrived");
}
