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 + "'");
}
}
}
