/// <summary> /// This is called asynchronously by the TTService worker thread. It then creates and /// attaches a Dispatcher for itself, and calls the InitAPI() method. This creates a /// queue for the TTService worker thread, which keeps it alive after processing requests. /// </summary> private void StartInitAPI() { if (m_Dispatcher == null) { m_Dispatcher = Dispatcher.AttachWorkerDispatcher(); } m_Dispatcher.BeginInvoke(new Action(InitAPI)); try { // this is a blocking statement, the thread will return here whenever a call is returned. m_Dispatcher.Run(); // This keeps the thread alive at the end of a return. } catch (Exception e) { if (m_Log != null) { m_Log.NewEntry(LogLevel.Error, "StartInitAPI: Error. Failed to start TT API. {0}", e.Message); } if (m_AlertManager != null) { m_AlertManager.RequestEmailAlert(AlertLevel.High, "StartInitAPI: Error. Failed to start TT API. {0}", e.Message); } Thread.Sleep(2000); // worker should sleep, then try to restart. StartInitAPI(); // try again. } }// StartInitAPI().
/// <summary> /// Create and start the Dispatcher /// </summary> public void Start() { // Attach a WorkerDispatcher to the current thread m_disp = Dispatcher.AttachWorkerDispatcher(); m_disp.BeginInvoke(new Action(Init)); m_disp.Run(); }
public void SubscribeToInstrument(InstrumentDescriptor descriptor) { if (_dispatcher.InvokeRequired()) { _dispatcher.BeginInvoke(() => { SubscribeToInstrument(descriptor); }); return; } InstrumentLookupSubscription req = new InstrumentLookupSubscription(_apiSession, Dispatcher.Current, descriptor.ProductKey, descriptor.ContractName); req.Update += new EventHandler <InstrumentLookupSubscriptionEventArgs>(instrumentLookupRequest_Update); req.Start(); }
public void CreateOrderSubscription() { if (_dispatcher.InvokeRequired()) { _dispatcher.BeginInvoke(() => { CreateOrderSubscription(); }); return; } Dispatcher dispatcher = Dispatcher.Current; Console.WriteLine("Creating Order Subscription..."); _ts = new TradeSubscription(_apiSession, dispatcher); _ts.OrderBookDownload += new EventHandler <OrderBookDownloadEventArgs>(ts_OrderBookDownload); _ts.OrderAdded += new EventHandler <OrderAddedEventArgs>(ts_OrderAdded); _ts.OrderUpdated += new EventHandler <OrderUpdatedEventArgs>(ts_OrderUpdated); _ts.OrderDeleted += new EventHandler <OrderDeletedEventArgs>(ts_OrderDeleted); _ts.OrderFilled += new EventHandler <OrderFilledEventArgs>(ts_OrderFilled); _ts.OrderStatusUnknown += new EventHandler <OrderStatusUnknownEventArgs>(ts_OrderStatusUnknown); _ts.OrderRejected += new EventHandler <OrderRejectedEventArgs>(ts_OrderRejected); //ts.EnablePNL = true; //ts.ProfitLossChanged += new EventHandler<ProfitLossChangedEventArgs>(ts_ProfitLossChanged); _ts.Start(); Console.WriteLine("Order Subscription created."); }
}//Dispose() // // #endregion//Public Methods #region Private Startup and Shutdown Methods // ***************************************************************** // **** Private Methods **** // ***************************************************************** /// <summary> /// Called from constructor to capture the PriceListener thread. He is captured once /// he creates a Dispatcher and calls an invoke on himself. /// </summary> private void InitializeThread() { m_Dispatcher = TradingTechnologies.TTAPI.Dispatcher.AttachWorkerDispatcher(); m_Dispatcher.BeginInvoke(new Action(InitComplete)); m_Dispatcher.Run(); // this tells thread to do this and wait. }
/// <summary> /// Create and start the Dispatcher /// </summary> public void Start() { cout("TengineTT::Start: Attaching dispatcher..."); // Attach a WorkerDispatcher to the current thread m_disp = Dispatcher.AttachWorkerDispatcher(); m_disp.BeginInvoke(new Action(Init)); m_disp.Run(); }
public void SuscribeToInstrumentPrice(string ttInstrumentId, string instruType, string productName, string market, string priceType) { if (!_instrumentToSubscribe.ContainsKey(ttInstrumentId)) { var newInstruSub = new InstruSubscription(priceType, instruType, productName, market, ttInstrumentId); _instrumentToSubscribe.Add(ttInstrumentId, newInstruSub); _instruQueue.Enqueue(newInstruSub); _disp.BeginInvoke(UpdateInstrumentSubscription); _disp.Run(); } }
/// <summary> /// Create and start the Dispatcher /// </summary> public void Start(TradingFrameworkUtility tfu) { util = tfu; username = Properties.Settings.Default.USER; password = Properties.Settings.Default.PASSWORD; util.dbug_write("user is: {0}", username); // Attach a WorkerDispatcher to the current thread workDispatch = Dispatcher.AttachWorkerDispatcher(); workDispatch.BeginInvoke(new Action(Init)); workDispatch.Run(); }
}// Start() // // // public void Dispose() { if (m_isDisposing) { return; } m_isDisposing = true; m_Dispatcher.BeginInvoke(new Action(StopThread)); m_Dispatcher.Run(); m_TradeSubsciption.Dispose(); }//Dispose()
// // **** Dispose() **** /// <summary> /// Called by an external thread, invoke the StopThread method. /// </summary> public void Dispose() { if (m_isDisposing) { return; } m_isDisposing = true; try { m_Dispatcher.BeginInvoke(new Action(StopThread)); } catch (Exception) { } }//Dispose()
public void CreateMarketSubscription() { if (_dispatcher.InvokeRequired()) { _dispatcher.BeginInvoke(() => { CreateMarketSubscription(); }); return; } Dispatcher dispatcher = Dispatcher.Current; Console.WriteLine("Creating MarketSubscription..."); // Find each market and subscribe to products for that market foreach (MarketKey key in _apiSession.MarketCatalog.Markets.Keys) { Market market = _apiSession.MarketCatalog.Markets[key]; currentMarkets.Add(key, market); ProductCatalogSubscription pcs = market.CreateProductCatalogSubscription(Dispatcher.Current); pcs.ProductsUpdated += new EventHandler <ProductCatalogUpdatedEventArgs>(pcs_ProductsUpdated); pcs.Start(); } // Find all the fill feeds, order feeds, price feeds and localAutospreader order feed foreach (FillFeed feed in _apiSession.MarketCatalog.FillFeeds) { currentFillFeeds.Add(feed); } localAutospreaderOrderFeed = _apiSession.MarketCatalog.LocalAutospreaderEngineOrderFeed; foreach (OrderFeed feed in _apiSession.MarketCatalog.OrderFeeds) { currentOrderFeeds.Add(feed); } foreach (PriceFeed feed in _apiSession.MarketCatalog.PriceFeeds) { currentPriceFeeds.Add(feed); } // Subscribe to some events related to markets _apiSession.MarketCatalog.FeedStatusChanged += new EventHandler <FeedStatusChangedEventArgs>(MarketCatalog_FeedStatusChanged); _apiSession.MarketCatalog.MarketsUpdated += new EventHandler <MarketCatalogUpdatedEventArgs>(MarketCatalog_MarketsUpdated); _apiSession.MarketCatalog.TradingEnabledChanged += new EventHandler <TradingEnabledChangedEventArgs>(MarketCatalog_TradingEnabledChanged); Console.WriteLine("MarketSubscription created."); }
/// <summary> /// Create and start the Dispatcher /// </summary> public void Initialize() { if (CheckArchitecture()) { // Attach a WorkerDispatcher to the current thread _disp = Dispatcher.AttachWorkerDispatcher(); _disp.BeginInvoke(Init); _disp.Run(); var delay = DateTime.Now.AddSeconds(30); while (DateTime.Now.CompareTo(delay) > 0) { Dispose(); } } }
public void CreateFillSubscription() { if (_dispatcher.InvokeRequired()) { _dispatcher.BeginInvoke(() => { CreateFillSubscription(); }); return; } Dispatcher dispatcher = Dispatcher.Current; Console.WriteLine("Creating Fill Subscription..."); _fs = new FillsSubscription(_apiSession, dispatcher); _fs.FillListStart += new EventHandler <FillListEventArgs>(fs_FillListStart); _fs.FillBookDownload += new EventHandler <FillBookDownloadEventArgs>(fs_FillBookDownload); _fs.FillListEnd += new EventHandler <FillListEventArgs>(fs_FillListEnd); _fs.FillAdded += new EventHandler <FillAddedEventArgs>(fs_FillAdded); _fs.FillDeleted += new EventHandler <FillDeletedEventArgs>(fs_FillDeleted); _fs.FillAmended += new EventHandler <FillAmendedEventArgs>(fs_FillAmended); _fs.Start(); _ts = new TradeSubscription(_apiSession, dispatcher); _ts.FillBookDownload += new EventHandler <FillBookDownloadEventArgs>(ts_FillBookDownload); _ts.FillListEnd += new EventHandler <FillListEventArgs>(ts_FillListEnd); _ts.FillListStart += new EventHandler <FillListEventArgs>(ts_FillListStart); _ts.FillAmended += new EventHandler <FillAmendedEventArgs>(ts_FillAmended); _ts.FillRecordAdded += new EventHandler <FillAddedEventArgs>(ts_FillRecordAdded); _ts.AdminFillAdded += new EventHandler <FillAddedEventArgs>(ts_AdminFillAdded); _ts.AdminFillDeleted += new EventHandler <FillDeletedEventArgs>(ts_AdminFillDeleted); _ts.Rollover += new EventHandler <RolloverEventArgs>(ts_Rollover); _ts.TradeSubscriptionReset += new EventHandler <TradeSubscriptionResetEventArgs>(ts_TradeSubscriptionReset); //ts.EnablePNL = true; //ts.ProfitLossChanged += new EventHandler<ProfitLossChangedEventArgs>(ts_ProfitLossChanged); _ts.Start(); Console.WriteLine("Fill Subscription created."); }