public void Open()
            {
                _messageQueue.Open();

                ThreadingHelper
                .Thread(() => CultureInfo.InvariantCulture.DoInCulture(() =>
                {
                    while (!_messageQueue.IsClosed)
                    {
                        try
                        {
                            var sended = _historyMessageAdapter.SendOutMessage();
                            var block  = !sended;

                            Message message;

                            while (_messageQueue.TryDequeue(out message, true, block))
                            {
                                NewOutMessage?.Invoke(message);
                                block = false;
                            }
                        }
                        catch (Exception ex)
                        {
                            _errorHandler(ex);
                        }
                    }
                }))
                .Name("History emulation channel thread.")
                .Launch();
            }
            protected virtual void Start()
            {
                if (IsStarted)
                {
                    return;
                }

                IsStarted  = true;
                IsStopping = false;
                _doneEvt.Reset();

                _lastLimitsUpdateTime = DateTime.MinValue;
                //_nextIntervalStartsAt = DateTime.MinValue;
                _requestsPerSecond = 0;

                CurrentAutoRequest = null;

                _recentRequests.Clear();

                UpdateLimitsIfNecessary();

                ThreadingHelper
                .Thread(() =>
                {
                    try
                    { ModuleThreadFunc(); }
                    catch (Exception e)
                    { Client.RaiseError(new ETradeException(LocalizedStrings.Str3362Params.Put(_name), e)); }
                    finally
                    { _doneEvt.Set(); }
                })
                .Background(true)
                .Name("etrade_" + _name)
                .Launch();
            }
        private void OnLoginOk(ISession session)
        {
            try
            {
                Session = session;
                SendOutMessage(new ConnectMessage());
            }
            catch (Exception ex)
            {
                SendError <ConnectMessage>(ex);
            }

            try
            {
                Session.Subscribe(new HeartbeatSubscriptionRequest(), () => { }, CreateErrorHandler("HeartbeatSubscriptionRequest"));

                ThreadingHelper
                .Thread(() => Session.Start())
                .Background(true)
                .Name("LMAX Export thread")
                .Launch();
            }
            catch (Exception ex)
            {
                SendOutError(ex);
            }
        }
        /// <summary>
        /// The method is called when the <see cref="Strategy.Start"/> method has been called and the <see cref="Strategy.ProcessState"/> state has been taken the <see cref="ProcessStates.Started"/> value.
        /// </summary>
        protected override void OnStarted()
        {
            var storateRegistry = new StorageRegistry();

            var drive = Environment.GetValue <IMarketDataDrive>("Drive");

            if (drive != null)
            {
                storateRegistry.DefaultDrive = drive;
            }

            StorateRegistry = storateRegistry;

            ThreadingHelper
            .Thread(() =>
            {
                try
                {
                    OnAnalyze();
                }
                catch (Exception ex)
                {
                    this.AddErrorLog(ex);
                    ex.LogError();
                }
            })
            .Name("{0} analyze thread.".Put(Name))
            .Culture(CultureInfo.InvariantCulture)
            .Launch();
        }
Beispiel #5
0
        public void StartListening(Action <Exception> processError)
        {
            if (processError == null)
            {
                throw new ArgumentNullException(nameof(processError));
            }

            ThreadingHelper
            .Thread(() =>
            {
                try
                {
                    while (!IsDisposed)
                    {
                        var func = ProcessResponse;

                        if (func == null || !func(this))
                        {
                            break;
                        }
                    }
                }
                catch (Exception ex)
                {
                    if (!IsDisposed)
                    {
                        processError(ex);
                    }
                }
            })
            .Name("IBSocket response")
            .Culture(CultureInfo.InvariantCulture)
            .Start();
        }
Beispiel #6
0
        void IMessageProcessor.Start()
        {
            _messageQueue.Open();

            ThreadingHelper
            .Thread(() => CultureInfo.InvariantCulture.DoInCulture(() =>
            {
                while (!_messageQueue.IsClosed)
                {
                    try
                    {
                        MessageItem item;

                        if (!TryDequeue(out item))
                        {
                            break;
                        }

                        _newMessage.SafeInvoke(item.Item1, item.Item2);
                    }
                    catch (Exception ex)
                    {
                        _errorHandler(ex);
                    }
                }

                _stopped.SafeInvoke();
            }))
            .Name("{0}. Messages thread.".Put(Name))
            //.Culture(CultureInfo.InvariantCulture)
            .Launch();
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="StorageCandleSource"/>.
 /// </summary>
 public StorageCandleSource()
 {
     ThreadingHelper
     .Thread(OnLoading)
     .Background(true)
     .Name(GetType().Name)
     .Launch();
 }
 /// <summary>
 /// Initialize <see cref="StorageCandleBuilderSource{T}"/>.
 /// </summary>
 protected StorageCandleBuilderSource()
 {
     ThreadingHelper
     .Thread(OnLoading)
     .Background(true)
     .Name(GetType().Name)
     .Launch();
 }
Beispiel #9
0
        /// <summary>
        /// Отправить сообщение.
        /// </summary>
        /// <param name="message">Сообщение.</param>
        protected override void OnSendInMessage(Message message)
        {
            switch (message.Type)
            {
            case MessageTypes.Connect:
            {
                if (_loadingThread != null)
                {
                    throw new InvalidOperationException(LocalizedStrings.Str1116);
                }

                LoadedEventCount = 0;
                _running         = true;
                _disconnecting   = false;

                _loadingThread = ThreadingHelper
                                 .Thread(OnLoad)
                                 .Name("HistoryMessageAdapter. Loader thread")
                                 .Launch();

                SendOutMessage(new ConnectMessage());

                return;
            }

            case MessageTypes.Disconnect:
            {
                var running = _running;

                _running = false;

                if (_loadingThread == null)
                {
                    // отправляем LastMessage только если не отправили его из OnLoad
                    if (!running)
                    {
                        SendOutMessage(new LastMessage());
                    }

                    SendOutMessage(new DisconnectMessage());
                }
                else
                {
                    // DisconnectMessage должен быть отправлен самым последним
                    _disconnecting = true;
                    _syncRoot.Pulse();
                }

                return;
            }

            case MessageTypes.MarketData:
                ProcessMarketDataMessage((MarketDataMessage)message);
                return;
            }

            SendOutMessage(message);
        }
 public StudioCommandService()
 {
     ThreadingHelper
     .Thread(Process)
     .Background(true)
     .Culture(CultureInfo.InvariantCulture)
     .Name("Studio command service thread")
     .Launch();
 }
Beispiel #11
0
        public void ConnectPusher()
        {
            _ws = new ClientWebSocket();
            _ws.ConnectAsync(new Uri("wss://ws.pusherapp.com/app/de504dc5763aeef9ff52?client=PC-Orbit&version=1.0&protocol=7"), _source.Token).Wait();

            _connected = true;

            ThreadingHelper.Thread(OnReceive).Launch();
        }
Beispiel #12
0
        private void OnLoginOk(ISession session)
        {
            try
            {
                _session = session;

                _session.HeartbeatReceived += OnSessionHeartbeatReceived;
                _session.EventStreamSessionDisconnected += OnSessionEventStreamSessionDisconnected;

                _session.InstructionRejected += OnSessionInstructionRejected;
                _session.AccountStateUpdated += OnSessionAccountStateUpdated;
                _session.OrderChanged        += OnSessionOrderChanged;
                _session.PositionChanged     += OnSessionPositionChanged;
                _session.OrderExecuted       += OnSessionOrderExecuted;

                _session.EventStreamFailed          += OnSessionEventStreamFailed;
                _session.HistoricMarketDataReceived += OnSessionHistoricMarketDataReceived;
                _session.MarketDataChanged          += OnSessionMarketDataChanged;
                _session.OrderBookStatusChanged     += OnSessionOrderBookStatusChanged;

                SendOutMessage(new ConnectMessage());
            }
            catch (Exception ex)
            {
                SendError <ConnectMessage>(ex);
            }

            try
            {
                _session.Subscribe(new HeartbeatSubscriptionRequest(), () => { }, CreateErrorHandler("HeartbeatSubscriptionRequest"));

                ThreadingHelper
                .Thread(() =>
                {
                    try
                    {
                        _session.Start();
                    }
                    catch (Exception ex)
                    {
                        SendOutError(ex);
                    }
                })
                .Background(true)
                .Name("LMAX session thread")
                .Launch();
            }
            catch (Exception ex)
            {
                SendOutError(ex);
            }
        }
Beispiel #13
0
        /// <summary>
        /// Initializes a new instance of the <see cref="CachedBasketMarketDataStorage{T}"/>.
        /// </summary>
        public CachedBasketMarketDataStorage(BasketMarketDataStorage <T> basketStorage)
        {
            if (basketStorage == null)
            {
                throw new ArgumentNullException(nameof(basketStorage));
            }

            _basketStorage     = basketStorage;
            _cancellationToken = new CancellationTokenSource();

            ThreadingHelper
            .Thread(() => CultureInfo.InvariantCulture.DoInCulture(OnLoad))
            .Name("Cached marketdata storage thread.")
            .Launch();
        }
Beispiel #14
0
        private void LookupPanel_OnLookup(Security filter)
        {
            SecuritiesAll.SecurityFilter = filter.Code;

            var downloader = Task as ISecurityDownloader;

            if (downloader == null)
            {
                return;
            }

            BusyIndicator.BusyContent = LocalizedStrings.Str2834;
            BusyIndicator.IsBusy      = true;

            ThreadingHelper
            .Thread(() =>
            {
                var securities = ConfigManager.GetService <IEntityRegistry>().Securities;

                try
                {
                    downloader.Refresh(securities, filter, s => { }, () => _isClosed);
                }
                catch (Exception ex)
                {
                    ex.LogError();
                }

                try
                {
                    securities.DelayAction.WaitFlush();
                }
                catch (Exception ex)
                {
                    ex.LogError();
                }

                try
                {
                    this.GuiAsync(() => BusyIndicator.IsBusy = false);
                }
                catch (Exception ex)
                {
                    ex.LogError();
                }
            })
            .Launch();
        }
        /// <summary>
        /// Добавить сообщение в очередь на отправку.
        /// </summary>
        /// <param name="message">Сообщение.</param>
        private void EnqueueMessage(LogMessage message)
        {
            if (message.IsDispose)
            {
                _queue.Close();
                return;
            }

            _queue.Enqueue(Tuple.Create(GetSubject(message), message.Message));

            lock (_queue.SyncRoot)
            {
                if (_isThreadStarted)
                {
                    return;
                }

                _isThreadStarted = true;

                ThreadingHelper.Thread(() =>
                {
                    try
                    {
                        using (var email = CreateClient())
                        {
                            while (true)
                            {
                                Tuple <string, string> m;

                                if (!_queue.TryDequeue(out m))
                                {
                                    break;
                                }

                                email.Send(From, To, m.Item1, m.Item2);
                            }
                        }

                        lock (_queue.SyncRoot)
                            _isThreadStarted = false;
                    }
                    catch (Exception ex)
                    {
                        Trace.WriteLine(ex);
                    }
                }).Name("Email log queue").Launch();
            }
        }
        private void LookupPanel_OnLookup(Security filter)
        {
            //SecurityPicker.Securities.Clear();
            SecurityPicker.SecurityFilter = filter.Code;

            var downloaders = MainWindow.Instance.Tasks.Where(t => t.Settings.IsEnabled).OfType <ISecurityDownloader>().ToArray();

            if (downloaders.IsEmpty())
            {
                return;
            }

            BusyIndicator.BusyContent = LocalizedStrings.Str2834;
            BusyIndicator.IsBusy      = true;

            ThreadingHelper
            .Thread(() =>
            {
                try
                {
                    var securities = ConfigManager.TryGetService <IEntityRegistry>().Securities;

                    SecurityPicker.Securities.AddRange(securities
                                                       .Lookup(filter)
                                                       .Where(s => !s.IsAllSecurity()));

                    downloaders.ForEach(d =>
                                        d.Refresh(securities, filter, SecurityPicker.Securities.Add, () => _isDisposed));
                }
                catch (Exception ex)
                {
                    ex.LogError();
                }

                try
                {
                    this.GuiAsync(() => BusyIndicator.IsBusy = false);
                }
                catch (Exception ex)
                {
                    ex.LogError();
                }
            })
            .Launch();
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="CachedBasketMarketDataStorage{T}"/>.
        /// </summary>
        public CachedBasketMarketDataStorage(BasketMarketDataStorage <T> basketStorage)
        {
            if (basketStorage == null)
            {
                throw new ArgumentNullException(nameof(basketStorage));
            }

            _basketStorage = basketStorage;
            _basketStorage.InnerStorages.Add(new InMemoryMarketDataStorage <TimeMessage>(null, null, GetTimeLine));

            _cancellationToken = new CancellationTokenSource();

            MaxMessageCount = 1000000;

            ThreadingHelper
            .Thread(() => CultureInfo.InvariantCulture.DoInCulture(OnLoad))
            .Name("Cached marketdata storage thread.")
            .Launch();
        }
Beispiel #18
0
        private void ButtonBase_OnClick(object sender, RoutedEventArgs e)
        {
            if (DatePicker.Value == null)
            {
                MessageBox.Show(LocalizedStrings.Str3750, Title, MessageBoxButton.OK, MessageBoxImage.Information);
                return;
            }

            var  date = ((DateTime)DatePicker.Value).Date;
            bool isSuccess;

            BusyIndicator.IsBusy = true;

            ThreadingHelper.Thread(() =>
            {
                try
                {
                    var ticks = MainWindow.Instance.Trader.GetHistoricalLevel1(_security.ToSecurityId(), date, date.AddDays(1), out isSuccess);

                    this.GuiAsync(() =>
                    {
                        BusyIndicator.IsBusy = false;

                        L1Grid.Messages.Clear();
                        L1Grid.Messages.AddRange(ticks);
                    });
                }
                catch (Exception ex)
                {
                    this.GuiAsync(() =>
                    {
                        BusyIndicator.IsBusy = false;

                        new MessageBoxBuilder().Text(ex.Message).Owner(this).Show();
                    });
                }
            }).Launch();
        }
Beispiel #19
0
        /// <summary>
        /// Open channel.
        /// </summary>
        public void Open()
        {
            _messageQueue.Open();

            ThreadingHelper
            .Thread(() => CultureInfo.InvariantCulture.DoInCulture(() =>
            {
                while (!_messageQueue.IsClosed)
                {
                    try
                    {
                        Message message;

                        if (!_messageQueue.TryDequeue(out message))
                        {
                            break;
                        }

                        //if (!(message is TimeMessage) && message.GetType().Name != "BasketMessage")
                        //	Console.WriteLine("<< ({0}) {1}", System.Threading.Thread.CurrentThread.Name, message);

                        _msgStat.Remove(message);
                        NewOutMessage?.Invoke(message);
                    }
                    catch (Exception ex)
                    {
                        _errorHandler(ex);
                    }
                }

                Closed?.Invoke();
            }))
            .Name($"{Name} channel thread.")
            //.Culture(CultureInfo.InvariantCulture)
            .Launch();
        }
Beispiel #20
0
            public void Open()
            {
                _messageQueue.Open();

                ThreadingHelper
                .Thread(() => CultureInfo.InvariantCulture.DoInCulture(() =>
                {
                    while (!_messageQueue.IsClosed)
                    {
                        try
                        {
                            var sended = _historyMessageAdapter.SendOutMessage();

                            KeyValuePair <DateTimeOffset, Message> pair;

                            if (!_messageQueue.TryDequeue(out pair, true, !sended))
                            {
                                if (!sended)
                                {
                                    break;
                                }
                            }
                            else
                            {
                                NewOutMessage.SafeInvoke(pair.Value);
                            }
                        }
                        catch (Exception ex)
                        {
                            _errorHandler(ex);
                        }
                    }
                }))
                .Name("History emulation channel thread.")
                .Launch();
            }
Beispiel #21
0
        /// <summary>
        /// Open channel.
        /// </summary>
        public void Open()
        {
            _messageQueue.Open();

            ThreadingHelper
            .Thread(() => CultureInfo.InvariantCulture.DoInCulture(() =>
            {
                while (!_messageQueue.IsClosed)
                {
                    try
                    {
                        KeyValuePair <DateTimeOffset, Message> pair;

                        if (!_messageQueue.TryDequeue(out pair))
                        {
                            break;
                        }

                        //if (!(message is TimeMessage) && message.GetType().Name != "BasketMessage")
                        //	Console.WriteLine("<< ({0}) {1}", System.Threading.Thread.CurrentThread.Name, message);

                        _msgStat.Remove(pair.Value);
                        NewOutMessage.SafeInvoke(pair.Value);
                    }
                    catch (Exception ex)
                    {
                        _errorHandler(ex);
                    }
                }

                Closed.SafeInvoke();
            }))
            .Name("{0} channel thread.".Put(Name))
            //.Culture(CultureInfo.InvariantCulture)
            .Launch();
        }
Beispiel #22
0
        /// <summary>
        /// Обновить таблицу. Выполняется асинхронно.
        /// </summary>
        /// <param name="storageRegistry">Хранилище маркет-данных.</param>
        /// <param name="security">Инструмент.</param>
        /// <param name="format">Формат данных.</param>
        /// <param name="drive">Хранилище.</param>
        public void BeginMakeEntries(IStorageRegistry storageRegistry, Security security, StorageFormats format, IMarketDataDrive drive)
        {
            if (storageRegistry == null)
            {
                throw new ArgumentNullException("storageRegistry");
            }

            lock (_syncObject)
            {
                _query     = new Query(storageRegistry, security, format, drive);
                _isChanged = true;

                if (_isFlushing)
                {
                    return;
                }

                _isFlushing = true;

                ThreadingHelper
                .Thread(() => CultureInfo.InvariantCulture.DoInCulture(OnFlush))
                .Launch();
            }
        }
Beispiel #23
0
        private void InitializeCommands()
        {
            var cmdSvc = ConfigManager.GetService <IStudioCommandService>();

            cmdSvc.Register <OpenMarketDataSettingsCommand>(this, true, cmd => OpenMarketDataPanel(cmd.Settings));

            cmdSvc.Register <RefreshSecurities>(this, false, cmd => ThreadingHelper
                                                .Thread(() =>
            {
                var entityRegistry = ConfigManager.GetService <IEntityRegistry>();
                var count          = 0;
                var progress       = 0;

                try
                {
                    using (var client = new RemoteStorageClient(new Uri(cmd.Settings.Path)))
                    {
                        var credentials = cmd.Settings.Credentials;

                        client.Credentials.Login    = credentials.Login;
                        client.Credentials.Password = credentials.Password;

                        foreach (var secType in cmd.Types.TakeWhile(secType => !cmd.IsCancelled()))
                        {
                            if (secType == SecurityTypes.Future)
                            {
                                var from        = DateTime.Today.AddMonths(-4);
                                var to          = DateTime.Today.AddMonths(4);
                                var expiryDates = from.GetExpiryDates(to);

                                foreach (var expiryDate in expiryDates.TakeWhile(d => !cmd.IsCancelled()))
                                {
                                    client.Refresh(entityRegistry.Securities, new Security {
                                        Type = secType, ExpiryDate = expiryDate
                                    }, s =>
                                    {
                                        entityRegistry.Securities.Save(s);
                                        _connector.SendOutMessage(s.ToMessage());
                                        count++;
                                    }, cmd.IsCancelled);
                                }
                            }
                            else
                            {
                                // для акций передаем фиктивное значение ExpiryDate, чтобы получить инструменты без даты экспирации
                                var expiryDate = secType == SecurityTypes.Stock ? DateTime.Today : (DateTime?)null;

                                client.Refresh(entityRegistry.Securities, new Security {
                                    Type = secType, ExpiryDate = expiryDate
                                }, s =>
                                {
                                    entityRegistry.Securities.Save(s);
                                    _connector.SendOutMessage(s.ToMessage());
                                    count++;
                                }, cmd.IsCancelled);
                            }

                            cmd.ProgressChanged(++progress);
                        }
                    }
                }
                catch (Exception ex)
                {
                    ex.LogError();
                }

                if (cmd.IsCancelled())
                {
                    return;
                }

                try
                {
                    cmd.WhenFinished(count);
                }
                catch (Exception ex)
                {
                    ex.LogError();
                }
            })
                                                .Launch());
        }
        /// <summary>
        /// Send message.
        /// </summary>
        /// <param name="message">Message.</param>
        protected override void OnSendInMessage(Message message)
        {
            switch (message.Type)
            {
            case MessageTypes.Reset:
            {
                TryResume();

                LoadedMessageCount = 0;
                _disconnecting     = _loadingThread != null;
                _loadingThread     = null;

                if (!_disconnecting)
                {
                    SendOutMessage(new ResetMessage());
                }

                break;
            }

            case MessageTypes.Connect:
            {
                if (_loadingThread != null)
                {
                    throw new InvalidOperationException(LocalizedStrings.Str1116);
                }

                SendOutMessage(new ConnectMessage {
                        LocalTime = StartDate.LocalDateTime
                    });
                return;
            }

            case MessageTypes.Disconnect:
            {
                _disconnecting = true;
                TryResume();
                return;
            }

            case MessageTypes.SecurityLookup:
            {
                var lookupMsg = (SecurityLookupMessage)message;

                //ThreadingHelper.Thread(() =>
                //{
                //	try
                //	{
                SecurityProvider.LookupAll().ForEach(security =>
                    {
                        SendOutMessage(security.Board.ToMessage());

                        var secMsg = security.ToMessage();
                        secMsg.OriginalTransactionId = lookupMsg.TransactionId;
                        SendOutMessage(secMsg);

                        //SendOutMessage(new Level1ChangeMessage { SecurityId = security.ToSecurityId() }
                        //	.Add(Level1Fields.StepPrice, security.StepPrice)
                        //	.Add(Level1Fields.MinPrice, security.MinPrice)
                        //	.Add(Level1Fields.MaxPrice, security.MaxPrice)
                        //	.Add(Level1Fields.MarginBuy, security.MarginBuy)
                        //	.Add(Level1Fields.MarginSell, security.MarginSell));
                    });

                SendOutMessage(new SecurityLookupResultMessage {
                        OriginalTransactionId = lookupMsg.TransactionId
                    });
                //	}
                //	catch (Exception ex)
                //	{
                //		SendOutError(ex);
                //	}
                //}).Name("History sec lookup").Start();
                return;
            }

            case MessageTypes.MarketData:
            case ExtendedMessageTypes.HistorySource:
                ProcessMarketDataMessage((MarketDataMessage)message);
                return;

            case ExtendedMessageTypes.EmulationState:
                var stateMsg    = (EmulationStateMessage)message;
                var isSuspended = false;

                switch (stateMsg.State)
                {
                case EmulationStates.Starting:
                {
                    if (_loadingThread != null)
                    {
                        TryResume();
                        break;
                    }

                    _loadingThread = ThreadingHelper
                                     .Thread(OnLoad)
                                     .Name("HistoryMessageAdapter")
                                     .Launch();

                    break;
                }

                case EmulationStates.Suspending:
                {
                    lock (_suspendLock)
                        _isSuspended = true;

                    isSuspended = true;
                    break;
                }
                }

                SendOutMessage(message);

                if (isSuspended)
                {
                    SendOutMessage(new EmulationStateMessage {
                        State = EmulationStates.Suspended
                    });
                }

                return;
            }

            //SendOutMessage(message);
        }
Beispiel #25
0
        private void InitializeCommands()
        {
            var cmdSvc = ConfigManager.GetService <IStudioCommandService>();

            cmdSvc.Register <OpenMarketDataSettingsCommand>(this, true, cmd => OpenMarketDataPanel(cmd.Settings));

            cmdSvc.Register <RefreshSecurities>(this, false, cmd => ThreadingHelper
                                                .Thread(() =>
            {
                var entityRegistry = ConfigManager.GetService <IEntityRegistry>();
                var count          = 0;
                var progress       = 0;

                try
                {
                    using (var client = new RemoteStorageClient(new Uri(cmd.Settings.Path)))
                    {
                        var credentials = cmd.Settings.Credentials;

                        client.Credentials.Login    = credentials.Login;
                        client.Credentials.Password = credentials.Password;

                        foreach (var secType in cmd.Types.TakeWhile(secType => !cmd.IsCancelled()))
                        {
                            if (secType == SecurityTypes.Future)
                            {
                                var from        = DateTime.Today.AddMonths(-4);
                                var to          = DateTime.Today.AddMonths(4);
                                var expiryDates = from.GetExpiryDates(to);

                                foreach (var expiryDate in expiryDates.TakeWhile(d => !cmd.IsCancelled()))
                                {
                                    client.Refresh(entityRegistry.Securities, new Security {
                                        Type = secType, ExpiryDate = expiryDate
                                    }, s =>
                                    {
                                        entityRegistry.Securities.Save(s);
                                        _connector.SendOutMessage(s.ToMessage());
                                        count++;
                                    }, cmd.IsCancelled);
                                }
                            }
                            else
                            {
                                // для акций передаем фиктивное значение ExpiryDate, чтобы получить инструменты без даты экспирации
                                var expiryDate = secType == SecurityTypes.Stock ? DateTime.Today : (DateTime?)null;

                                client.Refresh(entityRegistry.Securities, new Security {
                                    Type = secType, ExpiryDate = expiryDate
                                }, s =>
                                {
                                    entityRegistry.Securities.Save(s);
                                    _connector.SendOutMessage(s.ToMessage());
                                    count++;
                                }, cmd.IsCancelled);
                            }

                            cmd.ProgressChanged(++progress);
                        }
                    }
                }
                catch (Exception ex)
                {
                    ex.LogError();
                }

                if (cmd.IsCancelled())
                {
                    return;
                }

                try
                {
                    cmd.WhenFinished(count);
                }
                catch (Exception ex)
                {
                    ex.LogError();
                }
            })
                                                .Launch());

            cmdSvc.Register <CreateSecurityCommand>(this, true, cmd =>
            {
                var entityRegistry = ConfigManager.GetService <IEntityRegistry>();

                ISecurityWindow wnd;

                if (cmd.SecurityType == typeof(Security))
                {
                    wnd = new SecurityCreateWindow();
                }
                else
                {
                    throw new InvalidOperationException(LocalizedStrings.Str2140Params.Put(cmd.SecurityType));
                }

                wnd.ValidateId = id =>
                {
                    if (entityRegistry.Securities.ReadById(id) != null)
                    {
                        return(LocalizedStrings.Str2927Params.Put(id));
                    }

                    return(null);
                };

                if (!((Window)wnd).ShowModal(Application.Current.GetActiveOrMainWindow()))
                {
                    return;
                }

                entityRegistry.Securities.Save(wnd.Security);
                _connector.SendOutMessage(wnd.Security.ToMessage());
                cmd.Security = wnd.Security;
            });

            cmdSvc.Register <SetDefaultEmulationSettingsCommand>(this, false, cmd =>
            {
                _emulationSettings.Load(cmd.Settings.Save());
                _layoutManager.FlushSettings();
            });
        }
Beispiel #26
0
        /// <summary>
        /// Запустить.
        /// </summary>
        public void Start()
        {
            if (State != TaskStates.Stopped)
            {
                return;
            }

            _currentErrorCount = 0;

            ThreadingHelper.Thread(() =>
            {
                try
                {
                    WaitIfNecessary(TimeSpan.Zero);

                    State = TaskStates.Starting;
                    OnStarting();

                    var attempts = 60;

                    while (State == TaskStates.Starting && attempts-- > 0)
                    {
                        WaitIfNecessary(TimeSpan.FromSeconds(1));
                    }

                    if (State == TaskStates.Starting)
                    {
                        this.AddErrorLog(LocalizedStrings.Str2191);
                    }

                    while (State == TaskStates.Started)
                    {
                        try
                        {
                            var interval = OnProcess();

                            if (interval == TimeSpan.MaxValue)
                            {
                                Stop();
                                break;
                            }

                            // сбрасываем счетчик при успешной итерации
                            _currentErrorCount = 0;

                            WaitIfNecessary(interval);
                        }
                        catch (Exception ex)
                        {
                            HandleError(ex);
                            WaitIfNecessary(TimeSpan.FromSeconds(5));
                        }
                    }
                }
                catch (Exception ex)
                {
                    this.AddErrorLog(ex);
                    this.AddErrorLog(LocalizedStrings.Str2192);
                }
                finally
                {
                    try
                    {
                        OnStopped();
                    }
                    catch (Exception ex)
                    {
                        this.AddErrorLog(ex);
                    }

                    Stopped.SafeInvoke(this);
                    State = TaskStates.Stopped;
                }
            })
            .Name("{0} Task thread".Put(Name))
            .Launch();
        }
Beispiel #27
0
        public AlertService()
        {
            ThreadingHelper
            .Thread(() =>
            {
                try
                {
                    var player = new MediaPlayer();

                    var fileName = Path.Combine(UserConfig.Instance.MainFolder, "alert.mp3");

                    if (!File.Exists(fileName))
                    {
                        File.WriteAllBytes(fileName, Properties.Resources.Alert);
                    }

                    player.Open(new Uri(fileName, UriKind.RelativeOrAbsolute));

                    var logManager = ConfigManager.GetService <LogManager>();

                    using (var speech = new SpeechSynthesizer())
                        using (var client = new NotificationClient())
                            using (player.MakeDisposable(p => p.Close()))
                            {
                                while (!IsDisposed)
                                {
                                    Tuple <AlertTypes, string, string, DateTime> alert;

                                    if (!_alerts.TryDequeue(out alert))
                                    {
                                        break;
                                    }

                                    try
                                    {
                                        switch (alert.Item1)
                                        {
                                        case AlertTypes.Sound:
                                            player.Play();
                                            break;

                                        case AlertTypes.Speech:
                                            speech.Speak(alert.Item2);
                                            break;

                                        case AlertTypes.Popup:
                                            GuiDispatcher.GlobalDispatcher.AddAction(() => new AlertPopupWindow
                                            {
                                                Title   = alert.Item2,
                                                Message = alert.Item3,
                                                Time    = alert.Item4
                                            }.Show());
                                            break;

                                        case AlertTypes.Sms:
                                            client.SendSms(alert.Item2);
                                            break;

                                        case AlertTypes.Email:
                                            client.SendEmail(alert.Item2, alert.Item3);
                                            break;

                                        case AlertTypes.Log:
                                            logManager.Application.AddWarningLog(() => "Оповещение! В {0} случилось '{1}'.{2}"
                                                                                 .Put(alert.Item4, alert.Item2, Environment.NewLine + alert.Item3));
                                            break;

                                        default:
                                            throw new ArgumentOutOfRangeException();
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        ex.LogError();
                                    }
                                }
                            }
                }
                catch (Exception ex)
                {
                    ex.LogError();
                }
            })
            .Name("Alert thread")
            .Launch();
        }
Beispiel #28
0
        /// <summary>
        /// Подключиться к серверу.
        /// </summary>
        public void Connect()
        {
            _logReceiver.AddInfoLog("[{0}] Connecting...", Name);

            if (_socket != null)
            {
                throw new InvalidOperationException(LocalizedStrings.Str2152);
            }

            _socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            try
            {
                _socket.Connect(Address);

                lock (_syncDisconnect)
                    IsExportStarted = true;

                ThreadingHelper
                .Thread(() =>
                {
                    var buf    = new StringBuilder();
                    var buffer = new byte[1024];

                    try
                    {
                        while (true)
                        {
                            if (_socket == null)
                            {
                                throw new InvalidOperationException(LocalizedStrings.Str2153);
                            }

                            if (_socket.Poll(500000, SelectMode.SelectRead))
                            {
                                // http://stackoverflow.com/questions/2661764/how-to-check-if-a-socket-is-connected-disconnected-in-c
                                if (_socket.Available == 0)
                                {
                                    throw new InvalidOperationException(LocalizedStrings.Str1611);
                                }

                                var bytesRecv = _socket.Receive(buffer, 0, buffer.Length, SocketFlags.None);

                                buf.Append(Encoding.ASCII.GetString(buffer, 0, bytesRecv));

                                var index = buf.LastIndexOf('\n');

                                if (index == -1)
                                {
                                    continue;
                                }

                                var res   = buf.ToString(0, index + 1);
                                var reply = res.Split("\n").Select(v => v.TrimEnd('\r', '\n'));

                                if (index < buf.Length - 1)
                                {
                                    buf.Remove(0, index + 1);
                                }
                                else
                                {
                                    buf.Clear();
                                }

                                try
                                {
                                    foreach (var line in reply)
                                    {
                                        _logReceiver.AddDebugLog("[{0}] Response: {1}", Name, line);
                                        ProcessReply.SafeInvoke(line);
                                    }
                                }
                                catch (Exception ex)
                                {
                                    _logReceiver.AddErrorLog(ex);
                                }
                            }

                            lock (_syncDisconnect)
                            {
                                if (IsExportStarted)
                                {
                                    continue;
                                }

                                _logReceiver.AddInfoLog(LocalizedStrings.Str2154Params, Name);
                                Monitor.Pulse(_syncDisconnect);
                                break;
                            }
                        }
                    }
                    catch (ObjectDisposedException ex)
                    {
                        ConnectionError.SafeInvoke(new InvalidOperationException(LocalizedStrings.Str2155, ex));
                    }
                    catch (Exception ex)
                    {
                        ConnectionError.SafeInvoke(ex);
                    }

                    try
                    {
                        _socket.Shutdown(SocketShutdown.Both);
                    }
                    catch (Exception ex)
                    {
                        _logReceiver.AddErrorLog(ex);
                    }

                    _socket.Close();
                    _socket = null;

                    _logReceiver.AddInfoLog(LocalizedStrings.Str2156Params, Name);
                })
                .Name("IQFeed '{0}' thread".Put(Name))
                .Culture(CultureInfo.InvariantCulture)
                .Start();

                Request("S,SET PROTOCOL,5.1");

                _logReceiver.AddInfoLog("[{0}] Connected", Name);
            }
            catch
            {
                _socket.Close();
                _socket = null;
                throw;
            }
        }
            public void Add(TData data)
            {
                lock (_data.SyncRoot)
                {
                    if (!_data.TryAdd(data))
                    {
                        return;
                    }

                    _dataVersion++;

                    switch (_currState)
                    {
                    case States.Starting:
                        return;

                    case States.Started:
                        //_currState = States.Starting;
                        _response.Close();
                        return;

                    case States.Stopping:
                        _currState = States.Starting;
                        return;

                    case States.Stopped:
                        _currState = States.Starting;
                        break;

                    default:
                        throw new ArgumentOutOfRangeException();
                    }
                }

                ThreadingHelper.Thread(() =>
                {
                    var errorCount          = 0;
                    const int maxErrorCount = 10;

                    while (!_parent.IsDisposed)
                    {
                        var dataVersion = 0;

                        try
                        {
                            var url = new Url(_parent._streamingUrl + "/v1/" + _methodName);

                            TData[] cachedData;

                            lock (_data.SyncRoot)
                            {
                                switch (_currState)
                                {
                                case States.Starting:
                                    lock (_data.SyncRoot)
                                    {
                                        cachedData  = _data.Cache;
                                        dataVersion = _dataVersion;
                                    }
                                    break;

                                case States.Started:
                                case States.Stopped:
                                    throw new InvalidOperationException();

                                case States.Stopping:
                                    _currState = States.Stopped;
                                    return;

                                default:
                                    throw new ArgumentOutOfRangeException();
                                }
                            }

                            _fillQuery(url.QueryString, cachedData);

                            var request = WebRequest.Create(url);

                            // for non-sandbox requests
                            if (_parent._token != null)
                            {
                                request.Headers.Add("Authorization", "Bearer " + _parent._token.To <string>());
                            }

                            request.Headers.Add("X-Accept-Datetime-Format", "UNIX");

                            using (var response = request.GetResponse())
                            {
                                lock (_data.SyncRoot)
                                {
                                    switch (_currState)
                                    {
                                    case States.Starting:
                                        // new items may be added or removed
                                        if (dataVersion < _dataVersion)
                                        {
                                            continue;
                                        }

                                        _currState = States.Started;
                                        _response  = response;
                                        break;

                                    case States.Started:
                                    case States.Stopped:
                                        throw new InvalidOperationException();

                                    case States.Stopping:
                                        continue;

                                    default:
                                        throw new ArgumentOutOfRangeException();
                                    }
                                }

                                using (var reader = new StreamReader(response.GetResponseStream()))
                                {
                                    string line;

                                    var lineErrorCount          = 0;
                                    const int maxLineErrorCount = 100;

                                    while (!_parent.IsDisposed && (line = reader.ReadLine()) != null)
                                    {
                                        try
                                        {
                                            _newLine(JsonConvert.DeserializeObject <TResponse>(line));
                                            lineErrorCount = 0;
                                        }
                                        catch (Exception ex)
                                        {
                                            _parent.NewError.SafeInvoke(ex);

                                            if (++lineErrorCount >= maxLineErrorCount)
                                            {
                                                //this.AddErrorLog("Max error {0} limit reached.", maxLineErrorCount);
                                                break;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            bool needLog;

                            lock (_data.SyncRoot)
                            {
                                needLog    = dataVersion == _dataVersion;
                                _currState = _data.Count > 0 ? States.Starting : States.Stopping;
                                _response  = null;
                            }

                            if (needLog)
                            {
                                _parent.NewError.SafeInvoke(ex);

                                if (++errorCount >= maxErrorCount)
                                {
                                    //this.AddErrorLog("Max error {0} limit reached.", maxErrorCount);
                                    break;
                                }
                            }
                            else
                            {
                                errorCount = 0;
                            }
                        }
                        finally
                        {
                            lock (_data.SyncRoot)
                                _response = null;
                        }
                    }
                })
                .Name("Oanda " + _methodName)
                .Launch();
            }
Beispiel #30
0
        /// <summary>
        /// Initializes a new instance of the <see cref="AlertService"/>.
        /// </summary>
        /// <param name="dumpDir">Temp files directory.</param>
        public AlertService(string dumpDir)
        {
            if (dumpDir.IsEmpty())
            {
                throw new ArgumentNullException(nameof(dumpDir));
            }

            ThreadingHelper
            .Thread(() =>
            {
                try
                {
                    var player = new MediaPlayer();

                    var fileName = Path.Combine(dumpDir, "alert.mp3");

                    if (!File.Exists(fileName))
                    {
                        Properties.Resources.Alert.Save(fileName);
                    }

                    player.Open(new Uri(fileName, UriKind.RelativeOrAbsolute));

                    var logManager = ConfigManager.GetService <LogManager>();

                    using (var speech = new SpeechSynthesizer())
                        using (var client = new NotificationClient())
                            using (player.MakeDisposable(p => p.Close()))
                            {
                                while (!IsDisposed)
                                {
                                    Tuple <AlertTypes, string, string, DateTimeOffset> alert;

                                    if (!_alerts.TryDequeue(out alert))
                                    {
                                        break;
                                    }

                                    try
                                    {
                                        switch (alert.Item1)
                                        {
                                        case AlertTypes.Sound:
                                            player.Play();
                                            break;

                                        case AlertTypes.Speech:
                                            speech.Speak(alert.Item2);
                                            break;

                                        case AlertTypes.Popup:
                                            GuiDispatcher.GlobalDispatcher.AddAction(() => new AlertPopupWindow
                                            {
                                                Title   = alert.Item2,
                                                Message = alert.Item3,
                                                Time    = alert.Item4.UtcDateTime
                                            }.Show());
                                            break;

                                        case AlertTypes.Sms:
                                            client.SendSms(alert.Item2);
                                            break;

                                        case AlertTypes.Email:
                                            client.SendEmail(alert.Item2, alert.Item3);
                                            break;

                                        case AlertTypes.Log:
                                            logManager.Application.AddWarningLog(() => LocalizedStrings.Str3033Params
                                                                                 .Put(alert.Item4, alert.Item2, Environment.NewLine + alert.Item3));
                                            break;

                                        default:
                                            throw new ArgumentOutOfRangeException();
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        ex.LogError();
                                    }
                                }
                            }
                }
                catch (Exception ex)
                {
                    ex.LogError();
                }
            })
            .Name("Alert thread")
            .Launch();
        }