// // public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer) { if (ParentStrategy != null) { m_QuoteTickSize = ParentStrategy.m_OrderEngine.QuoteTickSize; } }
protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui) { base.SetupInitialize(myEngineHub, engineContainer, engineID, setupGui); m_Hub = (Hub)myEngineHub; this.m_Log = m_Hub.Log; // set up our logging this.m_ExecutionContainer = (ExecutionContainer)engineContainer; }
protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui) { base.SetupInitialize(myEngineHub, engineContainer, engineID, setupGui); m_StrategyHub = (StrategyHub)myEngineHub; this.m_Log = m_StrategyHub.Log; // set up our logging this.m_Market = m_StrategyHub.m_Market; // grab the market so we can have some instrument details }
// // **** Setup Initialize() **** // /// <summary> /// This is called by the local execution hub thread. /// </summary> /// <param name="hub"></param> public void SetupInitialize(IEngineHub hub) { // Keep pointers to my local hub. m_LocalEngineHub = hub; m_LocalEngineHubName = hub.ServiceName; Log = ((Hub)m_LocalEngineHub).Log; // Initialize all my engines. int ptr = 0; while (ptr < m_IEngineList.Count) { if (m_IEngineList[ptr] is Engine) { Engine engine = (Engine)m_IEngineList[ptr]; engine.SetupInitialize(hub, this, engine.EngineID); } ptr++; } m_ConfirmSynthOrderEventArg.Status = EngineEventArgs.EventStatus.Confirm; // create reusable event arg. m_ConfirmSynthOrderEventArg.EngineHubName = this.RemoteEngineHub.ServiceName; m_ConfirmSynthOrderEventArg.EngineContainerID = this.EngineContainerID; m_ConfirmSynthOrderEventArg.MsgType = EngineEventArgs.EventType.SyntheticOrder; m_ConfirmSynthOrderEventArg.DataObjectList = new List <object>(); }// SetupInitialize()
// // public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer) { base.SetupBegin(myEngineHub, engineContainer); foreach (IEngine ieng in engineContainer.GetEngines()) { // Find order Engine if (ieng is IOrderEngine) { this.m_IOrderEngine = (IOrderEngine)ieng; // find our order engine } } if (m_IOrderEngine is SingleLegExecutor) { // if this is a single leg order engine m_SingleLegExecutor = (SingleLegExecutor)m_IOrderEngine; this.m_Leg = m_SingleLegExecutor.m_PriceLeg; m_MaxPossibleWorkingQuoteQtyPerLot += (int)(Math.Abs(m_Leg.Weight) * 2); // leg ratios * 2 (each side) } // If we subscribe to order book creation, we can be sure to get all the info for all fills and submissions // this only works if create order books after setup beging. m_IOrderEngine.GetExecutionListener().OrderBookCreated += new EventHandler(ExecutionListener_OrderBookCreated); if (m_Hub is ExecutionHub) { // set up ITimer to work ((ExecutionHub)m_Hub).SubscribeToTimer((ITimerSubscriber)m_ExecutionContainer.m_ExecutionListener); m_ExecutionContainer.m_ExecutionListener.SubscribeToTimer(this); // subscrie to updates } }
// // // **** SetupBegin() **** // public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer) { base.SetupBegin(myEngineHub, engineContainer); m_Parent = (Strategy)engineContainer; Log = ((Hub)myEngineHub).Log; // Get Engines of interest. int modelCounter = 0; foreach (IEngine ieng in m_Parent.GetEngines()) { if (ieng is ZGraphEngine) { if (m_GraphEngine == null) { m_GraphEngine = (ZGraphEngine)ieng; // take first found graph engine to draw to. } } else if (ieng is ModelEngine) { if (ieng == this) { m_ModelEngineID = modelCounter; } // store the number of models in front of me (use as my id!) modelCounter++; } } }//SetupBegin()
// // ***************************************** // **** Setup Begin() **** // ***************************************** /// <summary> /// This is called after all Engines have been created, and added to the master /// list inside the Strategy (IEngineContainer). /// As a convenience, the PricingEngine class locates useful Engines and keeps /// pointers to them. /// </summary> /// <param name="myEngineHub"></param> /// <param name="engineContainer"></param> public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer) { base.SetupBegin(myEngineHub, engineContainer); // Locate engines we need. m_MarketSubscribers = new List <IMarketSubscriber>(); foreach (IEngine iEngine in engineContainer.GetEngines()) { if (iEngine is ZGraphEngine) { m_GraphEngine = (ZGraphEngine)iEngine; // PricingEngines also plot a lot. } else if (iEngine is IMarketSubscriber) { m_MarketSubscribers.Add((IMarketSubscriber)iEngine); } } // // Subscribe to Pricing instruments. // List <InstrumentName> instruments = new List <InstrumentName>(); foreach (PriceLeg leg in m_Legs) // Subscribe to each "PricingLeg" object. { instruments.Add(leg.InstrumentName); } this.ParentStrategy.StrategyHub.SubscribeToMarketInstruments(instruments, this.ParentStrategy); }//SetupBegin()
// // // ****************************************************** // **** Setup Initialize() **** // ****************************************************** /// <summary> /// Since we are a specialized gui manager, we override SetupInitialize() /// and don't create a default popup gui. /// </summary> /// <param name="myEngineHub"></param> /// <param name="engineContainer"></param> /// <param name="engineID"></param> /// <param name="isSetupGui"></param> protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool isSetupGui) { base.SetupInitialize(myEngineHub, engineContainer, engineID, false);// call base class first. m_Parent = (Strategy)engineContainer; m_ParentEngineContainerID = engineContainer.EngineContainerID; Log = m_Parent.StrategyHub.Log; // Set the plotting hour offset. m_StartTime = m_Parent.StrategyHub.GetLocalTime(); m_StartHour = m_StartTime.Hour + m_StartTime.Minute / 60.0 + m_StartTime.Second / 3600.0; if (m_StartHour >= 16.0) { m_StartHour -= 24.0; // after 4pm, shift to negative numbers (new trading day). } // // Add our custom ZGraphControl template // UV.Lib.FrontEnds.GuiTemplates.EngineGui engineGui = new Lib.FrontEnds.GuiTemplates.EngineGui(); engineGui.DisplayName = "Graph"; engineGui.EngineID = this.m_EngineID; engineGui.EngineFullName = this.GetType().FullName; engineGui.HeaderControlFullName = typeof(UV.Lib.FrontEnds.Graphs.ZGraphControl).FullName; engineGui.ParameterList.AddRange(this.m_PInfo); m_EngineGuis.Add(engineGui); }//SetupInitialize()
// // // **** Setup Begin() **** // public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer) { base.SetupBegin(myEngineHub, engineContainer); m_Name = base.EngineName; m_Parent = (Strategy)engineContainer; this.Log = ((StrategyHub)myEngineHub).Log; }//SetupBegin()
// #endregion//Properties #region Public Initialization Methods // ***************************************************************** // **** Public Initialization **** // ***************************************************************** // // // **************************************** // **** Setup Initialize() **** // **************************************** /// <summary> /// The Strategy has been created, and now we add its engines. /// When we call Engine.SetupInitialize() the engine can make NO assumptions /// about the Strategy, except that it and its StrategyHub exists. /// Other Engines may or may not exist. /// What is allowed is that Engines can spawn other Engines and add them /// to the *end* of the Strategy.m_Engines[] list freely. /// </summary> public void SetupInitialize(IEngineHub myHub) { StrategyHub = (StrategyHub)myHub; // store ptr to new parent hub. // First initialize each of my engines. int id = 0; while (id < m_Engines.Count) // Loop using while so that Engines can ADD new engines to end of list. { // Adding new engines spontaneously is allowed here only. Engine engine = m_Engines[id]; engine.SetupInitialize(StrategyHub, this, id); // Tell Engine his new Hub, and owner, and his new id#. // Keep track of important engine ptrs we need. if (engine is Engines.PricingEngine) // using simple "if"s allows one engine to play multiple roles. { m_PricingEngine = (Engines.PricingEngine)engine; } if (engine is IOrderEngine) { m_OrderEngine = (IOrderEngine)engine; } if (engine is ZGraphEngine) { m_GraphEngine = (ZGraphEngine)engine; } id++; } //next engine id m_IsInitializeComplete = true; // after this point if engines are added, they have to manually Initialize } //SetupInitialize()
}//SetupInitialize() // // // **************************************** // **** Setup Begin() **** // **************************************** /// <summary> /// The setup phase continues. /// Here, the Strategy and each of its engines have been created, and labeled. /// /// Strategy may attempt to find the resources and other dependences it requires to run. /// Engine are free to look for each other now. /// This method is called after ALL strategies have been created (and their engines), and /// after SetupInitialize(). The purpose of this is that /// by this time, engine can be assured that there exists a complete list of all /// strategies and engines available. They can find specific engines (of other strategies) /// that they need to link to, and make those initial linkages. /// /// While not ideal, if an engine must add another one during this process it is still /// possible however it is much better to add them during SetupInitialize. /// TODO: /// 1) To prevent multithread problems in future, Strategy must ask for pointer to /// another strategy, and this is monitored by hub, and pricing engines are /// ordered in tiers using this information. /// </summary> public void SetupBegin(IEngineHub myHub) { foreach (Engine engine in m_Engines) { engine.SetupBegin(myHub, this); } m_IsBeginComplete = true; }//end Initialize()
// // protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui) { base.SetupInitialize(myEngineHub, engineContainer, engineID, setupGui); ExecutionContainer execContainer = (ExecutionContainer)engineContainer; execContainer.TryAddEngine(m_Hedger); // add my sub engines to the container. execContainer.TryAddEngine(m_HedgeRuleManager); }
}//SetupInitialize() // // // ************************************************* // **** SetupBegin() **** // ************************************************* public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer) { base.SetupBegin(myEngineHub, engineContainer); // ParentStrategy.StrategyHub.SubscribeToTimer(ParentStrategy, this); // ParentStrategy.m_OrderEngine.QuoteTickSize = m_QuoteTickSize; // set our quote tick size for proper rounding }
// // public void BroadcastParameter(IEngineHub hub, IEngineContainer parent, string parameterName) { int id = GetParameterId(parameterName); if (id > -1) { BroadcastParameter(hub, parent, id); } }
protected ConcurrentQueue <EventArgs> m_InQueue = new ConcurrentQueue <EventArgs>(); // threadsafe queue to push events to processed onto. #endregion //members #region Constructors // ***************************************************************** // **** Constructors **** // ***************************************************************** public ExecutionListener(string name, IEngineHub engineHub) { m_EngineHub = engineHub; if (engineHub is Hub) { this.Log = ((Hub)engineHub).Log; } m_Name = name; }
// // ***************************************** // **** Setup Initialize() **** // ***************************************** protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui) { base.SetupInitialize(myEngineHub, engineContainer, engineID, setupGui); // // Keep pointers to important objects. // this.ParentStrategy = (Strategy)engineContainer; this.Log = ((Hub)myEngineHub).Log; // Pricing engines tend to log a lot, so keep a pointer. }
// // // // // **************************************** // **** Setup Initialize() **** // **************************************** /// <summary> /// The Strategy has been created, and now we add its engines. /// When we call Engine.SetupInitialize() the engine can make NO assumptions /// about the Strategy, except that it and its StrategyHub exists. /// Other Engines may or may not exist. /// What is allowed is that Engines can spawn other Engines and add them /// to the *end* of the Strategy.m_Engines[] list freely. /// </summary> public void SetupInitialize(IEngineHub myHub) { StrategyHub = (StrategyHub)myHub; // store ptr to new parent hub. // First initialize each of my engines. int id = 0; while (id < m_Engines.Count) // Loop using while so that Engines can ADD new engines to end of list. { // Adding new engines spontaneously is allowed here only. Engine engine = m_Engines[id]; engine.SetupInitialize(StrategyHub, this, id); // Tell Engine his new Hub, and owner, and his new id#. // Keep track of important engine ptrs we need. if (engine is PricingEngine) // using simple "if"s allows one engine to play multiple roles. { PricingEngines.Add((PricingEngine)engine); //m_PricingEngine = (StrategyEngines.PricingEngine)engine; } if (engine is TradeEngine) { m_OrderEngine = (TradeEngine)engine; } if (engine is ZGraphEngine) { m_GraphEngine = (ZGraphEngine)engine; } if (engine is FauxQuote) { m_QuoteEngine = (FauxQuote)engine; } id++; }//next engine id // Create missing basic engines if (m_OrderEngine == null) { m_OrderEngine = new TradeEngine(); TryAddEngine(m_OrderEngine, myHub); m_OrderEngine.SetupInitialize(StrategyHub, this, -1);// Tell Engine his new Hub, and owner, and his new id# (which is already set in TryAddEngine()). } if (m_GraphEngine == null) { m_GraphEngine = new ZGraphEngine(); TryAddEngine(m_GraphEngine, myHub); m_GraphEngine.SetupInitialize(StrategyHub, this, -1); } if (m_QuoteEngine == null) { QuoteEngine quoteEngine = new QuoteEngine(); m_QuoteEngine = quoteEngine; TryAddEngine(quoteEngine, myHub); quoteEngine.SetupInitialize(StrategyHub, this, -1); } // Exit m_IsInitializeComplete = true; // Must be last line in this method. }//SetupInitialize()
// // ***************************************** // **** Setup Initialize() **** // ***************************************** protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui) { base.SetupInitialize(myEngineHub, engineContainer, engineID, setupGui); // Keep pointers to important objects. this.ParentStrategy = (Strategy)engineContainer; // TODO: Locate the Alarm service. }
// // // ************************************************ // **** SetupInitialize() **** // ************************************************ /// <summary> /// This is called immediately after construction, when we add this engine to its strategy. /// During this call the Parameter tables *must* be created, and all *Gui Templates* must be /// created. /// If an Engine wants to create additional Engines, it should be done here. Since *after* /// this initialize call (that is, during the SetupBegin() call), Engines can assume that all /// other Engines have been created and added to the EngineList of the WStrategy. /// The short explanation: /// Setup Initialize: Strategy, StrategyHub and other ApplicationServices exist. /// Setup Begin: All Engines within my Strategy exist, and were SetupInitialize(). /// Setup Complete: All Engines in all Strategies exist and were SetUpBegin(). /// Note: /// 1) At this point, the Strategy has been created, but possibly no others. /// 2) The other engines in the Strategy may also not be created at this point. /// * Therefore, Engines should not look for other Strategies of other Engines. /// 3) Subclasses should call this base-class method FIRST (so engineID is set) before other implementations. /// </summary> public void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID) { if (engineID >= 0) // If engineID provide is positive, then { m_EngineID = engineID; // accept ID provided by my parent Strategy. Otherwise leave it alone. } // This is useful when its assigned at construction time already. m_Parent = engineContainer; SetupInitialize(myEngineHub, engineContainer, engineID, true); // default is to creaet the default Gui templates. }// SetupInitialize()
// // // // protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui) { base.SetupInitialize(myEngineHub, engineContainer, engineID, setupGui); // Request historic data for plots. DateTime end = ParentStrategy.StrategyHub.GetLocalTime(); DateTime start = end.AddHours(-m_NHoursHistoricData); // TODO: allow this to passed in as istringifiable param? base.RequestHistoricData(start, end); m_IEngineHub = myEngineHub; }
// // ********************************************* // **** SetUp Initialize() **** // ********************************************* /// <summary> /// </summary> protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui) { // Save information about local strategy hub. m_EngineContainerId = engineContainer.EngineContainerID; if (myEngineHub is IService) { m_LocalEngineHubName = ((IService)myEngineHub).ServiceName; } StrategyHub strategyHub = ((StrategyHub)myEngineHub); this.Log = strategyHub.Log; m_LocalEngineHub = myEngineHub; // Locate our target remote hub/service. IEngineHub remoteEngineHub = null; EventHandler del = new EventHandler(ProcessRemoteEngineEvents); if (strategyHub.SubscribeToRemoteEngineHub("ExecutionHub", m_EngineContainerId, m_EngineID, del, out remoteEngineHub)) { m_RemoteEngineHub = remoteEngineHub; } else { throw new Exception("Failed to locate remote hub."); } // Create the parameter table. Type remoteEngineType; if (Stringifiable.TryGetType(m_RemoteEngineClassName, out remoteEngineType)) { this.m_PInfo = CreateParameterInfo(myEngineHub, engineContainer.EngineContainerID, this.EngineID, remoteEngineType); } // // Add sub-engines to the parent Strategy // // They will be automatically initialized outside in StrategyHub loop // that called us, since we will add new engine to the end of the list we are looping thru now. List <IStringifiable> subElements = m_Node.GetElements(); if (subElements != null) { foreach (IStringifiable iObject in subElements) { // Engines that are beneath non-engines will not be found here. if (iObject is ExecutionController) // This remote engine will not need to broad its existance, { ExecutionController subEngine = (ExecutionController)iObject; subEngine.m_IsSubEngine = true; // since it will be included in another engine (this one). ((Strategy)engineContainer).TryAddEngine(subEngine, myEngineHub); } } } }//SetupInitialize()
// // #endregion//Public Methods #region no Private Methods // ***************************************************************** // **** Private Methods **** // ***************************************************************** // // #endregion//Private Methods #region Event Handlers // ***************************************************************** // **** Event Handlers **** // ***************************************************************** // // // ***************************************************************** // **** ExecutionListener_Initialized() **** // ***************************************************************** /// <summary> /// Called once dispatcher is attached to thread allowing us to finish our setup. /// </summary> /// <param name="sender"></param> /// <param name="eventArgs"></param> private void ExecutionListener_Initialized(object sender, EventArgs eventArgs) { IEngineHub iEngHub = (IEngineHub)m_Hub; // cast our generic hub to an Ieng hub //foreach (Engine eng in m_ExecutionContainer.EngineList.Values) // call all engine's begin, now we are on the right thread! // eng.SetupBegin(iEngHub, m_ExecutionContainer); //foreach (Engine eng in m_ExecutionContainer.EngineList.Values) // call all engine's complete // eng.SetupComplete(); this.SetupBegin(iEngHub, m_ExecutionContainer); this.SetupComplete(); }
// // public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer) { base.SetupBegin(myEngineHub, engineContainer); if (myEngineHub is ExecutionHub) { // set up ITimer to work ThreadContainer execContainer = (ThreadContainer)engineContainer; ((ExecutionHub)myEngineHub).SubscribeToTimer((ITimerSubscriber)execContainer.m_ExecutionListener); execContainer.m_ExecutionListener.SubscribeToTimer(this); // subscribe to updates } }
// // ***************************************** // **** Setup Initialize() **** // ***************************************** protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui) { base.SetupInitialize(myEngineHub, engineContainer, engineID, false); EngineGui engineGui = base.SetupGuiTemplates(); if (engineContainer is Strategy) { ParentStrategy = (Strategy)engineContainer; Log = ParentStrategy.StrategyHub.Log; } m_Services = AppServices.GetInstance(); }
private Dictionary <int, int> m_OppositeOrderIDToIPrice = new Dictionary <int, int>(); // map order ids to IPrice we want to scratch #endregion // members #region Constructors // ***************************************************************** // **** Constructors **** // ***************************************************************** // protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui) { this.m_EngineName = string.Format("Scratcher:{0}", m_PriceLeg.InstrumentName); if (typeof(UV.Strategies.ExecutionHubs.ExecutionContainers.MultiThreadContainer).IsAssignableFrom(engineContainer.GetType())) { // this is the "first" set up call from the manager container. base.SetupInitialize(myEngineHub, engineContainer, engineID, setupGui); m_Log = ((ExecutionHubs.ExecutionHub)myEngineHub).Log; // keep pointer to log } else { // this is the second set up call from the correct container, add correct sub engine mappings } }
// public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer) { base.SetupBegin(myEngineHub, engineContainer); foreach (IEngine eng in engineContainer.GetEngines()) { if (eng is IOrderEngine) { // find our orer engine and our execution listner m_ExecutionListener = ((IOrderEngine)eng).GetExecutionListener(); continue; } } }
// public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer) { base.SetupBegin(myEngineHub, engineContainer); m_Log = ((ExecutionHub)myEngineHub).Log; foreach (IEngine iEng in engineContainer.GetEngines()) {// find our needed engine pointers if (iEng is ExecutionEngines.OrderEngines.Spreader) { m_Quoter = (ExecutionEngines.OrderEngines.Spreader)iEng; } } }
private OrderEventArgs m_OrderEventArg; // careful, but this is always recycled #endregion // members #region Constructors // ***************************************************************** // **** Constructors **** // ***************************************************************** // // protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui) { if (typeof(UV.Strategies.ExecutionHubs.ExecutionContainers.MultiThreadContainer).IsAssignableFrom(engineContainer.GetType())) { // this is the "first" set up call from the manager container. base.SetupInitialize(myEngineHub, engineContainer, engineID, setupGui); m_Log = ((ExecutionHubs.ExecutionHub)myEngineHub).Log; } else { // this is the second set up call from the correct container, add correct sub engine mappings m_ExecutionContainer = (ThreadContainer)engineContainer; } }
}//SetupInitialize() // // // // // ************************************************ // **** SetupBegin() **** // ************************************************ /// <summary> /// </summary> public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer) { // // Master Remote-Engines must send requests to ExecutionHub now. // if (m_IsSubEngine == false) { // Count number of (master) remote engines found in this strategy. // Master remote engines are those connected directly to the Strategy, // without being held by another engine. // Only masters broadcast their xml to the ExecutionHub, and other sub-engine // engines are included as subelements of their master's broadcast. // (If each remote engine broadcasted separately, the ExecHub would have to know how // to put them all back together again... that is, who owned whom.) int remoteMasterEngineCount = 0; foreach (IEngine iEng in engineContainer.GetEngines()) { if (iEng is ExecutionController && ((ExecutionController)iEng).m_IsSubEngine == false) { remoteMasterEngineCount++; } //if (iEng is RemoteEngine) // now count all remote engines // remoteMasterEngineCount++; } // // Create my engine creation request // Dictionary <Type, string[]> rules = new Dictionary <Type, string[]>(); rules.Add(this.GetType(), new string[] { "GetClassName", string.Empty, string.Empty }); string xmlString = Stringifiable.Stringify(this, rules); EngineEventArgs e = new EngineEventArgs(); e.MsgType = EngineEventArgs.EventType.NewEngine; e.Status = EngineEventArgs.EventStatus.Request; e.EngineID = m_EngineID; e.EngineContainerID = m_EngineContainerId; e.DataObjectList = new List <object>(); e.DataObjectList.Add(xmlString); // 0 - engine specs e.DataObjectList.Add(m_LocalEngineHubName); // 1 - engine hub name e.DataObjectList.Add(remoteMasterEngineCount.ToString()); // 2 - number of engines remote hub should expect from this EngineContainer // Send request to remote. if (m_RemoteEngineHub != null && m_RemoteEngineHub.HubEventEnqueue(e)) { Log.NewEntry(LogLevel.Minor, "SetupBegin: Remote-{0} sent creation request to remote.", m_RemoteEngineClassName); } else { Log.NewEntry(LogLevel.Minor, "SetupBegin: Remote-{0} failed to send creation request to remote.", m_RemoteEngineClassName); } } // master remote-engine sends request. } //SetupBegin()
// // ************************************************************* // **** Setup Initialize() **** // ************************************************************* /// <summary> /// Since I depend critically on an OrderBookHub, I will look for them now. /// </summary> /// <param name="myEngineHub"></param> /// <param name="engineContainer"></param> /// <param name="engineID"></param> /// <param name="setupGui"></param> protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui) { base.SetupInitialize(myEngineHub, engineContainer, engineID, false); EngineGui engineGui = base.SetupGuiTemplates(); engineGui.LowerHudFullName = typeof(OrderEngineHud).FullName; // Collect services that I need. m_Hub = (Hub)myEngineHub; this.Log = m_Hub.Log; m_ExecutionContainer = (ThreadContainer)engineContainer; }// SetupInitialize()