public CreateOrChangeOrderDefault(OrderState orderState, SymbolInfo symbol, CreateOrChangeOrder origOrder) { binary.action = OrderAction.Cancel; OrderState = orderState; binary.lastModifyTime = Factory.Parallel.UtcNow; binary.symbol = symbol; binary.side = default(OrderSide); binary.type = default(OrderType); binary.price = 0D; binary.size = 0; binary.logicalOrderId = 0; binary.logicalSerialNumber = 0L; binary.tag = null; binary.reference = null; binary.brokerOrder = CreateBrokerOrderId(); binary.utcCreateTime = Factory.Parallel.UtcNow; if (origOrder == null) { throw new NullReferenceException("original order cannot be null for a cancel order."); } binary.originalOrder = origOrder; binary.replacedBy = null; binary.orderFlags = origOrder.OrderFlags; instanceId = ++nextInstanceId; }
private void ProcessChangeOrder(CreateOrChangeOrder order) { SendExecutionReport(order, "E", 0.0, 0, 0, 0, (int)order.Size, TimeStamp.UtcNow); SendPositionUpdate(order.Symbol, ProviderSimulator.GetPosition(order.Symbol)); SendExecutionReport(order, "5", 0.0, 0, 0, 0, (int)order.Size, TimeStamp.UtcNow); SendPositionUpdate(order.Symbol, ProviderSimulator.GetPosition(order.Symbol)); }
private CreateOrChangeOrder RemoveOrderInternal(long clientOrderId) { if (clientOrderId == 0) { return(null); } CreateOrChangeOrder order = null; if (ordersByBrokerId.TryGetValue(clientOrderId, out order)) { var result = ordersByBrokerId.Remove(clientOrderId); if (result && trace) { log.Trace("Removed order by broker id " + clientOrderId + ": " + order); } CreateOrChangeOrder orderBySerial; if (ordersBySerial.TryGetValue(order.LogicalSerialNumber, out orderBySerial)) { if (orderBySerial.BrokerOrder.Equals(clientOrderId)) { var result2 = ordersBySerial.Remove(order.LogicalSerialNumber); if (result2 && trace) { log.Trace("Removed order by logical serial " + order.LogicalSerialNumber + ": " + orderBySerial); } } } ordersBySequence.Remove(order.Sequence); return(order); } return(null); }
public void SelectBySymbolTest() { using (var store = Factory.Utility.PhyscalOrderStore("OrderStoreTest")) { var symbolInfo = Factory.Symbol.LookupSymbol("EUR/USD"); var clientId = 010101010101L; var logicalSerial = 100000335; var order = Factory.Utility.PhysicalOrder(OrderAction.Create, OrderState.Active, symbolInfo, OrderSide.Sell, OrderType.BuyLimit, OrderFlags.None, 124.34, 1234, 14, logicalSerial, clientId, null, TimeStamp.UtcNow); store.SetOrder(order); order = Factory.Utility.PhysicalOrder(OrderAction.Create, OrderState.Active, symbolInfo, OrderSide.Sell, OrderType.BuyLimit, OrderFlags.None, 124.34, 1234, 14, logicalSerial + 1, clientId, null, TimeStamp.UtcNow); store.SetOrder(order); var list = store.GetOrders((o) => o.Symbol.Symbol == "EUR/USD"); var enumerator = list.GetEnumerator(); var count = 0; CreateOrChangeOrder firstItem = null; if (enumerator.MoveNext()) { count++; firstItem = enumerator.Current; } Assert.AreEqual(1, count); Assert.AreEqual(order.BrokerOrder, firstItem.BrokerOrder); Assert.AreEqual(logicalSerial + 1, firstItem.LogicalSerialNumber); } }
private void AssureNode(CreateOrChangeOrder order) { if (order.Reference == null) { order.Reference = nodePool.Create(order); } }
protected override void ResendOrder(CreateOrChangeOrder order) { if (order.Action == OrderAction.Cancel) { if (debug) { log.Debug("Resending cancel order: " + order); } //if (SyncTicks.Enabled && !IsRecovered) //{ // TryAddPhysicalOrder(order); //} SendCancelOrder(order, true); } else { if (debug) { log.Debug("Resending order: " + order); } //if (SyncTicks.Enabled && !IsRecovered) //{ // TryAddPhysicalOrder(order); //} OnCreateOrChangeBrokerOrder(order, true); } }
public bool OnCancelBrokerOrder(CreateOrChangeOrder order) { if (debug) { log.Debug("OnCancelBrokerOrder( " + order.OriginalOrder.BrokerOrder + ")"); } var origOrder = CancelBrokerOrder(order.OriginalOrder.BrokerOrder); if (origOrder == null) { if (debug) { log.Debug("PhysicalOrder too late to change. Already filled or canceled, ignoring."); } var message = "No such order"; if (onRejectOrder != null) { SendReject(order, true, message); } else { throw new ApplicationException(message + " while handling order: " + order); } return(true); } origOrder.ReplacedBy = order; if (confirmOrders != null) { confirmOrders.ConfirmCancel(order.BrokerOrder, true); } UpdateCounts(); return(true); }
private IEnumerable <CreateOrChangeOrder> OrderReferences(CreateOrChangeOrder order) { if (order.ReplacedBy != null) { if (AddUniqueOrder(order.ReplacedBy)) { yield return(order.ReplacedBy); foreach (var sub in OrderReferences(order.ReplacedBy)) { if (AddUniqueOrder(sub)) { yield return(sub); } } } } if (order.OriginalOrder != null) { if (AddUniqueOrder(order.OriginalOrder)) { yield return(order.OriginalOrder); foreach (var sub in OrderReferences(order.OriginalOrder)) { if (AddUniqueOrder(sub)) { yield return(sub); } } } } }
public bool TryGetOrderById(long orderId, out CreateOrChangeOrder createOrChangeOrder) { LogOpenOrders(); lock (orderMapLocker) { return(orderMap.TryGetValue(orderId, out createOrChangeOrder)); } }
public bool AddCreateOrder(CreateOrChangeOrder order) { var result = !HasCreateOrder(order); if (!result) { createOrderQueue.AddLast(order); } return(result); }
private void ProcessCancelOrder(CreateOrChangeOrder cancelOrder) { var origOrder = cancelOrder.OriginalOrder; var randomOrder = random.Next(0, 10) < 5 ? cancelOrder : origOrder; SendExecutionReport(randomOrder, "6", 0.0, 0, 0, 0, (int)origOrder.Size, TimeStamp.UtcNow); SendPositionUpdate(cancelOrder.Symbol, ProviderSimulator.GetPosition(cancelOrder.Symbol)); SendExecutionReport(randomOrder, "4", 0.0, 0, 0, 0, (int)origOrder.Size, TimeStamp.UtcNow); SendPositionUpdate(cancelOrder.Symbol, ProviderSimulator.GetPosition(cancelOrder.Symbol)); }
public bool TryGetOrderBySequence(int sequence, out CreateOrChangeOrder order) { AssertAtomic(); if (sequence == 0) { order = null; return(false); } return(ordersBySequence.TryGetValue(sequence, out order)); }
public bool TryGetOrderById(long brokerOrder, out CreateOrChangeOrder order) { AssertAtomic(); if (brokerOrder == null) { order = null; return(false); } return(ordersByBrokerId.TryGetValue(brokerOrder, out order)); }
private bool CreateBrokerOrder(CreateOrChangeOrder order) { #if VERIFYSIDE if (!VerifySide(order)) { return(false); } #endif lock (orderMapLocker) { try { orderMap.Add(order.BrokerOrder, order); if (trace) { log.Trace("Added order " + order.BrokerOrder); } } catch (ArgumentException) { throw new ApplicationException("A broker order id of " + order.BrokerOrder + " was already added."); } } TriggerOperation operation = default(TriggerOperation); switch (order.Type) { case OrderType.BuyMarket: case OrderType.SellMarket: break; case OrderType.BuyStop: case OrderType.SellLimit: operation = TriggerOperation.GreaterOrEqual; break; case OrderType.BuyLimit: case OrderType.SellStop: operation = TriggerOperation.LessOrEqual; break; case OrderType.StopLoss: default: throw new ArgumentOutOfRangeException(); } if (triggers != null) { var triggerId = triggers.AddTrigger(order.LogicalSerialNumber, TriggerData.Price, operation, order.Price, TriggerCallback); serialTriggerMap[order.LogicalSerialNumber] = triggerId; } SortAdjust(order); IsChanged = true; OrderChanged(); return(true); }
private bool VerifyBuySide(CreateOrChangeOrder order) { var result = true; if (order.Side != OrderSide.Buy) { OrderSideWrongReject(order); result = false; } return(result); }
private void SendReject(CreateOrChangeOrder order, bool removeOriginal, string message) { var wrapper = new RejectWrapper { Order = order, RemoveOriginal = removeOriginal, Message = message }; rejectQueue.Enqueue(wrapper); }
private bool AddUniqueOrder(CreateOrChangeOrder order) { AssertAtomic(); int id; if (!unique.TryGetValue(order, out id)) { unique.Add(order, ++uniqueId); return(true); } return(false); }
public void TryProcessAdustments(CreateOrChangeOrder order) { SimulateSymbol symbolSyncTicks; using (symbolHandlersLocker.Using()) { symbolHandlers.TryGetValue(order.Symbol.BinaryIdentifier, out symbolSyncTicks); } if (symbolSyncTicks != null) { symbolSyncTicks.TryProcessAdjustments(); } }
public void CancelOrder(CreateOrChangeOrder order) { SimulateSymbol symbolSyncTicks; using (symbolHandlersLocker.Using()) { symbolHandlers.TryGetValue(order.Symbol.BinaryIdentifier, out symbolSyncTicks); } if (symbolSyncTicks != null) { symbolSyncTicks.CancelOrder(order); } }
private void OnProcessOrder(CreateOrChangeOrder order, Tick tick) { if (tick.UtcTime < order.UtcCreateTime) { //if (trace) log.Trace log.Info("Skipping check of " + order.Type + " on tick UTC time " + tick.UtcTime + "." + order.UtcCreateTime.Microsecond + " because earlier than order create UTC time " + order.UtcCreateTime + "." + order.UtcCreateTime.Microsecond); return; } if (tick.UtcTime > order.LastReadTime) { order.LastReadTime = tick.UtcTime; fillLogic.TryFillOrder(order, tick); } }
public bool HasCreateOrder(CreateOrChangeOrder order) { foreach (var queueOrder in GetActiveOrders(order.Symbol)) { if (queueOrder.Action == OrderAction.Create && order.LogicalSerialNumber == queueOrder.LogicalSerialNumber) { if (debug) { log.Debug("Create ignored because order was already on create order queue: " + queueOrder); } return(true); } } return(false); }
private bool HasCreateOrder(CreateOrChangeOrder order) { for (var current = CreateOrderQueue.First; current != null; current = current.Next) { var queueOrder = current.Value; if (order.LogicalSerialNumber == queueOrder.LogicalSerialNumber) { if (debug) { log.Debug("Create ignored because order was already on create order queue: " + queueOrder); } return(true); } } return(false); }
private void ProcessCreateOrder(CreateOrChangeOrder order) { SendExecutionReport(order, "A", 0.0, 0, 0, 0, (int)order.Size, TimeStamp.UtcNow); SendPositionUpdate(order.Symbol, ProviderSimulator.GetPosition(order.Symbol)); if (order.Symbol.FixSimulationType == FIXSimulationType.BrokerHeldStopOrder && (order.Type == OrderType.BuyStop || order.Type == OrderType.StopLoss)) { SendExecutionReport(order, "A", "D", 0.0, 0, 0, 0, (int)order.Size, TimeStamp.UtcNow); SendPositionUpdate(order.Symbol, ProviderSimulator.GetPosition(order.Symbol)); } else { SendExecutionReport(order, "0", 0.0, 0, 0, 0, (int)order.Size, TimeStamp.UtcNow); SendPositionUpdate(order.Symbol, ProviderSimulator.GetPosition(order.Symbol)); } }
private void Adjust(ActiveList <CreateOrChangeOrder> list, CreateOrChangeOrder order) { AssureNode(order); var addedOne = false; var node = (ActiveListNode <CreateOrChangeOrder>)order.Reference; if (node.List == null) { list.AddLast(node); } else if (!node.List.Equals(list)) { node.List.Remove(node); list.AddLast(node); } }
public void PurgeOriginalOrder(CreateOrChangeOrder order) { if (order.OriginalOrder == null) { return; } var clientOrderId = order.OriginalOrder.BrokerOrder; if (trace) { log.Trace("PurgeOriginalOrder( " + clientOrderId + ")"); } AssertAtomic(); RemoveOrderInternal(order.OriginalOrder.BrokerOrder); order.OriginalOrder = null; }
public bool OnChangeBrokerOrder(CreateOrChangeOrder createOrChangeOrder) { if (!IsRecovered) { return(false); } if (debug) { log.Debug("OnChangeBrokerOrder( " + createOrChangeOrder + ". Connection " + ConnectionStatus + ", IsOrderServerOnline " + isOrderServerOnline); } if (createOrChangeOrder.Action != OrderAction.Change) { throw new InvalidOperationException("Expected action Change but was " + createOrChangeOrder.Action); } OnCreateOrChangeBrokerOrder(createOrChangeOrder, false); return(true); }
public override void OnRejectOrder(CreateOrChangeOrder order, string error) { var mbtMsg = (FIXMessage4_2)FixFactory.Create(); mbtMsg.SetAccount("33006566"); mbtMsg.SetClientOrderId(order.BrokerOrder.ToString()); mbtMsg.SetOrderStatus("8"); mbtMsg.SetText(error); mbtMsg.SetSymbol(order.Symbol.Symbol); mbtMsg.SetTransactTime(TimeStamp.UtcNow); mbtMsg.AddHeader("8"); if (trace) { log.Trace("Sending reject order: " + mbtMsg); } SendMessage(mbtMsg); }
public void SetOrder(CreateOrChangeOrder order) { AssertAtomic(); if (trace) { log.Trace("Assigning order " + order.BrokerOrder + " with " + order.LogicalSerialNumber); } ordersByBrokerId[order.BrokerOrder] = order; if (order.Sequence != 0) { ordersBySequence[order.Sequence] = order; } if (order.LogicalSerialNumber != 0) { ordersBySerial[order.LogicalSerialNumber] = order; if (order.Action == OrderAction.Cancel && order.OriginalOrder == null) { throw new ApplicationException("CancelOrder w/o any original order setting: " + order); } } }
private void OrderSideWrongReject(CreateOrChangeOrder order) { var message = "Sorry, improper setting of a " + order.Side + " order when position is " + actualPosition; lock (orderMapLocker) { orderMap.Remove(order.BrokerOrder); } if (onRejectOrder != null) { if (debug) { log.Debug("Rejecting order because position is " + actualPosition + " but order side was " + order.Side + ": " + order); } SendReject(order, true, message); } else { throw new ApplicationException(message + " while handling order: " + order); } }
public override void OnPhysicalFill(PhysicalFill fill, CreateOrChangeOrder order) { if (order.Symbol.FixSimulationType == FIXSimulationType.BrokerHeldStopOrder && (order.Type == OrderType.BuyStop || order.Type == OrderType.SellStop)) { order.Type = order.Type == OrderType.BuyStop ? OrderType.BuyMarket : OrderType.SellMarket; var marketOrder = Factory.Utility.PhysicalOrder(order.Action, order.OrderState, order.Symbol, order.Side, order.Type, OrderFlags.None, 0, order.Size, order.LogicalOrderId, order.LogicalSerialNumber, order.BrokerOrder, null, TimeStamp.UtcNow); SendExecutionReport(marketOrder, "0", 0.0, 0, 0, 0, (int)marketOrder.Size, TimeStamp.UtcNow); } if (debug) { log.Debug("Converting physical fill to FIX: " + fill); } SendPositionUpdate(order.Symbol, ProviderSimulator.GetPosition(order.Symbol)); var orderStatus = fill.CumulativeSize == fill.TotalSize ? "2" : "1"; SendExecutionReport(order, orderStatus, "F", fill.Price, fill.TotalSize, fill.CumulativeSize, fill.Size, fill.RemainingSize, fill.UtcTime); }