Esempio n. 1
0
        public static void OnConnectionStatusChanged(ApiConnectionStatus status, string type)
        {
            _apiConnectionStatus = status;

            ConnectionStatusHandler handler = ConnectionStatusChanged;

            if (handler != null)
            {
                handler(status, type);
            }
        }
Esempio n. 2
0
 public static void OnEventsSessionStatusChanged(bool started, Exception e)
 {
     if (e != null)
     {
         if (_apiConnectionStatus != ApiConnectionStatus.Recovering)
         {
             OnConnectionStatusChanged(ApiConnectionStatus.Faulted, null);
             RecoverApiConnection(e.Message, e.InnerException);
         }
     }
     else if (_apiConnectionStatus == ApiConnectionStatus.Recovering && started)
     {
         _apiConnectionStatus = ApiConnectionStatus.Recovered;
     }
     else if (_apiConnectionStatus == ApiConnectionStatus.Disconnected && started)
     {
         OnConnectionStatusChanged(ApiConnectionStatus.Streaming, "Events");
     }
 }
Esempio n. 3
0
        protected virtual void OnConnectionStatusChanged(ApiConnectionStatus status, string type)
        {
            if (status == ApiConnectionStatus.Connected)
            {
                AddAlgorithmMessage("OANDA Api connection status is: Connected.", true, TraceEventType.Information);
            }
            else if (status == ApiConnectionStatus.Streaming)
            {
                AddAlgorithmMessage(string.Format("OANDA Api connection status is: Streaming {0}.", type), true, TraceEventType.Information);
            }
            else if (status == ApiConnectionStatus.Faulted)
            {
                AddAlgorithmMessage("OANDA Api connection status is: Faulted.", true, TraceEventType.Information);
            }
            else if (status == ApiConnectionStatus.Recovered)
            {
                AddAlgorithmMessage("OANDA Api connection status is: Recovered.", true, TraceEventType.Information);
            }
            else if (status == ApiConnectionStatus.Disconnected)
            {
                AddAlgorithmMessage("OANDA Api connection status is: Disconnected.", true, TraceEventType.Information);
            }

            if (_instance.Status == (short?)AlgorithmStatus.Running)
            {
                if (status == ApiConnectionStatus.Connected)
                {
                    // api connection restored
                    if (_lastConnectionStatus == ApiConnectionStatus.Recovered)
                    {
                        // get missed account activity
                        UpdateStrategyTransactions().Wait();
                        UpdateOrdersAndTrades().Wait();
                    }
                }
            }

            OnConnectionStatusChangedAction(status);

            _lastConnectionStatus = status;
        }
Esempio n. 4
0
 protected override void OnConnectionStatusChangedAction(ApiConnectionStatus status)
 {
     if (_instance.Status == (short?)AlgorithmStatus.Running)
     {
         if (status == ApiConnectionStatus.Faulted)
         {
             _chartsInitialized = false;
         }
         else if (status == ApiConnectionStatus.Recovered)
         {
         }
         else if (status == ApiConnectionStatus.Connected)
         {
             // api connection restored
             if (_lastConnectionStatus == ApiConnectionStatus.Recovered && !_chartsInitialized)
             {
                 InitializeCharts();
             }
         }
     }
 }
Esempio n. 5
0
        private static async Task RecoverApiConnection(string reason, Exception e)
        {
            bool connectionRecovered = false;

            OnConnectionRecovering(string.Format("Fault Error: {0}", reason));
            if (e != null)
            {
                OnConnectionRecovering(string.Format("Exception Error: {0}", e.Message));
            }

            await Task.Run(() =>
            {
                short count = 1;

                while (!connectionRecovered)
                {
                    string message = "";

                    if (_apiConnectionStatus == ApiConnectionStatus.Faulted ||
                        _apiConnectionStatus == ApiConnectionStatus.Recovering)
                    {
                        _apiConnectionStatus = ApiConnectionStatus.Recovering;

                        if (count > 1)
                        {
                            OnConnectionRecovering("Event stream re-start attempt failed.");
                        }

                        Task.Delay(TimeSpan.FromMilliseconds(5000)).Wait();

                        message = string.Format("OANDA connection recovery attempt: {0}", count.ToString());
                        OnConnectionRecovering(message);

                        message = StopEventsStream();
                        OnConnectionRecovering(message);

                        // 5 secs
                        Task.Delay(TimeSpan.FromMilliseconds(5000)).Wait();
                        OnConnectionRecovering("Attempting to re-start events stream ...");

                        StartEventsStreamAsync();

                        // 25 secs .. to allow time for a hearbeat
                        // http://developer.oanda.com/rest-live/streaming/#eventsStreaming
                        Task.Delay(TimeSpan.FromMilliseconds(25000)).Wait();

                        count++;
                    }

                    if (_apiConnectionStatus == ApiConnectionStatus.Recovered)
                    {
                        connectionRecovered = true;

                        OnConnectionRecovering("OANDA connection recovered.");

                        OnConnectionStatusChanged(ApiConnectionStatus.Recovered, null);

                        Task.Delay(TimeSpan.FromMilliseconds(1500)).Wait();

                        OnConnectionStatusChanged(ApiConnectionStatus.Connected, null);
                    }
                }
            });
        }
Esempio n. 6
0
 protected abstract void OnConnectionStatusChangedAction(ApiConnectionStatus status);