Пример #1
0
 public void ConnectToBroker()
 {
     //TODO: error handling
     if (_clientSocket.IsConnected())
     {
         Logger.Warn("ConnectToBroker called although we already connected");
         return;
     }
     _clientSocket.eConnect(_host, _port, _clientId);
     if (!_clientSocket.IsConnected())
     {
         GeneralTimer.GeneralTimerInstance.AddTask(RECONNECTION_TIMEOUT, ConnectToBroker, false);
         Logger.Error($"Failed to connect to TWS, going to retry in {RECONNECTION_TIMEOUT}");
     }
     else
     {
         //this tells tws to send market data even when there is no active trading
         _clientSocket.reqMarketDataType(2);
         _consumer.Enqueue(new BrokerConnectionStatusMessage(
                               ConnectionStatus.Connected, null)
         {
             AfterConnectionToApiWrapper = true
         });
     }
 }
Пример #2
0
 private void PropagateMessageToAllComponents(IMessage message)
 {
     _accountManager.Enqueue(message, false);
     _managedSecuritiesManager.Enqueue(message, false);
     _uiMessageHandler.Enqueue(message, false);
     PropagateMessageToAllUnlManagers(message);
 }
Пример #3
0
        protected override void HandleMessage(IMessage message)
        {
            //For evaluation only:
            SendMessageToUIDataBroker(message);
            //if((message.APIDataType) == EapiDataTypes.PositionData)
            //{ }
            switch (message.APIDataType)
            {
            case EapiDataTypes.ExceptionData:
                HandleException(message);
                break;

            case EapiDataTypes.APIMessageData:
                var apiMessageData = (APIMessageData)message;
                _uiMessageHandler?.Enqueue(message, false);
                Logger.Debug(apiMessageData.ToString());
                break;

            case EapiDataTypes.AccountSummaryData:
                _accountManager.Enqueue(message, false);
                MarginManager.UpdateAccountData((AccountSummaryData)message);
                PropagateMessageToAllUnlManagers(message);
                break;

            case EapiDataTypes.OptionData:
                var optionData = (OptionData)message;
                if (CalculateGreekLocally)
                {
                    //ForTesting:
                    //if ((optionData.OptionContract.Symbol == "MSFT") && (optionData.OptionContract.Strike == 52) &
                    //    optionData.OptionContract.OptionType == EOptionType.Put )

                    {
                        optionData.UnderlinePrice =
                            ((UNLManager)(_unlManagersDic[optionData.OptionContract.Symbol])).
                            MainSecurityData.LastPrice;
                        BnSCalcHelpper.UpdateGreekValues(optionData);
                    }
                }
                PropagateMessageToAdequateUnlManager(optionData);
                WriteToDB(message);

                break;

            case EapiDataTypes.PositionData:
                var posData = (OptionsPositionData)message;
                //in case that it was handled already, dont handle it agian, it can happen
                //becasue the PositionDataBuilder send the position data again
                if (posData.HandledByPositionDataBuilder)
                {
                    break;
                }
                PropagateMessageToAdequateUnlManager(message);
                WriteToDB(message);
                break;

            case EapiDataTypes.OrderStatus:
            case EapiDataTypes.OrderData:
            case EapiDataTypes.SecurityContract:
                PropagateMessageToAdequateUnlManager(message);
                WriteToDB(message);
                break;

            case EapiDataTypes.SecurityData:
                _managedSecuritiesManager.Enqueue(message, false);

                //ForTesting: if(securityData.SecurityContract.Symbol == "VIX"){ }
                PropagateMessageToAllUnlManagers(message);

                WriteToDB(message);
                break;

            case EapiDataTypes.BrokerConnectionStatus:
                var statusMessage = message as BrokerConnectionStatusMessage;
                if (statusMessage != null && statusMessage.Status == ConnectionStatus.TWSDisconnected)
                {
                    AppManager.AppManagerSingleTonObject.OnTWSDisconnected();
                }
                PropagateMessageToAllComponents(message);
                break;

            case EapiDataTypes.UnlTradingData:
                MarginManager.UpdateUnlTradingData((UnlTradingData)message);
                ((UnlTradingData)message).SetLastUpdate();
                WriteToDB(message);
                break;

            case EapiDataTypes.MarginData:
                var marginData = (MarginData)message;
                if (_unlManagersDic.ContainsKey(marginData.Symbol))
                {
                    _unlManagersDic[marginData.Symbol].Enqueue(marginData, false);
                }
                break;

            case EapiDataTypes.UnlOption:
                WriteToDB(message);
                break;
            }
        }