private void FIXRequestSessionStatus(MessageFIX4_4 packet)
{
if (packet.TradingSessionId != "TSSTATE")
{
throw new ApplicationException("Expected TSSTATE for trading session id but was: " + packet.TradingSessionId);
}
if (!packet.TradingSessionRequestId.Contains(sender) || !packet.TradingSessionRequestId.Contains(packet.Sequence.ToString()))
{
throw new ApplicationException("Expected unique trading session request id but was:" + packet.TradingSessionRequestId);
}
requestSessionStatus = true;
if (onlineNextTime)
{
ProviderSimulator.SetOrderServerOnline();
onlineNextTime = false;
}
if (ProviderSimulator.IsOrderServerOnline)
{
SendSessionStatusOnline();
}
else
{
SendSessionStatus("3");
}
onlineNextTime = true;
}
private void PositionUpdate(FIXContext context, MessageFIX4_4 packet)
{
if (packet.MessageType == "AO")
{
isPositionUpdateComplete = true;
if (debug)
{
log.Debug("PositionUpdate Complete.");
}
TryEndRecovery();
}
else
{
double position = packet.LongQuantity + packet.ShortQuantity;
SymbolInfo symbolInfo;
try {
symbolInfo = Factory.Symbol.LookupSymbol(packet.Symbol);
} catch (Exception ex) {
log.Error("Error looking up " + packet.Symbol + ": " + ex.Message);
return;
}
if (debug)
{
log.Debug("PositionUpdate: " + symbolInfo + "=" + position);
}
symbolPositionMap[symbolInfo.BinaryIdentifier] = position;
}
}
private CreateOrChangeOrder ConstructCancelOrder(MessageFIX4_4 packet, string clientOrderId)
{
if (string.IsNullOrEmpty(clientOrderId))
{
var message = "Client order id was null or empty. FIX Message is: " + packet;
log.Error(message);
throw new ApplicationException(message);
}
var symbol = Factory.Symbol.LookupSymbol(packet.Symbol);
var side = OrderSide.Buy;
var type = OrderType.None;
var logicalId = 0;
long clientId;
if (!long.TryParse(clientOrderId, out clientId))
{
log.Error("original client order id " + clientOrderId +
" cannot be converted to long: " + packet);
clientId = 0;
}
var utcCreateTime = new TimeStamp(packet.TimeStamp);
var physicalOrder = Factory.Utility.PhysicalOrder(
OrderAction.Cancel, OrderState.Active, symbol, side, type, OrderFlags.None,
0D, 0, logicalId, 0, clientId, null, utcCreateTime);
if (debug)
{
log.Debug("Received physical Order: " + physicalOrder);
}
return(physicalOrder);
}
private void CloseWithError(FIXContext context, MessageFIX4_4 packetIn, string textMessage)
{
Message message = context.LocalSocket.MessageFactory.Create();
var fixFactory = new FIXFactory4_4(1, fixSender, packetIn.Sender);
var fixMsg = (FIXMessage4_4)fixFactory.Create();
TimeStamp timeStamp = TimeStamp.UtcNow;
fixMsg.SetAccount(packetIn.Account);
fixMsg.SetText(textMessage);
fixMsg.AddHeader("j");
string errorMessage = fixMsg.ToString();
message.DataOut.Write(errorMessage.ToCharArray());
long end = Factory.Parallel.TickCount + 2000;
if (debug)
{
log.Debug("Writing Error Message: " + textMessage);
}
while (!context.LocalSocket.TrySendMessage(message))
{
if (Factory.Parallel.TickCount > end)
{
throw new ApplicationException("Timeout while sending an order.");
}
Factory.Parallel.Yield();
}
throw new FilterException();
}
private void FIXCreateOrder(MessageFIX4_4 packet)
{
if (debug)
{
log.Debug("FIXCreateOrder() for " + packet.Symbol + ". Client id: " + packet.ClientOrderId);
}
var symbol = Factory.Symbol.LookupSymbol(packet.Symbol);
var order = ConstructOrder(packet, packet.ClientOrderId);
if (!ProviderSimulator.IsOrderServerOnline)
{
if (debug)
{
log.Debug(symbol + ": Rejected " + packet.ClientOrderId + ". Order server offline.");
}
OnRejectOrder(order, symbol + ": Order Server Offline.");
return;
}
var simulator = simulators[SimulatorType.RejectSymbol];
if (FixFactory != null && simulator.CheckFrequencyAndSymbol(symbol))
{
if (debug)
{
log.Debug("Simulating create order reject of 35=" + packet.MessageType);
}
OnRejectOrder(order, "Testing reject of create order");
return;
}
simulator = simulators[SimulatorType.ServerOfflineReject];
if (FixFactory != null && simulator.CheckFrequency())
{
if (debug)
{
log.Debug("Simulating order server offline business reject of 35=" + packet.MessageType);
}
OnBusinessRejectOrder(packet.ClientOrderId, "Server offline for create order.");
ProviderSimulator.SwitchBrokerState("offline", false);
ProviderSimulator.SetOrderServerOffline();
return;
}
if (packet.Symbol == "TestPending")
{
log.Info("Ignoring FIX order since symbol is " + packet.Symbol);
}
else
{
if (string.IsNullOrEmpty(packet.ClientOrderId))
{
System.Diagnostics.Debugger.Break();
}
ProviderSimulator.CreateOrder(order);
ProcessCreateOrder(order);
ProviderSimulator.TryProcessAdustments(order);
}
return;
}
private SymbolInfo GetSymbolInfo(FIXContext context, MessageFIX4_4 packet)
{
SymbolInfo symbolInfo = null;
try {
symbolInfo = Factory.Symbol.LookupSymbol(packet.Symbol);
} catch (ApplicationException ex) {
log.Error("Error looking up " + packet.Symbol + ": " + ex.Message);
}
return(symbolInfo);
}
private void FIXOrderList(MessageFIX4_4 packet)
{
var mbtMsg = (FIXMessage4_4)FixFactory.Create();
mbtMsg.SetText("END");
mbtMsg.AddHeader("8");
if (debug)
{
log.Debug("Sending end of order list: " + mbtMsg);
}
SendMessage(mbtMsg);
}
private void FIXPositionList(MessageFIX4_4 packet)
{
var mbtMsg = (FIXMessage4_4)FixFactory.Create();
mbtMsg.SetText("DONE");
mbtMsg.AddHeader("AO");
if (debug)
{
log.Debug("Sending end of position list: " + mbtMsg);
}
SendMessage(mbtMsg);
}
private void ExecutionReport(FIXContext context, MessageFIX4_4 packetFIX)
{
if (packetFIX.Text == "END")
{
isOrderUpdateComplete = true;
if (debug)
{
log.Debug("ExecutionReport Complete.");
}
TryEndRecovery();
}
}
private void PositionUpdate(MessageFIX4_4 packetFIX)
{
if (packetFIX.MessageType == "AO")
{
if (debug)
{
log.Debug("PositionUpdate Complete.");
}
TryEndRecovery();
}
else
{
var position = packetFIX.LongQuantity + packetFIX.ShortQuantity;
SymbolInfo symbolInfo;
try
{
symbolInfo = Factory.Symbol.LookupSymbol(packetFIX.Symbol);
}
catch (ApplicationException ex)
{
log.Error("Error looking up " + packetFIX.Symbol + ": " + ex.Message);
return;
}
SymbolInfo symbol;
try
{
symbol = Factory.Symbol.LookupSymbol(packetFIX.Symbol);
}
catch
{
log.Info("PositionUpdate. But " + packetFIX.Symbol + " was not found in symbol dictionary.");
return;
}
SymbolAlgorithm algorithm;
if (TryGetAlgorithm(symbol.BinaryIdentifier, out algorithm))
{
if (debug)
{
log.Debug("PositionUpdate for " + symbolInfo + ": MBT actual =" + position + ", TZ actual=" + algorithm.OrderAlgorithm.ActualPosition);
}
}
else
{
log.Info("PositionUpdate for " + symbolInfo + ": MBT actual =" + position + " but symbol was not requested. Ignoring.");
}
}
}
private void AssertPositionMaximum(FIXContext context, MessageFIX4_4 packet)
{
if (isRecovered)
{
var quantity = GetOrderQuantity(context, packet);
var symbolInfo = GetSymbolInfo(context, packet);
if (symbolInfo != null)
{
var position = GetPosition(symbolInfo);
position += quantity;
var maxPositionSize = symbolInfo.MaxPositionSize;
var positionSize = Math.Abs(position);
if (positionSize > maxPositionSize)
{
CloseWithError(context, packet, "Position size " + positionSize + " for " + symbolInfo + " was greater than MaxPositionSize of " + maxPositionSize + " in Message sequence #" + packet.Sequence);
}
}
}
}
private int GetOrderQuantity(FIXContext context, MessageFIX4_4 packet)
{
var quantity = packet.OrderQuantity;
switch (packet.Side)
{
case "1":
break;
case "2":
case "5":
quantity *= -1;
break;
default:
CloseWithError(context, packet, "Unknown order side " + packet.Side + " in fix message. Unable to perform pre-trade verification.");
break;
}
return(quantity);
}
private void AssertOrderMaximum(FIXContext context, MessageFIX4_4 packet)
{
if (isRecovered)
{
var quantity = GetOrderQuantity(context, packet);
var symbolInfo = GetSymbolInfo(context, packet);
if (symbolInfo != null)
{
var position = GetPosition(symbolInfo);
if (Math.Sign(quantity) != Math.Sign(position))
{
quantity += (int)position;
}
var maxOrderSize = symbolInfo.MaxOrderSize;
if (Math.Abs(quantity) > maxOrderSize)
{
CloseWithError(context, packet, "Order size " + quantity + " for " + symbolInfo + " was greater than MaxOrderSize of " + maxOrderSize + " in Message sequence #" + packet.Sequence);
}
}
}
}
private void FIXChangeOrder(MessageFIX4_4 packet)
{
var symbol = Factory.Symbol.LookupSymbol(packet.Symbol);
var order = ConstructOrder(packet, packet.ClientOrderId);
if (!ProviderSimulator.IsOrderServerOnline)
{
log.Info(symbol + ": Rejected " + packet.ClientOrderId + ". Order server offline.");
OnRejectOrder(order, symbol + ": Order Server Offline.");
return;
}
var simulator = simulators[SimulatorType.RejectSymbol];
if (FixFactory != null && simulator.CheckFrequencyAndSymbol(symbol))
{
if (debug)
{
log.Debug("Simulating create order reject of 35=" + packet.MessageType);
}
OnRejectOrder(order, "Testing reject of change order.");
return;
}
simulator = simulators[SimulatorType.ServerOfflineReject];
if (FixFactory != null && simulator.CheckFrequency())
{
if (debug)
{
log.Debug("Simulating order server offline business reject of 35=" + packet.MessageType);
}
OnBusinessRejectOrder(packet.ClientOrderId, "Server offline for change order.");
ProviderSimulator.SwitchBrokerState("offline", false);
ProviderSimulator.SetOrderServerOffline();
return;
}
CreateOrChangeOrder origOrder = null;
if (debug)
{
log.Debug("FIXChangeOrder() for " + packet.Symbol + ". Client id: " + packet.ClientOrderId + ". Original client id: " + packet.OriginalClientOrderId);
}
try
{
long origClientId;
if (!long.TryParse(packet.OriginalClientOrderId, out origClientId))
{
log.Error("original client order id " + packet.OriginalClientOrderId + " cannot be converted to long: " + packet);
origClientId = 0;
}
origOrder = ProviderSimulator.GetOrderById(symbol, origClientId);
} catch (ApplicationException ex) {
if (debug)
{
log.Debug(symbol + ": Rejected " + packet.ClientOrderId + ". Cannot change order: " + packet.OriginalClientOrderId + ". Already filled or canceled. Message: " + ex.Message);
}
OnRejectOrder(order, symbol + ": Cannot change order. Probably already filled or canceled.");
return;
}
order.OriginalOrder = origOrder;
#if VERIFYSIDE
if (order.Side != origOrder.Side)
{
var message = symbol + ": Cannot change " + origOrder.Side + " to " + order.Side;
log.Error(message);
OnRejectOrder(order, false, message);
return;
}
if (order.Type != origOrder.Type)
{
var message = symbol + ": Cannot change " + origOrder.Type + " to " + order.Type;
log.Error(message);
OnRejectOrder(order, false, message);
return;
}
#endif
ProviderSimulator.ChangeOrder(order);
ProcessChangeOrder(order);
}
private void FIXCancelOrder(MessageFIX4_4 packet)
{
var symbol = Factory.Symbol.LookupSymbol(packet.Symbol);
if (!ProviderSimulator.IsOrderServerOnline)
{
if (debug)
{
log.Debug(symbol + ": Cannot cancel order by client id: " + packet.OriginalClientOrderId + ". Order Server Offline.");
}
OnRejectCancel(packet.Symbol, packet.ClientOrderId, packet.OriginalClientOrderId, symbol + ": Order Server Offline");
return;
}
var simulator = simulators[SimulatorType.RejectSymbol];
if (FixFactory != null && simulator.CheckFrequencyAndSymbol(symbol))
{
if (debug)
{
log.Debug("Simulating cancel order reject of 35=" + packet.MessageType);
}
OnRejectCancel(packet.Symbol, packet.ClientOrderId, packet.OriginalClientOrderId, "Testing reject of cancel order.");
return;
}
simulator = simulators[SimulatorType.ServerOfflineReject];
if (FixFactory != null && simulator.CheckFrequency())
{
if (debug)
{
log.Debug("Simulating order server offline business reject of 35=" + packet.MessageType);
}
OnBusinessRejectOrder(packet.ClientOrderId, "Server offline for cancel order.");
ProviderSimulator.SwitchBrokerState("offline", false);
ProviderSimulator.SetOrderServerOffline();
return;
}
if (debug)
{
log.Debug("FIXCancelOrder() for " + packet.Symbol + ". Original client id: " + packet.OriginalClientOrderId);
}
CreateOrChangeOrder origOrder = null;
try
{
long origClientId;
if (!long.TryParse(packet.OriginalClientOrderId, out origClientId))
{
log.Error("original client order id " + packet.OriginalClientOrderId +
" cannot be converted to long: " + packet);
origClientId = 0;
}
origOrder = ProviderSimulator.GetOrderById(symbol, origClientId);
}
catch (ApplicationException)
{
if (debug)
{
log.Debug(symbol + ": Cannot cancel order by client id: " + packet.OriginalClientOrderId + ". Probably already filled or canceled.");
}
OnRejectCancel(packet.Symbol, packet.ClientOrderId, packet.OriginalClientOrderId, "No such order");
return;
}
var cancelOrder = ConstructCancelOrder(packet, packet.ClientOrderId);
cancelOrder.OriginalOrder = origOrder;
ProviderSimulator.CancelOrder(cancelOrder);
ProcessCancelOrder(cancelOrder);
ProviderSimulator.TryProcessAdustments(cancelOrder);
return;
}
public unsafe void ConnectToFIX()
{
string addrStr = "216.52.236.112";
ushort port = 5679;
// Forex
// string password = "******";
// string userName = "******";
// Equity
string password = "******";
string userName = "******";
using (var filter = new FIXPretradeFilter(addrStr, port))
using (Socket socket = Factory.Provider.Socket("TestSocket", "127.0.0.1", filter.LocalPort))
{
socket.MessageFactory = new MessageFactoryFix44();
socket.SetBlocking(true);
socket.Connect();
socket.SetBlocking(false);
Message message = socket.MessageFactory.Create();
string hashPassword = MBTQuotesProvider.Hash(password);
var fixFactory = new FIXFactory4_4(1, userName, destination);
var mbtMsg = (FIXMessage4_4)fixFactory.Create();
mbtMsg.SetEncryption(0);
mbtMsg.SetHeartBeatInterval(30);
mbtMsg.ResetSequence();
mbtMsg.SetEncoding("554_H1");
mbtMsg.SetPassword(password);
mbtMsg.AddHeader("A");
string login = mbtMsg.ToString();
message.DataOut.Write(login.ToCharArray());
log.Info("Login message: \n" + message);
while (!socket.TrySendMessage(message))
{
Factory.Parallel.Yield();
}
long end = Factory.Parallel.TickCount + 5000;
while (!socket.TryGetMessage(out message))
{
if (Factory.Parallel.TickCount > end)
{
Assert.Fail("Login Timed Out.");
}
Factory.Parallel.Yield();
}
MessageFIX4_4 packetFIX = (MessageFIX4_4)message;
// packetFIX.ReadMessage();
Assert.AreEqual("FIX.4.4", packetFIX.Version);
Assert.AreEqual("A", packetFIX.MessageType);
Assert.AreEqual("MBT", packetFIX.Sender);
Assert.AreEqual(userName, packetFIX.Target);
Assert.AreEqual(1, packetFIX.Sequence);
Assert.NotNull(packetFIX.TimeStamp);
Assert.AreEqual("0", packetFIX.Encryption);
Assert.AreEqual(30, packetFIX.HeartBeatInterval);
socket.MessageFactory.Release(message);
}
}
private CreateOrChangeOrder ConstructOrder(MessageFIX4_4 packet, string clientOrderId)
{
if (string.IsNullOrEmpty(clientOrderId))
{
var message = "Client order id was null or empty. FIX Message is: " + packet;
log.Error(message);
throw new ApplicationException(message);
}
var symbol = Factory.Symbol.LookupSymbol(packet.Symbol);
var side = OrderSide.Buy;
switch (packet.Side)
{
case "1":
side = OrderSide.Buy;
break;
case "2":
side = OrderSide.Sell;
break;
case "5":
side = OrderSide.SellShort;
break;
}
var type = OrderType.BuyLimit;
switch (packet.OrderType)
{
case "1":
if (side == OrderSide.Buy)
{
type = OrderType.BuyMarket;
}
else
{
type = OrderType.SellMarket;
}
break;
case "2":
if (side == OrderSide.Buy)
{
type = OrderType.BuyLimit;
}
else
{
type = OrderType.SellLimit;
}
break;
case "3":
if (side == OrderSide.Buy)
{
type = OrderType.BuyStop;
}
else
{
type = OrderType.SellStop;
}
break;
}
long clientId;
var logicalId = 0;
if (!long.TryParse(clientOrderId, out clientId))
{
log.Error("original client order id " + clientOrderId +
" cannot be converted to long: " + packet);
clientId = 0;
}
var utcCreateTime = new TimeStamp(packet.TimeStamp);
var physicalOrder = Factory.Utility.PhysicalOrder(
OrderAction.Create, OrderState.Active, symbol, side, type, OrderFlags.None,
packet.Price, packet.OrderQuantity, logicalId, 0, clientId, null, utcCreateTime);
if (debug)
{
log.Debug("Received physical Order: " + physicalOrder);
}
return(physicalOrder);
}
