private void PositionUpdate(PacketFIX4_4 packetFIX) { if (packetFIX.MessageType == "AO") { isPositionUpdateComplete = true; 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; } if (debug) { log.Debug("PositionUpdate: " + symbolInfo + "=" + position); } var orderHandler = GetAlgorithm(symbolInfo.BinaryIdentifier); orderHandler.SetActualPosition(position); } }
private unsafe bool VerifyLogin(Packet packet) { PacketFIX4_4 packetFIX = (PacketFIX4_4)packet; if (!("A" == packetFIX.MessageType && "FIX.4.4" == packetFIX.Version && "MBT" == packetFIX.Sender && UserName == packetFIX.Target && "0" == packetFIX.Encryption && 30 == packetFIX.HeartBeatInterval)) { StringBuilder message = new StringBuilder(); message.AppendLine("Invalid login response:"); message.AppendLine(" message type = " + packetFIX.MessageType); message.AppendLine(" version = " + packetFIX.Version); message.AppendLine(" sender = " + packetFIX.Sender); message.AppendLine(" target = " + packetFIX.Target); message.AppendLine(" encryption = " + packetFIX.Encryption); message.AppendLine(" heartbeat interval = " + packetFIX.HeartBeatInterval); message.AppendLine(packetFIX.ToString()); log.Warn(message + " -- retrying."); return(false); } return(1 == packetFIX.Sequence); }
private void FIXLogin(PacketFIX4_4 packet) { if (fixState != ServerState.Startup) { CloseWithFixError(packet, "Invalid login request. Already logged in."); } fixState = ServerState.LoggedIn; var writePacket = fixSocket.CreatePacket(); target = packet.Target; sender = packet.Sender; FixFactory = new FIXFactory4_4(1, packet.Target, packet.Sender); var mbtMsg = (FIXMessage4_4)FixFactory.Create(); mbtMsg.SetEncryption(0); mbtMsg.SetHeartBeatInterval(30); mbtMsg.AddHeader("A"); string login = mbtMsg.ToString(); writePacket.DataOut.Write(login.ToCharArray()); fixPacketQueue.Enqueue(writePacket); if (debug) { log.Debug("Sending login response: " + login); } }
private void PositionUpdate(FIXContext context, PacketFIX4_4 packet) { if (packet.MessageType == "AO") { isPositionUpdateComplete = true; if (debug) { log.Debug("PositionUpdate Complete."); } TryEndRecovery(); } else { // if( isRecovered) { double position = packet.LongQuantity + packet.ShortQuantity; SymbolInfo symbolInfo; try { symbolInfo = Factory.Symbol.LookupSymbol(packet.Symbol); } catch (ApplicationException ex) { log.Error("Error looking up " + packet.Symbol + ": " + ex.Message); return; } if (debug) { log.Debug("PositionUpdate: " + symbolInfo + "=" + position); } symbolPositionMap[symbolInfo.BinaryIdentifier] = position; // } } }
private void CloseWithError(FIXContext context, PacketFIX4_4 packetIn, string message) { Packet packet = context.LocalSocket.CreatePacket(); 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(message); fixMsg.AddHeader("j"); string errorMessage = fixMsg.ToString(); packet.DataOut.Write(errorMessage.ToCharArray()); long end = Factory.Parallel.TickCount + 2000; if (debug) { log.Debug("Writing Error Message: " + packet); } while (!context.LocalSocket.TrySendPacket(packet)) { if (Factory.Parallel.TickCount > end) { throw new ApplicationException("Timeout while sending an order."); } Factory.Parallel.Yield(); } throw new FilterException(); }
private Yield FIXCancelOrder(PacketFIX4_4 packet) { var symbol = Factory.Symbol.LookupSymbol(packet.Symbol); if (debug) { log.Debug("FIXCancelOrder() for " + packet.Symbol + ". Original client id: " + packet.OriginalClientOrderId); } PhysicalOrder order = null; try { order = GetOrderById(symbol, packet.OriginalClientOrderId); } catch (ApplicationException) { if (debug) { log.Debug(symbol + ": Cannot cancel order by client id: " + packet.OriginalClientOrderId + ". Probably already filled or canceled. Should send a reject in this case."); } if (SyncTicks.Enabled) { var tickSync = SyncTicks.GetTickSync(symbol.BinaryIdentifier); tickSync.RemovePhysicalOrder(); } return(Yield.DidWork.Return); } // log.Info( packet.Symbol + ": Canceling order for client id: " + packet.OriginalClientOrderId); CancelOrder(symbol, order.BrokerOrder); SendExecutionReport(order, "6", 0.0, 0, 0, 0, (int)order.Size, TimeStamp.UtcNow, packet); SendPositionUpdate(order.Symbol, GetPosition(order.Symbol)); SendExecutionReport(order, "4", 0.0, 0, 0, 0, (int)order.Size, TimeStamp.UtcNow, packet); SendPositionUpdate(order.Symbol, GetPosition(order.Symbol)); return(Yield.DidWork.Repeat); }
public void RejectOrder(PacketFIX4_4 packetFIX) { var rejectReason = false; rejectReason = packetFIX.Text.Contains("Outside trading hours") ? true : rejectReason; rejectReason = packetFIX.Text.Contains("not accepted this session") ? true : rejectReason; rejectReason = packetFIX.Text.Contains("Pending live orders") ? true : rejectReason; rejectReason = packetFIX.Text.Contains("Trading temporarily unavailable") ? true : rejectReason; rejectReason = packetFIX.Text.Contains("improper setting") ? true : rejectReason; rejectReason = packetFIX.Text.Contains("No position to close") ? true : rejectReason; RemoveOrder(packetFIX.ClientOrderId); RemoveOrder(packetFIX.OriginalClientOrderId); if (!rejectReason && IsRecovered) { var message = "Order Rejected: " + packetFIX.Text + "\n" + packetFIX; var ignore = "The reject error message '" + packetFIX.Text + "' was unrecognized. So it is being ignored. "; var handle = "If this reject causes any other problems please report it to have it added and properly handled."; log.Warn(message); log.Error(ignore + handle); } else { log.Info("RejectOrder(" + packetFIX.Text + ") Removed cancel order: " + packetFIX.ClientOrderId + " and original order: " + packetFIX.OriginalClientOrderId); } }
public void SendFill(PacketFIX4_4 packetFIX) { if (debug) { log.Debug("SendFill( " + packetFIX.ClientOrderId + ")"); } var symbolInfo = Factory.Symbol.LookupSymbol(packetFIX.Symbol); var timeZone = new SymbolTimeZone(symbolInfo); if (GetSymbolStatus(symbolInfo)) { var algorithm = GetAlgorithm(symbolInfo.BinaryIdentifier); var order = GetPhysicalOrder(packetFIX.ClientOrderId); var fillPosition = packetFIX.LastQuantity * SideToSign(packetFIX.Side); TimeStamp executionTime; if (UseLocalFillTime) { executionTime = TimeStamp.UtcNow; } else { executionTime = new TimeStamp(packetFIX.TransactionTime); } var configTime = executionTime; configTime.AddSeconds(timeZone.UtcOffset(executionTime)); var fill = Factory.Utility.PhysicalFill(fillPosition, packetFIX.LastPrice, configTime, executionTime, order, false); if (debug) { log.Debug("Sending physical fill: " + fill); } algorithm.ProcessFill(fill, packetFIX.OrderQuantity, packetFIX.CumulativeQuantity, packetFIX.LeavesQuantity); } }
private int GetLogicalOrderId(PacketFIX4_4 packetFIX) { string[] parts = packetFIX.ClientOrderId.Split(DOT_SEPARATOR); int logicalOrderId = 0; try { logicalOrderId = int.Parse(parts[0]); } catch (FormatException) { } return(logicalOrderId); }
private SymbolInfo GetSymbolInfo(FIXContext context, PacketFIX4_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 ExecutionReport(FIXContext context, PacketFIX4_4 packetFIX) { if (packetFIX.Text == "END") { isOrderUpdateComplete = true; if (debug) { log.Debug("ExecutionReport Complete."); } TryEndRecovery(); } }
private OrderType GetOrderType(PacketFIX4_4 packetFIX) { var orderType = OrderType.None; switch (packetFIX.Side) { case "1": switch (packetFIX.OrderType) { case "1": orderType = OrderType.BuyMarket; break; case "2": orderType = OrderType.BuyLimit; break; case "3": orderType = OrderType.BuyStop; break; default: break; } break; case "2": case "5": switch (packetFIX.OrderType) { case "1": orderType = OrderType.SellMarket; break; case "2": orderType = OrderType.SellLimit; break; case "3": orderType = OrderType.SellStop; break; default: break; } break; default: throw new ApplicationException("Unknown order side: '" + packetFIX.Side + "'\n" + packetFIX); } return(orderType); }
public PhysicalOrder UpdateOrder(PacketFIX4_4 packetFIX, OrderState orderState, object note) { var clientOrderId = packetFIX.ClientOrderId; if (!string.IsNullOrEmpty(packetFIX.OriginalClientOrderId)) { clientOrderId = packetFIX.OriginalClientOrderId; } if (debug && (LogRecovery || !IsRecovery)) { log.Debug("UpdateOrder( " + clientOrderId + ", state = " + orderState + ")"); } return(UpdateOrReplaceOrder(packetFIX, clientOrderId, clientOrderId, orderState, note)); }
public PhysicalOrder ReplaceOrder(PacketFIX4_4 packetFIX, OrderState orderState, object note) { if (debug && (LogRecovery || !IsRecovery)) { log.Debug("ReplaceOrder( " + packetFIX.OriginalClientOrderId + ", state = " + orderState + " => " + packetFIX.ClientOrderId + ")"); } var order = UpdateOrReplaceOrder(packetFIX, packetFIX.OriginalClientOrderId, packetFIX.ClientOrderId, orderState, note); if (order != null) { RemoveOrder(packetFIX.OriginalClientOrderId); } return(order); }
private void CloseWithFixError(PacketFIX4_4 packet, string message) { var writePacket = fixSocket.CreatePacket(); var fixMsg = (FIXMessage4_4)FixFactory.Create(); TimeStamp timeStamp = TimeStamp.UtcNow; fixMsg.SetAccount(packet.Account); fixMsg.SetText(message); fixMsg.AddHeader("j"); string errorMessage = fixMsg.ToString(); writePacket.DataOut.Write(errorMessage.ToCharArray()); fixPacketQueue.Enqueue(writePacket); }
private void FIXPositionList(PacketFIX4_4 packet) { var writePacket = fixSocket.CreatePacket(); var mbtMsg = (FIXMessage4_4)FixFactory.Create(); mbtMsg.SetText("DONE"); mbtMsg.AddHeader("AO"); string message = mbtMsg.ToString(); writePacket.DataOut.Write(message.ToCharArray()); fixPacketQueue.Enqueue(writePacket); if (debug) { log.Debug("Sending end of position list: " + message); } }
private void AssertPositionMaximum(FIXContext context, PacketFIX4_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 packet sequence #" + packet.Sequence); } } } }
private void FIXChangeOrder(PacketFIX4_4 packet) { var symbol = Factory.Symbol.LookupSymbol(packet.Symbol); PhysicalOrder origOrder = null; if (debug) { log.Debug("FIXChangeOrder() for " + packet.Symbol + ". Client id: " + packet.ClientOrderId + ". Original client id: " + packet.OriginalClientOrderId); } try { origOrder = GetOrderById(symbol, packet.OriginalClientOrderId); } catch (ApplicationException) { log.Warn(symbol + ": Cannot change order by client id: " + packet.OriginalClientOrderId + ". Probably already filled or canceled. Should send a reject in this case."); if (SyncTicks.Enabled) { var tickSync = SyncTicks.GetTickSync(symbol.BinaryIdentifier); tickSync.RemovePhysicalOrder(); } return; } var order = ConstructOrder(packet, packet.ClientOrderId); if (order.Side != origOrder.Side) { var message = "Cannot change " + origOrder.Side + " to " + order.Side; log.Error(message); OnRejectOrder(origOrder, message); return; } if (order.Type != origOrder.Type) { var message = "Cannot change " + origOrder.Type + " to " + order.Type; log.Error(message); OnRejectOrder(origOrder, message); return; } SendExecutionReport(order, "E", 0.0, 0, 0, 0, (int)order.Size, TimeStamp.UtcNow, packet); SendPositionUpdate(order.Symbol, GetPosition(order.Symbol)); SendExecutionReport(order, "5", 0.0, 0, 0, 0, (int)order.Size, TimeStamp.UtcNow, packet); SendPositionUpdate(order.Symbol, GetPosition(order.Symbol)); ChangeOrder(order, packet.OriginalClientOrderId); }
private Yield FIXCreateOrder(PacketFIX4_4 packet) { if (debug) { log.Debug("FIXCreateOrder() for " + packet.Symbol + ". Client id: " + packet.ClientOrderId); } var order = ConstructOrder(packet, packet.ClientOrderId); // log.Info( packet.Symbol + ": Creating order for client id: " + packet.ClientOrderId); if (string.IsNullOrEmpty(packet.ClientOrderId)) { System.Diagnostics.Debugger.Break(); } SendExecutionReport(order, "A", 0.0, 0, 0, 0, (int)order.Size, TimeStamp.UtcNow, packet); SendPositionUpdate(order.Symbol, GetPosition(order.Symbol)); SendExecutionReport(order, "0", 0.0, 0, 0, 0, (int)order.Size, TimeStamp.UtcNow, packet); SendPositionUpdate(order.Symbol, GetPosition(order.Symbol)); CreateOrder(order); return(Yield.DidWork.Repeat); }
private int GetOrderQuantity(FIXContext context, PacketFIX4_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 TryHandlePiggyBackFill(PacketFIX4_4 packetFIX) { if (packetFIX.LastQuantity > 0 && IsRecovered) { SendFill(packetFIX); } if (packetFIX.LeavesQuantity == 0) { var order = RemoveOrder(packetFIX.ClientOrderId); if (packetFIX.OriginalClientOrderId != null) { order = RemoveOrder(packetFIX.OriginalClientOrderId); } if (IsRecovered) { var algorithm = GetAlgorithm(order.Symbol.BinaryIdentifier); algorithm.PerformCompare(); } } }
private void CancelRejected(PacketFIX4_4 packetFIX) { if (debug && (LogRecovery || !IsRecovery)) { log.Debug("ExecutionReport: " + packetFIX); } string orderStatus = packetFIX.OrderStatus; switch (orderStatus) { case "8": // Rejected var rejectReason = false; rejectReason = packetFIX.Text.Contains("No such order") ? true : rejectReason; rejectReason = packetFIX.Text.Contains("Cancel request already pending") ? true : rejectReason; rejectReason = packetFIX.Text.Contains("ORDER in pending state") ? true : rejectReason; RemoveOrder(packetFIX.ClientOrderId); if (packetFIX.Text.Contains("No such order")) { RemoveOrder(packetFIX.OriginalClientOrderId); } if (!rejectReason && IsRecovered) { var message = "Order Rejected: " + packetFIX.Text + "\n" + packetFIX; var ignore = "The cancel reject error message '" + packetFIX.Text + "' was unrecognized. So it is being ignored. "; var handle = "If this reject causes any other problems please report it to have it added and properly handled."; log.Warn(message); log.Error(ignore + handle); } else { if (LogRecovery || !IsRecovery) { log.Info("CancelReject(" + packetFIX.Text + ") Removed cancel order: " + packetFIX.ClientOrderId); } } break; default: throw new ApplicationException("Unknown cancel rejected order status: '" + orderStatus + "'"); } }
private void AssertOrderMaximum(FIXContext context, PacketFIX4_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 packet sequence #" + packet.Sequence); } } } }
private void TestMethod(PacketFIX4_4 packetFIX) { string account = packetFIX.Account; string destination = packetFIX.Destination; int orderQuantity = packetFIX.OrderQuantity; double averagePrice = packetFIX.AveragePrice; string orderID = packetFIX.OrderId; string massStatusRequestId = packetFIX.MassStatusRequestId; string positionEffect = packetFIX.PositionEffect; string orderType = packetFIX.OrderType; string clientOrderId = packetFIX.ClientOrderId; double price = packetFIX.Price; int cumulativeQuantity = packetFIX.CumulativeQuantity; string executionId = packetFIX.ExecutionId; int productType = packetFIX.ProductType; string symbol = packetFIX.Symbol; string side = packetFIX.Side; string timeInForce = packetFIX.TimeInForce; string executionType = packetFIX.ExecutionType; string internalOrderId = packetFIX.InternalOrderId; string transactionTime = packetFIX.TransactionTime; int leavesQuantity = packetFIX.LeavesQuantity; }
private void BusinessReject(PacketFIX4_4 packetFIX) { var lower = packetFIX.Text.ToLower(); var text = packetFIX.Text; var errorOkay = false; errorOkay = lower.Contains("order") && lower.Contains("server") ? true : errorOkay; errorOkay = text.Contains("DEMOORDS") ? true : errorOkay; errorOkay = text.Contains("FXORD1") ? true : errorOkay; errorOkay = text.Contains("FXORD2") ? true : errorOkay; errorOkay = text.Contains("FXORD01") ? true : errorOkay; errorOkay = text.Contains("FXORD02") ? true : errorOkay; if (errorOkay) { log.Warn(packetFIX.Text + " -- Sending EndBroker event. \n" + packetFIX); SendEndBroker(); } else { string message = "FIX Server reported an error: " + packetFIX.Text + "\n" + packetFIX; throw new ApplicationException(message); } }
private OrderSide GetOrderSide(PacketFIX4_4 packetFIX) { OrderSide side; switch (packetFIX.Side) { case "1": side = OrderSide.Buy; break; case "2": side = OrderSide.Sell; break; case "5": side = OrderSide.SellShort; break; default: throw new ApplicationException("Unknown order side: " + packetFIX.Side + "\n" + packetFIX); } return(side); }
private PhysicalOrder ConstructOrder(PacketFIX4_4 packet, string clientOrderId) { 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; } var clientId = clientOrderId.Split(new char[] { '.' }); var logicalId = int.Parse(clientId[0]); var physicalOrder = Factory.Utility.PhysicalOrder( OrderState.Active, symbol, side, type, packet.Price, packet.OrderQuantity, logicalId, 0, clientOrderId, null); if (debug) { log.Debug("Received physical Order: " + physicalOrder); } return(physicalOrder); }
private void SendExecutionReport(PhysicalOrder order, string status, double price, int orderQty, int cumQty, int lastQty, int leavesQty, TimeStamp time, PacketFIX4_4 packet) { int orderType = 0; switch (order.Type) { case OrderType.BuyMarket: case OrderType.SellMarket: orderType = 1; break; case OrderType.BuyLimit: case OrderType.SellLimit: orderType = 2; break; case OrderType.BuyStop: case OrderType.SellStop: orderType = 3; break; } int orderSide = 0; switch (order.Side) { case OrderSide.Buy: orderSide = 1; break; case OrderSide.Sell: orderSide = 2; break; case OrderSide.SellShort: orderSide = 5; break; } var writePacket = fixSocket.CreatePacket(); var mbtMsg = (FIXMessage4_4)FixFactory.Create(); mbtMsg.SetAccount("33006566"); mbtMsg.SetDestination("MBTX"); mbtMsg.SetOrderQuantity(orderQty); mbtMsg.SetLastQuantity(Math.Abs(lastQty)); if (lastQty != 0) { mbtMsg.SetLastPrice(price); } mbtMsg.SetCumulativeQuantity(Math.Abs(cumQty)); mbtMsg.SetOrderStatus(status); mbtMsg.SetPositionEffect("O"); mbtMsg.SetOrderType(orderType); mbtMsg.SetSide(orderSide); if (packet == null) { mbtMsg.SetClientOrderId(order.BrokerOrder.ToString()); } else { mbtMsg.SetClientOrderId(packet.ClientOrderId); if (packet.OriginalClientOrderId != null) { mbtMsg.SetOriginalClientOrderId(packet.OriginalClientOrderId); } } mbtMsg.SetPrice(order.Price); mbtMsg.SetSymbol(order.Symbol.Symbol); mbtMsg.SetTimeInForce(0); mbtMsg.SetExecutionType(status); mbtMsg.SetTransactTime(time); mbtMsg.SetLeavesQuantity(Math.Abs(leavesQty)); mbtMsg.AddHeader("8"); string message = mbtMsg.ToString(); writePacket.DataOut.Write(message.ToCharArray()); if (debug) { log.Debug("Sending execution report: " + message); } fixPacketQueue.Enqueue(writePacket); }
public PhysicalOrder UpdateOrReplaceOrder(PacketFIX4_4 packetFIX, string clientOrderId, string newClientOrderId, OrderState orderState, object note) { SymbolInfo symbolInfo; try { symbolInfo = Factory.Symbol.LookupSymbol(packetFIX.Symbol); } catch (ApplicationException ex) { log.Error("Error looking up " + packetFIX.Symbol + ": " + ex.Message); return(null); } PhysicalOrder oldOrder = null; long logicalSerialNumber = 0; try { oldOrder = GetOrderById(clientOrderId); logicalSerialNumber = oldOrder.LogicalSerialNumber; } catch (ApplicationException) { if (!IsRecovery) { log.Warn("Order ID# " + clientOrderId + " was not found for update or replace."); return(null); } } int quantity = packetFIX.LeavesQuantity; PhysicalOrder order; var type = GetOrderType(packetFIX); var side = GetOrderSide(packetFIX); var logicalId = GetLogicalOrderId(packetFIX); order = Factory.Utility.PhysicalOrder(orderState, symbolInfo, side, type, packetFIX.Price, packetFIX.LeavesQuantity, logicalId, logicalSerialNumber, newClientOrderId, null); if (quantity > 0) { if (info && (LogRecovery || !IsRecovery)) { if (debug) { log.Debug("Updated order: " + order + ". Executed: " + packetFIX.CumulativeQuantity + " Remaining: " + packetFIX.LeavesQuantity); } } } else { if (info && (LogRecovery || !IsRecovery)) { if (debug) { log.Debug("Order Completely Filled. Id: " + packetFIX.ClientOrderId + ". Executed: " + packetFIX.CumulativeQuantity); } } } lock ( openOrdersLocker) { openOrders[newClientOrderId] = order; } if (trace) { log.Trace("Updated order list:"); lock ( openOrdersLocker) { foreach (var kvp in openOrders) { PhysicalOrder temp = kvp.Value; log.Trace(" " + temp.BrokerOrder + " " + temp); } } } return(order); }
private void ExecutionReport(PacketFIX4_4 packetFIX) { if (packetFIX.Text == "END") { isOrderUpdateComplete = true; if (debug) { log.Debug("ExecutionReport Complete."); } TryEndRecovery(); } else { if (debug && (LogRecovery || !IsRecovery)) { log.Debug("ExecutionReport: " + packetFIX); } PhysicalOrder order; string orderStatus = packetFIX.OrderStatus; switch (orderStatus) { case "0": // New SymbolInfo symbol = null; try { symbol = Factory.Symbol.LookupSymbol(packetFIX.Symbol); } catch (ApplicationException) { // symbol unknown. } if (symbol != null) { order = UpdateOrder(packetFIX, OrderState.Active, null); if (IsRecovered) { var algorithm = GetAlgorithm(symbol.BinaryIdentifier); algorithm.OnCreateBrokerOrder(order); } } break; case "1": // Partial UpdateOrder(packetFIX, OrderState.Active, null); if (IsRecovered) { SendFill(packetFIX); } break; case "2": // Filled if (IsRecovered) { SendFill(packetFIX); } order = RemoveOrder(packetFIX.ClientOrderId); if (IsRecovered) { var algorithm = GetAlgorithm(order.Symbol.BinaryIdentifier); algorithm.PerformCompare(); } if (order != null && order.Replace != null) { if (debug) { log.Debug("Found this order in the replace property. Removing it also: " + order.Replace); } RemoveOrder(order.Replace.BrokerOrder.ToString()); } break; case "5": // Replaced order = ReplaceOrder(packetFIX, OrderState.Active, null); if (IsRecovered) { if (order != null) { var algorithm = GetAlgorithm(order.Symbol.BinaryIdentifier); algorithm.OnChangeBrokerOrder(order, packetFIX.OriginalClientOrderId); } else { log.Warn("Changing order status after cancel/replace failed. Probably due to already being canceled or filled. Ignoring."); } } break; case "4": // Canceled order = RemoveOrder(packetFIX.ClientOrderId); order = RemoveOrder(packetFIX.OriginalClientOrderId); if (IsRecovered) { if (order != null) { var algorithm = GetAlgorithm(order.Symbol.BinaryIdentifier); algorithm.OnCancelBrokerOrder(order.Symbol, packetFIX.ClientOrderId); } else if (IsRecovered) { log.Notice("Order " + packetFIX.ClientOrderId + " was already removed after cancel. Ignoring."); } } break; case "6": // Pending Cancel UpdateOrder(packetFIX, OrderState.Pending, "PendingCancel"); TryHandlePiggyBackFill(packetFIX); break; case "8": // Rejected RejectOrder(packetFIX); break; case "9": // Suspended UpdateOrder(packetFIX, OrderState.Suspended, packetFIX); // Ignore break; case "A": // PendingNew UpdateOrder(packetFIX, OrderState.Active, null); break; case "E": // Pending Replace UpdateOrder(packetFIX, OrderState.Pending, "PendingReplace"); TryHandlePiggyBackFill(packetFIX); break; case "R": // Resumed. UpdateOrder(packetFIX, OrderState.Active, null); // Ignore break; default: throw new ApplicationException("Unknown order status: '" + orderStatus + "'"); } } }