public void OrderFilledUnlockSequenceSubmitOpening(Order order) { List<List<Order>> ordersCloseFoundInKeys = new List<List<Order>>(); lock (this.ordersCloseOpen) { foreach (List<Order> ordersClose in this.ordersCloseOpen.Keys) { if (ordersClose.Contains(order) == false) continue; ordersCloseFoundInKeys.Add(ordersClose); } foreach (List<Order> ordersCloseFound in ordersCloseFoundInKeys) { ordersCloseFound.Remove(order); if (ordersCloseFound.Count == 0) { List<Order> ordersOpen = this.ordersCloseOpen[ordersCloseFound]; this.ordersCloseOpen.Remove(ordersCloseFound); if (ordersOpen.Count == 0) continue; this.orderProcessor.AppendOrderMessageAndPropagateCheckThrowOrderNull(order, "last CloseOpenSequence order filled, unlocking submission of [" + ordersOpen.Count + "]ordersOpen"); foreach (Order submitting in ordersOpen) { OrderStateMessage omsg = new OrderStateMessage(submitting, OrderState.Submitting, "sequence cleared: [" + submitting.State + "]=>[" + OrderState.Submitting + "]" + " for [" + ordersOpen.Count + "] fellow ordersOpen" + " by orderClose=[" + order + "]"); this.orderProcessor.UpdateOrderStateAndPostProcess(submitting, omsg); } BrokerProvider broker = ordersOpen[0].Alert.DataSource.BrokerProvider; ThreadPool.QueueUserWorkItem(new WaitCallback(broker.SubmitOrdersThreadEntry), new object[] { ordersOpen }); } } } }
public void InitializeSequence(List<Order> ordersClose, List<Order> ordersOpen) { lock (this.ordersCloseOpen) { this.ordersCloseOpen.Add(ordersClose, ordersOpen); } foreach (Order sequenced in ordersOpen) { OrderStateMessage omsg = new OrderStateMessage(sequenced, OrderState.SubmittingSequenced, "sequence initialized: [" + sequenced.State + "]=>[" + OrderState.SubmittingSequenced + "]" + " for [" + ordersOpen.Count + "] fellow ordersOpen" + " by [" + ordersClose.Count + "]ordersClose"); this.orderProcessor.UpdateOrderStateAndPostProcess(sequenced, omsg); } }
private void removeEmergencyLock(Order filledEmergencyOrder, OrderState stateCompletedOrInterrupted) { OrderPostProcessorEmergencyLock emergencyLock = new OrderPostProcessorEmergencyLock(filledEmergencyOrder); string msgPost = "EmergencyLock Removed [" + emergencyLock + "]"; if (this.emergencyLocks.Contains(emergencyLock) == false) { string msg = "no EmergencyLock to remove: multiple QUIK callbacks? if u can find [" + msgPost + "] earlier in thisOrder.Messages then it's ok"; this.orderProcessor.AppendOrderMessageAndPropagateCheckThrowOrderNull(filledEmergencyOrder, msg); Assembler.PopupException(msg); //throw new Exception(msg); return; } lock (this.emergencyLocks) { this.emergencyLocks.Remove(emergencyLock); } OrderStateMessage omsgPost = new OrderStateMessage(filledEmergencyOrder, stateCompletedOrInterrupted, msgPost); this.orderProcessor.UpdateOrderStateAndPostProcess(filledEmergencyOrder, omsgPost); }
public void OrderFilledUnlockSequenceSubmitOpening(Order orderClosed) { List<List<Order>> lockingClosesFound = new List<List<Order>>(); lock (this.dictionaryLock) { // if among all the keys we have an order, then we should have Open orders sequenced foreach (List<Order> lockingCloseOrders in this.sequencerLockCloseOpen.Keys) { if (lockingCloseOrders.Contains(orderClosed) == false) continue; lockingClosesFound.Add(lockingCloseOrders); } // analyzing all locks for all symbols to find out whether this closed order released the lock foreach (List<Order> lockingCloseFound in lockingClosesFound) { // delete the locking order from the list (most likely containing 1 order) lockingCloseFound.Remove(orderClosed); if (lockingCloseFound.Count > 0) continue; // delete the list of locks from global dictionary List<Order> ordersOpen = this.sequencerLockCloseOpen[lockingCloseFound]; this.sequencerLockCloseOpen.Remove(lockingCloseFound); this.orderProcessor.AppendOrderMessageAndPropagateCheckThrowOrderNull(orderClosed, "last CloseOpenSequence order filled, unlocking submission of [" + ordersOpen.Count + "]ordersOpen"); if (ordersOpen.Count == 0) continue; // submitting all released opening orders foreach (Order submitting in ordersOpen) { OrderStateMessage omsg = new OrderStateMessage(submitting, OrderState.Submitting, "sequence cleared: [" + submitting.State + "]=>[" + OrderState.Submitting + "]" + " for [" + ordersOpen.Count + "] fellow ordersOpen" + " by orderClose=[" + orderClosed + "]"); this.orderProcessor.UpdateOrderStateAndPostProcess(submitting, omsg); } BrokerProvider broker = ordersOpen[0].Alert.DataSource.BrokerProvider; ThreadPool.QueueUserWorkItem(new WaitCallback(broker.SubmitOrdersThreadEntryDelayed), new object[] { ordersOpen, ordersOpen[0].Alert.Bars.SymbolInfo.SequencedOpeningAfterClosedDelayMillis }); } } }
public virtual void ModifyOrderTypeAccordingToMarketOrderAs(Order order) { string msg = Name + "::ModifyOrderTypeAccordingToMarketOrderAs():" + " Guid[" + order.GUID + "]" + " SernoExchange[" + order.SernoExchange + "]" + " SernoSession[" + order.SernoSession + "]"; order.CurrentBid = this.StreamingProvider.StreamingDataSnapshot.BestBidGetForMarketOrder(order.Alert.Symbol); order.CurrentAsk = this.StreamingProvider.StreamingDataSnapshot.BestAskGetForMarketOrder(order.Alert.Symbol); double priceBestBidAsk = this.StreamingProvider.StreamingDataSnapshot.BidOrAskFor( order.Alert.Symbol, order.Alert.PositionLongShortFromDirection); switch (order.Alert.MarketLimitStop) { case MarketLimitStop.Market: //if (order.PriceRequested != 0) { // string msg1 = Name + "::OrderSubmit(): order[" + order + "] is MARKET, dropping Price[" + order.PriceRequested + "] replacing with current Bid/Ask "; // order.addMessage(new OrderStateMessage(order, order.State, msg1)); // Assembler.PopupException(msg1); // order.PriceRequested = 0; //} if (order.Alert.Bars == null) { msg = "order.Bars=null; can't align order and get Slippage; returning with error // " + msg; Assembler.PopupException(msg); //order.AppendMessageAndChangeState(new OrderStateMessage(order, OrderState.ErrorOrderInconsistent, msg)); this.OrderProcessor.UpdateOrderStateAndPostProcess(order, new OrderStateMessage(order, OrderState.ErrorOrderInconsistent, msg)); throw new Exception(msg); } switch (order.Alert.MarketOrderAs) { case MarketOrderAs.MarketZeroSentToBroker: order.PriceRequested = 0; msg = "SymbolInfo[" + order.Alert.Symbol + "/" + order.Alert.SymbolClass + "].OverrideMarketPriceToZero==true" + "; setting Price=0 (Slippage=" + order.SlippageFill + ") //" + msg; break; case MarketOrderAs.MarketMinMaxSentToBroker: order.Alert.MarketLimitStop = MarketLimitStop.Limit; msg = this.ModifyOrderTypeAccordingToMarketOrderAsBrokerSpecificInjection(order); msg = "[" + order.Alert.MarketLimitStop + "]=>[" + MarketLimitStop.Limit + "](" + order.Alert.MarketOrderAs + ") // " + msg; break; case MarketOrderAs.LimitCrossMarket: order.Alert.MarketLimitStop = MarketLimitStop.Limit; msg = "PreSubmit: doing nothing for Alert.MarketOrderAs=[" + order.Alert.MarketOrderAs + "]" + " //" + msg; break; case MarketOrderAs.LimitTidal: order.Alert.MarketLimitStop = MarketLimitStop.Limit; msg = "PreSubmit: doing nothing for Alert.MarketOrderAs=[" + order.Alert.MarketOrderAs + "]" + " //" + msg; break; default: msg = "no handler for Market Order with Alert.MarketOrderAs[" + order.Alert.MarketOrderAs + "] // " + msg; OrderStateMessage newOrderState2 = new OrderStateMessage(order, OrderState.ErrorOrderInconsistent, msg); this.OrderProcessor.UpdateOrderStateAndPostProcess(order, newOrderState2); throw new Exception(msg); } //if (order.Alert.Bars.SymbolInfo.OverrideMarketPriceToZero == true) { //} else { // if (order.PriceRequested == 0) { // base.StreamingProvider.StreamingDataSnapshot.getAlignedBidOrAskTidalOrCrossMarketFromStreaming( // order.Alert.Symbol, order.Alert.Direction, out order.PriceRequested, out order.SpreadSide, ???); // order.PriceRequested += order.Slippage; // order.PriceRequested = order.Alert.Bars.alignOrderPriceToPriceLevel(order.PriceRequested, order.Alert.Direction, order.Alert.MarketLimitStop); // } //} //order.addMessage(new OrderStateMessage(order, order.State, msg)); //Assembler.PopupException(msg); break; case MarketLimitStop.Limit: order.SpreadSide = OrderSpreadSide.ERROR; switch (order.Alert.Direction) { case Direction.Buy: case Direction.Cover: if (priceBestBidAsk <= order.PriceRequested) order.SpreadSide = OrderSpreadSide.BidTidal; break; case Direction.Sell: case Direction.Short: if (priceBestBidAsk >= order.PriceRequested) order.SpreadSide = OrderSpreadSide.AskTidal; break; default: msg += " No Direction[" + order.Alert.Direction + "] handler for order[" + order.ToString() + "]" + "; must be one of those: Buy/Cover/Sell/Short"; //orderProcessor.updateOrderStatusError(order, OrderState.Error, msg); OrderStateMessage newOrderState = new OrderStateMessage(order, OrderState.Error, msg); this.OrderProcessor.UpdateOrderStateAndPostProcess(order, newOrderState); throw new Exception(msg); } break; case MarketLimitStop.Stop: case MarketLimitStop.StopLimit: order.SpreadSide = OrderSpreadSide.ERROR; switch (order.Alert.Direction) { case Direction.Buy: case Direction.Cover: if (priceBestBidAsk >= order.PriceRequested) order.SpreadSide = OrderSpreadSide.AskTidal; break; case Direction.Sell: case Direction.Short: if (priceBestBidAsk <= order.PriceRequested) order.SpreadSide = OrderSpreadSide.BidTidal; break; default: msg += " No Direction[" + order.Alert.Direction + "] handler for order[" + order.ToString() + "]" + "; must be one of those: Buy/Cover/Sell/Short"; //orderProcessor.updateOrderStatusError(order, OrderState.Error, msg); OrderStateMessage newOrderState = new OrderStateMessage(order, OrderState.Error, msg); this.OrderProcessor.UpdateOrderStateAndPostProcess(order, newOrderState); throw new Exception(msg); } break; default: msg += " No MarketLimitStop[" + order.Alert.MarketLimitStop + "] handler for order[" + order.ToString() + "]" + "; must be one of those: Market/Limit/Stop"; //orderProcessor.updateOrderStatusError(order, OrderState.Error, msg); OrderStateMessage omsg = new OrderStateMessage(order, OrderState.Error, msg); this.OrderProcessor.UpdateOrderStateAndPostProcess(order, omsg); throw new Exception(msg); } order.AppendMessage(msg); }
public virtual void OrderKillSubmitUsingKillerOrder(Order killerOrder) { if (string.IsNullOrEmpty(killerOrder.VictimGUID)) { throw new Exception("killerOrder.KillerForGUID=EMPTY"); } if (killerOrder.VictimToBeKilled == null) { throw new Exception("killerOrder.VictimToBeKilled=null"); } string msg = "State[" + killerOrder.State + "]" + " [" + killerOrder.Alert.Symbol + "/" + killerOrder.Alert.SymbolClass + "]" + " VictimToBeKilled.SernoExchange[" + killerOrder.VictimToBeKilled.SernoExchange + "]"; msg = Name + "::UsingKillerOrder(): " + msg; Assembler.PopupException(msg); OrderStateMessage omsgKiller = new OrderStateMessage(killerOrder, OrderState.KillerPreSubmit, msg); this.OrderProcessor.UpdateOrderStateAndPostProcess(killerOrder, omsgKiller); this.OrderKillSubmit(killerOrder.VictimToBeKilled); }
public void UpdateOrderStateNoPostProcess(Order order, OrderStateMessage newStateOmsg) { if (newStateOmsg.Order != order) { string msg = "sorry for athavism, but OrderStateMessage.Order should be equal to order here"; throw new Exception(msg); } if (order == null) { string msg = "how come ORDER=NULL?"; } if (order.Alert == null) { string msg = "how come ORDER.AlertNULL?"; } if (order.Alert.OrderFollowed != order) { string msg = "order.Alert.OrderFollowed[" + order.Alert.OrderFollowed + "] != order[" + order + "]"; //throw new Exception(msg); } if (order.State == newStateOmsg.State) { string msg = "Replace with AppendOrderMessage()! UpdateOrderStateNoPostProcess(): got the same OrderState[" + order.State + "]?"; throw new Exception(msg); } if (newStateOmsg.State == OrderState.Active) { bool signalled = order.MreActiveCanCome.WaitOne(-1); } OrderState orderStatePriorToUpdate = order.State; order.State = newStateOmsg.State; order.StateUpdateLastTimeLocal = newStateOmsg.DateTime; this.DataSnapshot.SwitchLanesForOrderPostStatusUpdate(order, orderStatePriorToUpdate); this.EventDistributor.RaiseOrderStateChanged(this, order); this.appendOrderMessageAndPropagate(order, newStateOmsg); if (order.State == OrderState.Submitted) { order.MreActiveCanCome.Set(); } }
void PostProcessVictimOrder(Order victimOrder, OrderStateMessage newStateOmsg) { this.UpdateOrderStateNoPostProcess(victimOrder, newStateOmsg); switch (victimOrder.State) { case OrderState.KillPending: case OrderState.SLAnnihilated: case OrderState.TPAnnihilated: break; case OrderState.Submitting: case OrderState.Active: case OrderState.Filled: break; case OrderState.Killed: if (victimOrder.FindStateInOrderMessages(OrderState.SLAnnihilated)) { this.UpdateOrderStateNoPostProcess(victimOrder, new OrderStateMessage(victimOrder, OrderState.SLAnnihilated, "Setting State to the reason why it was killed")); } if (victimOrder.FindStateInOrderMessages(OrderState.TPAnnihilated)) { this.UpdateOrderStateNoPostProcess(victimOrder, new OrderStateMessage(victimOrder, OrderState.TPAnnihilated, "Setting State to the reason why it was killed")); } Order killerOrder = victimOrder.KillerOrder; this.UpdateOrderStateNoPostProcess(killerOrder, new OrderStateMessage(killerOrder, OrderState.KillerDone, "Victim.Killed => Killer.KillerDone")); break; default: string msg = "no handler for victimOrder[" + victimOrder + "]'s state[" + victimOrder.State + "]" + "your BrokerProvider should call for Victim.States:{" //+ OrderState.KillSubmitting + "," + OrderState.KillPending + "," //+ OrderState.Killed + "," //+ OrderState.SLAnnihilated + "," //+ OrderState.TPAnnihilated + "}"; ; throw new Exception(msg); break; } }
void appendOrderMessageAndPropagate(Order order, OrderStateMessage omsg) { //log.Debug(omsg.Message); if (string.IsNullOrEmpty(omsg.Message)) { int a = 1; } omsg.Order.AppendMessageSynchronized(omsg); this.EventDistributor.RaiseOrderMessageAddedExecutionFormNotification(this, omsg); }
public void CancelReplaceOrder(Order orderToReplace, Order orderReplacement) { string msgVictim = "expecting callback on successful REPLACEMENT completion [" + orderReplacement + "]"; OrderStateMessage newOrderStateVictim = new OrderStateMessage(orderToReplace, OrderState.KillPending, msgVictim); this.UpdateOrderStateAndPostProcess(orderToReplace, newOrderStateVictim); orderReplacement.State = OrderState.Submitted; orderReplacement.IsReplacement = true; this.DataSnapshot.OrderAddSynchronizedAndPropagate(orderReplacement); if (orderToReplace.hasBrokerProvider("CancelReplaceOrder(): ") == false) { string msg = "CRAZY #65"; Assembler.PopupException(msg); return; } orderToReplace.Alert.DataSource.BrokerProvider.CancelReplace(orderToReplace, orderReplacement); this.DataSnapshot.SerializerLogrotateOrders.HasChangesToSave = true; this.DataSnapshot.UpdateActiveOrdersCountEvent(); }
bool IsOrderEatable(Order order) { if (order.Alert.Strategy == null) return true; if (order.IsKiller) return true; if (order.Alert.Direction == Direction.Sell || order.Alert.Direction == Direction.Cover) { return true; } Account account = null; if (account == null) return true; if (account.CashAvailable <= 0) { string msg = "ACCOUNT_CASH_ZERO"; OrderStateMessage newOrderState = new OrderStateMessage(order, OrderState.ErrorOrderInconsistent, msg); this.UpdateOrderStateAndPostProcess(order, newOrderState); return false; } return true; }
private void submitReplacementOrderFor(Order rejectedOrderToReplace) { Order replacement = this.createEmergencyCloseOrderInsteadOfRejected(rejectedOrderToReplace); if (replacement == null) { string msgNoReplacement = "got NULL from CreateEmergencyCloseOrderInsteadOfRejected() for (" + rejectedOrderToReplace + "); "; Assembler.PopupException(msgNoReplacement); this.orderProcessor.AppendOrderMessageAndPropagateCheckThrowOrderNull(rejectedOrderToReplace, msgNoReplacement); return; } try { this.OPPsequencer.ReplaceLockingCloseOrder(rejectedOrderToReplace, replacement); double priceScript = replacement.Alert.DataSource.StreamingProvider.StreamingDataSnapshot .GetAlignedBidOrAskForTidalOrCrossMarketFromStreaming( replacement.Alert.Bars.Symbol, replacement.Alert.Direction, out replacement.SpreadSide, true); replacement.Alert.PositionAffected.ExitPriceScript = priceScript; if (replacement.Alert.Bars.SymbolInfo.ReSubmittedUsesNextSlippage == true) { replacement.SlippageIndex++; } int emergencyCloseAttemptsMax = replacement.Alert.Bars.SymbolInfo.EmergencyCloseAttemptsMax; string serno = "#[" + replacement.EmergencyCloseAttemptSerno + "]/[" + emergencyCloseAttemptsMax + "]"; string msg_replacement = "This is an EMERGENCY replacement " + serno + " for order[" + replacement.EmergencyReplacementForGUID + "]; SlippageIndex[" + replacement.SlippageIndex + "]"; this.orderProcessor.AppendOrderMessageAndPropagateCheckThrowOrderNull(replacement, msg_replacement); if (replacement.hasSlippagesDefined && replacement.noMoreSlippagesAvailable) { addMessageNoMoreSlippagesAvailable(replacement); replacement.SlippageIndex = replacement.Alert.Bars.SymbolInfo.getSlippageIndexMax(replacement.Alert.Direction); } double slippage = replacement.Alert.Bars.SymbolInfo.getSlippage( priceScript, replacement.Alert.Direction, replacement.SlippageIndex, false, false); replacement.SlippageFill = slippage; replacement.PriceRequested = priceScript + slippage; string msg = "Scheduling SubmitOrdersThreadEntry [" + replacement.ToString() + "] slippageIndex[" + replacement.SlippageIndex + "] through [" + replacement.Alert.DataSource.BrokerProvider + "]"; OrderStateMessage omsg = new OrderStateMessage(replacement, OrderState.PreSubmit, msg); this.orderProcessor.UpdateOrderStateAndPostProcess(replacement, omsg); ThreadPool.QueueUserWorkItem(new WaitCallback(replacement.Alert.DataSource.BrokerProvider.SubmitOrdersThreadEntry), new object[] { new List<Order>() { replacement } }); } catch (Exception e) { Assembler.PopupException("Replacement wasn't submitted [" + replacement + "]", e); OrderStateMessage omsg2 = new OrderStateMessage(replacement, OrderState.Error, e.Message); this.orderProcessor.UpdateOrderStateAndPostProcess(replacement, omsg2); } }
private void closeEmergencyThreadEntry(Order rejectedExitOrder) { try { throwLogIfNotRejectedClosingOrder(rejectedExitOrder); throwLogAndAppendMessageIfNoEmergencyLockFor(rejectedExitOrder); throwLogAndAppendMessageIfNextAttemptReachesLimit(rejectedExitOrder); } catch (Exception) { return; } OrderState newState = rejectedExitOrder.ComplementaryEmergencyStateForError; string changeState = "ExitOrderCriticalState[" + rejectedExitOrder.State + "]=>[" + newState + "]"; int millis = rejectedExitOrder.Alert.Bars.SymbolInfo.EmergencyCloseDelayMillis; if (millis > 0) { string msg = "Emergency sleeping millis[" + millis + "] before " + changeState; OrderStateMessage omsg = new OrderStateMessage(rejectedExitOrder, newState, msg); this.orderProcessor.UpdateOrderStateAndPostProcess(rejectedExitOrder, omsg); Thread.Sleep(millis); } string msg2 = changeState + " after having slept millis[" + millis + "]"; if (rejectedExitOrder.State == newState) { // announced "sleeping xxx before" this.orderProcessor.AppendOrderMessageAndPropagateCheckThrowOrderNull(rejectedExitOrder, msg2); } else { // didnt announce "sleeping xxx before" OrderStateMessage omsg2 = new OrderStateMessage(rejectedExitOrder, newState, msg2); this.orderProcessor.UpdateOrderStateAndPostProcess(rejectedExitOrder, omsg2); } this.submitReplacementOrderFor(rejectedExitOrder); }
public void AppendMessageSynchronized(OrderStateMessage omsg) { //this.messages.Push(omsg); this.messages.Enqueue(omsg); }
public void RaiseOrderMessageAddedExecutionFormNotification(object sender, OrderStateMessage orderStateMessage) { if (this.OnOrderMessageAddedExecutionFormNotification == null) return; this.OnOrderMessageAddedExecutionFormNotification(sender, new OrderStateMessageEventArgs(orderStateMessage)); }
public void AppendOrderMessageAndRaiseOrderMessageAddedExecutionFormNotification(object sender, OrderStateMessage orderStateMessage) { orderStateMessage.Order.AppendMessageSynchronized(orderStateMessage); this.OrderEventDistributor.RaiseOrderMessageAddedExecutionFormNotification(sender, orderStateMessage); }
public void SubmitEatableOrdersFromGui(List<Order> orders) { List<Order> ordersEatable = new List<Order>(); foreach (Order order in orders) { if (this.IsOrderEatable(order) == false) continue; ordersEatable.Add(order); string msg = "Submitting Eatable Order From Gui"; OrderStateMessage newOrderState = new OrderStateMessage(order, OrderState.Submitting, msg); this.UpdateOrderStateAndPostProcess(order, newOrderState); } if (ordersEatable.Count > 0) { BrokerProvider broker = extractSameBrokerProviderThrowIfDifferent(ordersEatable, "SubmitEatableOrders(): "); broker.SubmitOrders(ordersEatable); } this.DataSnapshot.SerializerLogrotateOrders.HasChangesToSave = true; this.DataSnapshot.UpdateActiveOrdersCountEvent(); }
private void throwLogAndAppendMessageIfNextAttemptReachesLimit(Order rejectedExitOrder) { if (rejectedExitOrder.IsEmergencyClose == false) return; int emergencyCloseAttemptsMax = rejectedExitOrder.Alert.Bars.SymbolInfo.EmergencyCloseAttemptsMax; if (rejectedExitOrder.EmergencyCloseAttemptSerno + 1 < emergencyCloseAttemptsMax) return; string msg = "no more EmergencyCloseAttempts:" + " EmergencyCloseAttemptSerno[" + rejectedExitOrder.EmergencyCloseAttemptSerno + "]>= EmergencyCloseAttemptsMax[" + emergencyCloseAttemptsMax + "]" + " emergencyReplacement[" + rejectedExitOrder + "]"; OrderStateMessage omsg = new OrderStateMessage(rejectedExitOrder, OrderState.EmergencyCloseLimitReached, msg); this.orderProcessor.UpdateOrderStateAndPostProcess(rejectedExitOrder, omsg); throw new Exception(msg); }
public void KillOrderUsingKillerOrder(Order victimOrder) { Order killerOrder = this.CreateKillerOrder(victimOrder); //killerOrder.FromAutoTrading = false; if (killerOrder.hasBrokerProvider("KillOrder():") == false) { string msg = "CRAZY #63"; Assembler.PopupException(msg); return; }; string msgVictim = "expecting callback on successful KILLER completion [" + killerOrder + "]"; OrderStateMessage newOrderStateVictim = new OrderStateMessage(victimOrder, OrderState.KillPending, msgVictim); this.UpdateOrderStateAndPostProcess(victimOrder, newOrderStateVictim); killerOrder.Alert.DataSource.BrokerProvider.OrderKillSubmitUsingKillerOrder(killerOrder); }
private void throwLogIfEmergencyCloseInterrupted(Order replacementOrder) { Order reason4lock = this.GetReasonForLock(replacementOrder); lock (this.interruptedEmergencyLockReasons) { if (this.interruptedEmergencyLockReasons.Contains(reason4lock) == false) return; } string msg = "InterruptedEmergencyLockReasons.Contains reason4lock[" + reason4lock + "] for replacementOrder[" + replacementOrder + "]"; Assembler.PopupException(msg); OrderStateMessage newOrderStateRejected = new OrderStateMessage(replacementOrder, OrderState.EmergencyCloseUserInterrupted, msg); this.orderProcessor.UpdateOrderStateAndPostProcess(replacementOrder, newOrderStateRejected); throw new Exception(msg); }
public Order UpdateOrderStateByGuidNoPostProcess(string orderGUID, OrderState orderState, string message) { Order orderFound = this.DataSnapshot.OrdersSubmitting.FindByGUID(orderGUID); if (orderFound == null) { orderFound = this.DataSnapshot.OrdersAll.FindByGUID(orderGUID); } if (orderFound == null) { string msg = "order[" + orderGUID + "] wasn't found; OrderProcessorDataSnapshot.OrderCount=[" + this.DataSnapshot.OrderCountThreadSafe + "]"; throw new Exception(msg); //log.Fatal(msg, new Exception(msg)); //return; } OrderState orderStateAbsorbed = (orderState == OrderState.LeaveTheSame) ? orderFound.State : orderState; if (orderStateAbsorbed != orderFound.State) { OrderStateMessage osm = new OrderStateMessage(orderFound, orderStateAbsorbed, message); UpdateOrderStateNoPostProcess(orderFound, osm); } else { this.AppendOrderMessageAndPropagateCheckThrowOrderNull(orderFound, message); } return orderFound; }
public void SubmitReplacementOrderInsteadOfRejected(Order replacementOrder) { if (replacementOrder == null) { Assembler.PopupException("replacementOrder == null why did you call me?"); return; } if (replacementOrder.hasBrokerProvider("PlaceReplacementOrderInsteadOfRejected(): ") == false) { return; } string msg = "Scheduling SubmitOrdersThreadEntry [" + replacementOrder.ToString() + "] slippageIndex[" + replacementOrder.SlippageIndex + "] through [" + replacementOrder.Alert.DataSource.BrokerProvider + "]"; OrderStateMessage newOrderState = new OrderStateMessage(replacementOrder, OrderState.PreSubmit, msg); this.OrderProcessor.UpdateOrderStateAndPostProcess(replacementOrder, newOrderState); //this.BrokerProvider.SubmitOrdersThreadEntry(ordersFromAlerts); ThreadPool.QueueUserWorkItem(new WaitCallback(replacementOrder.Alert.DataSource.BrokerProvider.SubmitOrdersThreadEntry), new object[] { new List<Order>() { replacementOrder } }); //this.orderProcessor.UpdateActiveOrdersCountEvent(); }
public void AppendOrderMessageAndPropagateCheckThrowOrderNull(Order order, string msg) { if (order == null) { throw new Exception("order=NULL! you don't want to get NullPointerException and debug it"); } OrderStateMessage omsg = new OrderStateMessage(order, order.State, msg); this.appendOrderMessageAndPropagate(order, omsg); }
public void AddMessageNoMoreSlippagesAvailable(Order order) { int slippageIndexMax = order.Alert.Bars.SymbolInfo.getSlippageIndexMax(order.Alert.Direction); string msg2 = "Reached max slippages available for [" + order.Alert.Bars.Symbol + "]" + " order.SlippageIndex[" + order.SlippageIndex + "] > slippageIndexMax[" + slippageIndexMax + "]" + "; Order will have slippageIndexMax[" + slippageIndexMax + "]"; Assembler.PopupException(msg2); //orderProcessor.updateOrderStatusError(orderExecuted, OrderState.RejectedLimitReached, msg2); OrderStateMessage newOrderStateRejected = new OrderStateMessage(order, OrderState.RejectedLimitReached, msg2); this.OrderProcessor.UpdateOrderStateAndPostProcess(order, newOrderStateRejected); }
void PostProcessKillerOrder(Order killerOrder, OrderStateMessage newStateOmsg) { switch (killerOrder.State) { case OrderState.JustCreated: case OrderState.KillerPreSubmit: case OrderState.KillerSubmitting: case OrderState.KillerBulletFlying: case OrderState.KillerDone: this.UpdateOrderStateNoPostProcess(killerOrder, newStateOmsg); break; default: string msg = "no handler for killerOrder[" + killerOrder + "]'s state[" + killerOrder.State + "]" + "your BrokerProvider should call for Killer.States:{" + OrderState.KillerBulletFlying + "," + OrderState.KillerDone + "}"; break; //throw new Exception(msg); } }
public OrderStateMessageEventArgs(OrderStateMessage orderStateMessage) { this.OrderStateMessage = orderStateMessage; }
public void UpdateOrderStateAndPostProcess(Order order, OrderStateMessage newStateOmsg, double priceFill = 0, double qtyFill = 0) { string msig = "UpdateOrderStateAndPostProcess(): "; try { if (order.State == OrderState.Killed) { int a = 1; // crawl in debugger if I can find VictimOrder.Alert.Executor.Script.OnAlertKilledCallback //this.RemovePendingAlertsForVictimOrderMustBePostKill(order, msig); } if (order.VictimToBeKilled != null) { this.PostProcessKillerOrder(order, newStateOmsg); return; } if (order.KillerOrder != null) { this.PostProcessVictimOrder(order, newStateOmsg); return; } if (order.hasBrokerProvider("handleOrderStatusUpdate():") == false) { string msg = "most likely QuikTerminal.CallbackOrderStatus got something wrong..."; Assembler.PopupException(msg); return; } if (newStateOmsg.State == OrderState.Rejected && order.State == OrderState.EmergencyCloseLimitReached) { string prePostErrorMsg = "BrokerProvider CALLBACK DUPE: Status[" + newStateOmsg.State + "] delivered for EmergencyCloseLimitReached " //+ "; skipping PostProcess for [" + order + "]" ; this.AppendOrderMessageAndPropagateCheckThrowOrderNull(order, prePostErrorMsg); return; } if (newStateOmsg.State == OrderState.Rejected && order.InEmergencyState) { string prePostErrorMsg = "BrokerProvider CALLBACK DUPE: Status[" + newStateOmsg.State + "] delivered for" + " order.inEmergencyState[" + order.State + "] " //+ "; skipping PostProcess for [" + order + "]" ; this.AppendOrderMessageAndPropagateCheckThrowOrderNull(order, prePostErrorMsg); return; } OrderCallbackDupesChecker dupesChecker = order.Alert.DataSource.BrokerProvider.OrderCallbackDupesChecker; if (dupesChecker != null) { string why = dupesChecker.OrderCallbackDupeResonWhy(order, newStateOmsg, priceFill, qtyFill); if (string.IsNullOrEmpty(why) == false) { string msgChecker = "OrderCallbackDupeResonWhy[" + why + "]; skipping PostProcess for [" + order + "]"; this.AppendOrderMessageAndPropagateCheckThrowOrderNull(order, msgChecker); return; } } if (newStateOmsg.State == OrderState.Filled) { int a = 1; } /*if (qtyFill != 0) { if (order.QtyFill == 0 || order.QtyFill == -999) { order.QtyFill = qtyFill; } else { if (order.QtyFill != qtyFill && order.QtyFill != -qtyFill) { string msg = "got qtyFill[" + qtyFill + "] while order.QtyFill=[" + order.QtyFill + "]; skipping update; trying to figure out why Filled orders get ZERO price from QUIK"; order.AppendMessage(msg); } } }*/ if (priceFill != 0) { if (order.PriceFill == 0 || order.PriceFill == -999.99) { order.PriceFill = priceFill; order.QtyFill = qtyFill; } else { bool marketWasSubstituted = order.Alert.MarketLimitStop == MarketLimitStop.Limit && order.Alert.Bars.SymbolInfo.MarketOrderAs == MarketOrderAs.MarketMinMaxSentToBroker; if (order.PriceFill != priceFill && marketWasSubstituted == false) { string msg = "got priceFill[" + priceFill + "] while order.PriceFill=[" + order.PriceFill + "]" + "; weird for Order.Alert.MarketLimitStop=[" + order.Alert.MarketLimitStop + "]"; order.AppendMessage(msg); } } } this.UpdateOrderStateNoPostProcess(order, newStateOmsg); this.PostProcessOrderState(order, priceFill, qtyFill); } catch (Exception e) { string msg = "trying to figure out why SL is not getting placed - we didn't reach PostProcess??"; this.PopupException(new Exception(msg, e)); } }
public override string OrderCallbackDupeResonWhy( Order order, OrderStateMessage newStateOmsg, double priceFill, double qtyFill) { return null; }
public virtual void OrderPreSubmitEnrichCheckThrow(Order order) { string msg = Name + "::OrderPreSubmitChecker():" + " Guid[" + order.GUID + "]" + " SernoExchange[" + order.SernoExchange + "]" + " SernoSession[" + order.SernoSession + "]"; if (this.StreamingProvider == null) { msg = " StreamingProvider=null, can't get last/fellow/crossMarket price // " + msg; OrderStateMessage newOrderState = new OrderStateMessage(order, OrderState.ErrorOrderInconsistent, msg); this.OrderProcessor.UpdateOrderStateAndPostProcess(order, newOrderState); throw new Exception(msg); } try { this.checkOrderThrowInvalid(order); } catch (Exception ex) { msg = ex.Message + " //" + msg; //orderProcessor.updateOrderStatusError(order, OrderState.ErrorOrderInconsistent, msg); OrderStateMessage newOrderState = new OrderStateMessage(order, OrderState.ErrorOrderInconsistent, msg); this.OrderProcessor.UpdateOrderStateAndPostProcess(order, newOrderState); throw new Exception(msg, ex); } order.CurrentBid = this.StreamingProvider.StreamingDataSnapshot.BestBidGetForMarketOrder(order.Alert.Symbol); order.CurrentAsk = this.StreamingProvider.StreamingDataSnapshot.BestAskGetForMarketOrder(order.Alert.Symbol); this.OrderPreSubmitEnrichBrokerSpecificInjection(order); // moved to orderProcessor::CreatePropagateOrderFromAlert() // this.ModifyOrderTypeAccordingToMarketOrderAs(order); if (order.Alert.Strategy.Script != null) { Order reason4lock = this.OrderProcessor.OPPemergency.GetReasonForLock(order); bool isEmergencyClosingNow = (reason4lock != null); //bool positionWasFilled = this.orderProcessor.positionWasFilled(order); if (order.Alert.IsEntryAlert && isEmergencyClosingNow) { // && positionWasFilled //OrderState IRefuseUntilemrgComplete = this.orderProcessor.OPPemergency.getRefusalForEmergencyState(reason4lock); OrderState IRefuseUntilemrgComplete = OrderState.IRefuseOpenTillEmergencyCloses; msg = "Reason4lock: " + reason4lock.ToString(); OrderStateMessage omsg = new OrderStateMessage(order, IRefuseUntilemrgComplete, msg); this.OrderProcessor.UpdateOrderStateAndPostProcess(order, omsg); throw new Exception(msg); } } }
public abstract string OrderCallbackDupeResonWhy( Order order, OrderStateMessage newStateOmsg, double priceFill, double qtyFill);
internal bool AnnihilateCounterpartyAlert(Alert alert) { if (alert.OrderFollowed == null) { string msg = "can't AnnihilateCounterparty: OrderFollowed=null for alert=[" + alert + "]"; throw new Exception(msg); //this.executor.ThrowPopup(new Exception(msg)); } if (alert.PositionAffected == null) { string msg = "can't AnnihilateCounterparty: PositionAffected=null for alert=[" + alert + "]"; throw new Exception(msg); //this.executor.ThrowPopup(new Exception(msg)); } if (alert.IsEntryAlert) { string msg = "can't AnnihilateCounterparty: alert.isEntryAlert for alert=[" + alert + "]"; throw new Exception(msg); //this.executor.ThrowPopup(new Exception(msg)); } OrderStateMessage newOrderState = null; if (alert.PositionAffected.ClosedByTakeProfitLogically) { //copy from dispatcher (caller of a caller) string msg = "position ClosedByTakeProfit@" + alert.PriceScript + ", annihilating StopLoss"; newOrderState = new OrderStateMessage(alert.OrderFollowed, OrderState.SLAnnihilated, msg); } else { string msg = "position ClosedByStopLoss@" + alert.PriceScript + ", annihilating TakeProfit"; newOrderState = new OrderStateMessage(alert.OrderFollowed, OrderState.TPAnnihilated, msg); } executor.OrderProcessor.UpdateOrderStateNoPostProcess(alert.OrderFollowed, newOrderState); executor.OrderProcessor.KillOrderUsingKillerOrder(alert.OrderFollowed); //this.executor.RemovePendingExitAlert(alert, "MarketRealtime:AnnihilateCounterparty(): "); bool removed = this.executor.ExecutionDataSnapshot.AlertsPendingRemove(alert); return true; }