Exemple #1
0
        public void Clear()
        {
            _securityData.Clear();

            _allOrdersById.Clear();
            _allOrdersByStringId.Clear();
            _allOrdersByTransactionId.Clear();
            _orders.Clear();

            _newsById.Clear();
            _newsWithoutId.Clear();

            _myTrades.Clear();

            _trades.Clear();
            _tradeStat.Clear(true);

            _orderStatusTransactions.Clear();
            _massCancelationTransactions.Clear();

            _exchangeBoards.Clear();
            _securities.Clear();

            _orderCancelFails.Clear();
            _orderRegisterFails.Clear();

            _positions.Clear();
        }
Exemple #2
0
            private void RecycleOrders()
            {
                if (OrdersKeepCount == 0)
                {
                    Orders.Clear();

                    AllOrdersByTransactionId.Clear();
                    AllOrdersById.Clear();
                    AllOrdersByStringId.Clear();

                    _securityData.SyncDo(d => d.Values.ForEach(v =>
                    {
                        v.Orders.Clear();
                        v.OrdersById.Clear();
                        v.OrdersByStringId.Clear();
                    }));

                    return;
                }

                var totalCount = Orders.Count;

                if (OrdersKeepCount == -1 || totalCount < (1.5 * OrdersKeepCount))
                {
                    return;
                }

                var countToRemove = totalCount - OrdersKeepCount;

                lock (_securityData.SyncRoot)
                {
                    var toRemove = Orders.SyncGet(d =>
                    {
                        var tmp = d.Where(o => o.State == OrderStates.Done || o.State == OrderStates.Failed).Take(countToRemove).ToHashSet();
                        d.RemoveRange(tmp);
                        return(tmp);
                    });

                    MyTrades.SyncDo(d => d.RemoveWhere(t => toRemove.Contains(t.Order)));
                    AllOrdersByTransactionId.SyncDo(d => d.RemoveWhere(t => toRemove.Contains(t.Value)));
                    AllOrdersById.SyncDo(d => d.RemoveWhere(t => toRemove.Contains(t.Value)));
                    AllOrdersByStringId.SyncDo(d => d.RemoveWhere(t => toRemove.Contains(t.Value)));

                    foreach (var pair in _securityData)
                    {
                        pair.Value.Orders.SyncDo(d => d.RemoveWhere(t => toRemove.Contains(t.Value.Order)));
                        pair.Value.MyTrades.SyncDo(d => d.RemoveWhere(t => toRemove.Contains(t.Value.Order)));
                        pair.Value.OrdersById.SyncDo(d => d.RemoveWhere(t => toRemove.Contains(t.Value)));
                        pair.Value.OrdersByStringId.SyncDo(d => d.RemoveWhere(t => toRemove.Contains(t.Value)));
                    }
                }
            }
        /// <inheritdoc />
        protected override bool OnSendInMessage(Message message)
        {
            switch (message.Type)
            {
            case MessageTypes.Reset:
                _infos.Clear();
                break;

            case MessageTypes.MarketData:
            {
                var mdMsg = (MarketDataMessage)message;

                if (!mdMsg.IsSubscribe)
                {
                    // NOTE candles can be received during unsubscription process
                    //_infos.Remove(mdMsg.OriginalTransactionId);
                    break;
                }

                if (mdMsg.DataType.IsCandleDataType())
                {
                    var info = _infos.SafeAdd(mdMsg.TransactionId, k => mdMsg.DataType.ToCandleMessage().CreateInstance <CandleMessage>());
                    info.SecurityId = mdMsg.SecurityId;
                    info.Arg        = mdMsg.Arg;
                }

                break;
            }
            }

            return(base.OnSendInMessage(message));
        }
        private void ChartUpdateTimerOnTick(object sender, EventArgs eventArgs)
        {
            if (IsRealtime.IsChecked == true && _lastPrice != 0m)
            {
                var step  = PriceStep.Value ?? 10;
                var price = Round(_lastPrice + (decimal)((RandomGen.GetDouble() - 0.5) * 5 * step), (decimal)step);
                AppendTick(_security, new ExecutionMessage
                {
                    ServerTime = _lastTime,
                    TradePrice = price,
                    Volume     = RandomGen.GetInt(50) + 1
                });
                _lastTime += TimeSpan.FromSeconds(10);
            }

            TimeFrameCandle[] candlesToUpdate;
            lock (_updatedCandles.SyncRoot)
            {
                candlesToUpdate = _updatedCandles.OrderBy(p => p.Key).Select(p => p.Value).ToArray();
                _updatedCandles.Clear();
            }

            _allCandles.AddRange(candlesToUpdate);

            candlesToUpdate.ForEach(c =>
            {
                Chart.Draw(c.OpenTime, new Dictionary <IChartElement, object>
                {
                    { _candleElement1, c },
                });
            });
        }
Exemple #5
0
        /// <inheritdoc />
        protected override void OnSendInMessage(Message message)
        {
            switch (message.Type)
            {
            case MessageTypes.Reset:
                _states.Clear();
                break;

            case MessageTypes.MarketData:
            {
                var mdMsg = (MarketDataMessage)message;

                if (mdMsg.DataType == MarketDataTypes.MarketDepth)
                {
                    if (mdMsg.IsSubscribe)
                    {
                        if (IsSupportOrderBookIncrements)
                        {
                            _states.Add(mdMsg.TransactionId, RefTuple.Create(new QuotesDict(new BackwardComparer <decimal>()), new QuotesDict(), _none));
                        }
                    }
                    else
                    {
                        _states.Remove(mdMsg.OriginalTransactionId);
                    }
                }

                break;
            }
            }

            base.OnSendInMessage(message);
        }
Exemple #6
0
        public void Dispose()
        {
            if (!_isDisposed)
            {
                if (!_shutdown)
                {
                    Shutdown(true, 0);
                }

                if (null != _shuttingDownEvent)
                {
                    _shuttingDownEvent.Close();
                    _shuttingDownEvent = null;
                }
                _workerThreads.Clear();

                if (null != _isIdleWaitHandle)
                {
                    _isIdleWaitHandle.Close();
                    _isIdleWaitHandle = null;
                }

                _isDisposed = true;
            }
        }
Exemple #7
0
        private void ChartUpdateTimerOnTick(object sender, EventArgs eventArgs)
        {
            if (IsRealtime.IsChecked == true && _lastPrice != 0m)
            {
                var nextTick = (ExecutionMessage)_tradeGenerator.Process(new TimeMessage {
                    ServerTime = _lastTime
                });

                if (nextTick != null)
                {
                    AppendTick(_security, nextTick);
                }

                _lastTime += TimeSpan.FromSeconds(10);
            }

            Tuple <TimeFrameCandle, bool>[] candlesToUpdate;
            lock (_updatedCandles.SyncRoot)
            {
                candlesToUpdate = _updatedCandles.OrderBy(p => p.Key).Select(p => p.Value).ToArray();
                _updatedCandles.Clear();
            }

            var lastCandle = _allCandles.LastOrDefault();

            _allCandles.AddRange(candlesToUpdate.Where(c => lastCandle == null || c.Item1.OpenTime != lastCandle.OpenTime).Select(t => t.Item1));

            ChartDrawData chartData = null;

            foreach (var tuple in candlesToUpdate)
            {
                var candle       = tuple.Item1;
                var needToFinish = tuple.Item2;

                if (chartData == null)
                {
                    chartData = new ChartDrawData();
                }

                if (needToFinish)
                {
                    candle.State = CandleStates.Finished;
                }

                var chartGroup = chartData.Group(candle.OpenTime);

                lock (candle.PriceLevels)
                    chartGroup.Add(_candleElement, candle);

                foreach (var pair in _indicators.CachedPairs)
                {
                    chartGroup.Add(pair.Key, pair.Value.Process(candle));
                }
            }

            if (chartData != null)
            {
                Chart.Draw(chartData);
            }
        }
        /// <summary>
        /// Process <see cref="MessageAdapterWrapper.InnerAdapter"/> output message.
        /// </summary>
        /// <param name="message">The message.</param>
        protected override void OnInnerAdapterNewOutMessage(Message message)
        {
            switch (message.Type)
            {
            case MessageTypes.Reset:
                _level1DepthBuilders.Clear();
                break;

            case MessageTypes.Level1Change:
            {
                var level1Msg = (Level1ChangeMessage)message;

                // генерация стакана из Level1
                var quoteMsg = GetBuilder(level1Msg.SecurityId).Process(level1Msg);

                if (quoteMsg != null)
                {
                    RaiseNewOutMessage(quoteMsg);
                }

                break;
            }

            case MessageTypes.QuoteChange:
            {
                var quoteMsg = (QuoteChangeMessage)message;
                GetBuilder(quoteMsg.SecurityId).HasDepth = true;
                break;
            }
            }

            base.OnInnerAdapterNewOutMessage(message);
        }
        /// <inheritdoc />
        public override void SendInMessage(Message message)
        {
            switch (message.Type)
            {
            case MessageTypes.Reset:
                _depths.Clear();
                break;

            case MessageTypes.MarketData:
            {
                var mdMsg = (MarketDataMessage)message;

                if (mdMsg.DataType == MarketDataTypes.MarketDepth)
                {
                    if (mdMsg.IsSubscribe)
                    {
                        if (mdMsg.MaxDepth != null)
                        {
                            _depths[mdMsg.SecurityId] = mdMsg.MaxDepth.Value;
                        }
                    }
                    else
                    {
                        _depths.Remove(mdMsg.SecurityId);
                    }
                }

                break;
            }
            }

            base.SendInMessage(message);
        }
 /// <summary>
 /// To reset the state.
 /// </summary>
 private void Reset()
 {
     _cancellationTransactions.Clear();
     _orderIds.Clear();
     _orderStringIds.Clear();
     _orderStatusIds.Clear();
 }
Exemple #11
0
 /// <summary>
 /// To reset the state.
 /// </summary>
 private void Reset()
 {
     _orderStatusIds.Clear();
     _cancellationTransactions.Clear();
     _replaceTransactions.Clear();
     _replaceTransactionsByTransId.Clear();
 }
 public void ClearCache()
 {
     _subscribers.Clear();
     //_continuousSecurities.Clear();
     _registeredFilteredMarketDepths.Clear();
     _registeredPortfolios.Clear();
 }
        /// <inheritdoc />
        protected override bool OnSendInMessage(Message message)
        {
            switch (message.Type)
            {
            case MessageTypes.Reset:
            {
                lock (_sync)
                {
                    _pending.Clear();
                }

                break;
            }

            case MessageTypes.MarketData:
            {
                var mdMsg = (MarketDataMessage)message;

                if (mdMsg.IsSubscribe)
                {
                    if (mdMsg.SecurityId == default || mdMsg.DoNotBuildOrderBookInrement || mdMsg.To != null)
                    {
                        break;
                    }

                    if (mdMsg.DataType2 != DataType.MarketDepth && mdMsg.DataType2 != DataType.Level1)
                    {
                        break;
                    }

                    lock (_sync)
                        _pending[mdMsg.TransactionId] = mdMsg.TypedClone();
                }
                else
                {
                    lock (_sync)
                        _pending.Remove(mdMsg.OriginalTransactionId);
                }

                break;
            }

            case MessageTypes.OrderStatus:
            case MessageTypes.PortfolioLookup:
            {
                var subscrMsg = (ISubscriptionMessage)message;

                if (subscrMsg.IsSubscribe && subscrMsg.To == null)
                {
                    lock (_sync)
                        _pending[subscrMsg.TransactionId] = subscrMsg.TypedClone();
                }

                break;
            }
            }

            return(base.OnSendInMessage(message));
        }
            protected override bool OnClearing()
            {
                GuiDispatcher.GlobalDispatcher.AddAction(() => _parent.InputBindings.Clear());
                _keyBindings.Clear();
                _mouseActions.Clear();

                return(base.OnClearing());
            }
Exemple #15
0
        /// <inheritdoc />
        public override void SendInMessage(Message message)
        {
            switch (message.Type)
            {
            case MessageTypes.Reset:
            {
                _subscriptions.Clear();
                break;
            }

            case MessageTypes.MarketData:
            {
                var mdMsg = (MarketDataMessage)message;

                if (mdMsg.IsSubscribe)
                {
                    if (!mdMsg.IsBasket())
                    {
                        break;
                    }

                    if (_securityProvider.LookupById(mdMsg.SecurityId) is BasketSecurity basket)
                    {
                        var processor = _processorProvider.CreateProcessor(basket);
                        var tuple     = Tuple.Create(processor, mdMsg.TransactionId);

                        var info = _subscriptions.SafeAdd(mdMsg.DataType);

                        var ids = new long[processor.BasketLegs.Length];

                        for (var i = 0; i < ids.Length; i++)
                        {
                            ids[i] = TransactionIdGenerator.GetNextId();
                            info.ByTransactionIds.Add(ids[i], tuple);
                        }

                        foreach (var id in ids)
                        {
                            var clone = (MarketDataMessage)mdMsg.Clone();
                            clone.TransactionId = id;
                            SendInMessage(clone);
                        }

                        return;
                    }
                }
                else
                {
                }



                break;
            }
            }

            base.SendInMessage(message);
        }
 public void ClearAll()
 {
     lock (_snapshots.SyncRoot)
     {
         _snapshots.Clear();
         _dirtyKeys.Clear();
         _resetFile = true;
     }
 }
Exemple #17
0
        /// <summary>
        /// Создать <see cref="LuaFixServer"/>.
        /// </summary>
        public LuaFixServer()
        {
            _sessionHolder = new LuaSession(new MillisecondIncrementalIdGenerator())
            {
                Path = SystemProcess.GetCurrentProcess().MainModule.FileName
            };

            var inProcessor  = new MessageProcessorPool(new MessageProcessor("Processor 'LuaServer' (In)", err => _logManager.Application.AddErrorLog(err)));
            var outProcessor = new MessageProcessorPool(new MessageProcessor("Processor 'LuaServer' (Out)", err => _logManager.Application.AddErrorLog(err)));

            _marketDataAdapter = new LuaMarketDataAdapter(_sessionHolder)
            {
                InMessageProcessor  = inProcessor,
                OutMessageProcessor = outProcessor
            };
            _transactionAdapter = new LuaTransactionAdapter(_sessionHolder)
            {
                InMessageProcessor  = inProcessor,
                OutMessageProcessor = outProcessor
            };

            _fixServer = new FixServerEx((l, p) =>
            {
                if (Login.IsEmpty() || (l.CompareIgnoreCase(Login) && p == Password))
                {
                    _prevLevel1.Clear();
                    return(Tuple.Create(TimeSpan.FromMilliseconds(100), FixClientRoles.Admin));
                }

                return(null);
            }, _transactionAdapter, _marketDataAdapter);

            _logManager.Application = new QuikNativeApp();

            _logManager.Sources.Add(_sessionHolder);
            _logManager.Sources.Add(_fixServer);

            LogFile = "StockSharp.QuikLua.log";

            var path        = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            var logFileName = Path.Combine(path, LogFile);

            _logManager.Listeners.Add(new FileLogListener(logFileName));
        }
Exemple #18
0
        /// <summary>
        /// Clear cache.
        /// </summary>
        public override void ClearCache()
        {
            base.ClearCache();

            _series.Clear();
            _historySourceSubscriptions.Clear();
            _subscribedCandles.Clear();

            IsFinished = false;
        }
Exemple #19
0
            public void Reset(DateTimeOffset from)
            {
                lock (_candleValues.SyncRoot)
                {
                    _firstValueTime = from.UtcTicks;

                    _candleValues.Values.ForEach(_valuesStat.Remove);
                    _candleValues.Clear();
                }
            }
Exemple #20
0
        /// <inheritdoc />
        protected override bool OnSendInMessage(Message message)
        {
            switch (message.Type)
            {
            case MessageTypes.Reset:
                _depths.Clear();
                break;

            case MessageTypes.MarketData:
            {
                var mdMsg = (MarketDataMessage)message;

                if (mdMsg.SecurityId == default)
                {
                    break;
                }

                if (mdMsg.DataType2 == DataType.MarketDepth)
                {
                    if (mdMsg.IsSubscribe)
                    {
                        if (mdMsg.PassThroughOrderBookInrement)
                        {
                            break;
                        }

                        if (mdMsg.MaxDepth != null)
                        {
                            var actualDepth = mdMsg.MaxDepth.Value;

                            var supportedDepth = InnerAdapter.NearestSupportedDepth(actualDepth);

                            if (supportedDepth != actualDepth)
                            {
                                mdMsg          = mdMsg.TypedClone();
                                mdMsg.MaxDepth = supportedDepth;

                                _depths.Add(mdMsg.TransactionId, actualDepth);

                                this.AddInfoLog("MD truncate {0}/{1} ({2}->{3}).", mdMsg.SecurityId, mdMsg.TransactionId, actualDepth, supportedDepth);
                            }
                        }
                    }
                    else
                    {
                        RemoveSubscription(mdMsg.OriginalTransactionId);
                    }
                }

                break;
            }
            }

            return(base.OnSendInMessage(message));
        }
Exemple #21
0
        /// <inheritdoc />
        public override void SendInMessage(Message message)
        {
            switch (message.Type)
            {
            case MessageTypes.Reset:
                _states.Clear();
                break;
            }

            base.SendInMessage(message);
        }
            public void Reset(DateTimeOffset from)
            {
                _firstCandleTime = from.UtcTicks;

                _byTime.Clear();

                lock (_allCandles.SyncRoot)
                {
                    _candleStat.Remove(_allCandles);
                    _allCandles.Clear();
                }
            }
        public void CompareTest()
        {
            const int size = 1000000;
            int       reps = 3;
            Stopwatch timer;

            IDictionary <Guid, TestValue> dict = new SynchronizedDictionary <Guid, TestValue>(new Dictionary <Guid, TestValue>(size));
            IDictionary <Guid, TestValue> test = new LurchTable <Guid, TestValue>(size);

            for (int rep = 0; rep < reps; rep++)
            {
                var sample = CreateSample(Guid.NewGuid(), size, 1);

                timer = Stopwatch.StartNew();
                Parallel(1, sample, item => dict.Add(item, new TestValue {
                    Id = item, Count = rep
                }));
                Trace.TraceInformation("Dict Add: {0}", timer.Elapsed);

                timer = Stopwatch.StartNew();
                Parallel(1, sample, item => test.Add(item, new TestValue {
                    Id = item, Count = rep
                }));
                Trace.TraceInformation("Test Add: {0}", timer.Elapsed);

                timer = Stopwatch.StartNew();
                Parallel(1, sample, item => dict[item] = new TestValue {
                    Id = item, Count = rep
                });
                Trace.TraceInformation("Dict Update: {0}", timer.Elapsed);

                timer = Stopwatch.StartNew();
                Parallel(1, sample, item => test[item] = new TestValue {
                    Id = item, Count = rep
                });
                Trace.TraceInformation("Test Update: {0}", timer.Elapsed);

                timer = Stopwatch.StartNew();
                Parallel(1, sample, item => dict.Remove(item));
                Trace.TraceInformation("Dict Rem: {0}", timer.Elapsed);
                Assert.AreEqual(0, dict.Count);

                timer = Stopwatch.StartNew();
                Parallel(1, sample, item => test.Remove(item));
                Trace.TraceInformation("Test Rem: {0}", timer.Elapsed);

                test.Clear();
                dict.Clear();

                GC.Collect();
                GC.WaitForPendingFinalizers();
            }
        }
Exemple #24
0
        /// <summary>
        /// Clears the caches for Responses and Redirects if they were enabled.
        /// </summary>
        public virtual void FlushCache()
        {
            if (Responses)
            {
                Responses.Clear();
            }

            if (Redirects)
            {
                Redirects.Clear();
            }
        }
        private void ProcessReset(Message message)
        {
            _hearbeatAdapters.Values.ForEach(a =>
            {
                a.SendInMessage(message);
                a.Dispose();
            });

            _connectedAdapters.Clear();
            _hearbeatAdapters.Clear();
            _subscriptionQueue.Clear();
            _subscriptions.Clear();
        }
        private void Reset()
        {
            _transactionLogSubscriptions.Clear();
            _orders.Clear();

            _secIds.Clear();

            _nonAssociatedByIdMyTrades.Clear();
            _nonAssociatedByStringIdMyTrades.Clear();
            _nonAssociatedByTransactionIdMyTrades.Clear();

            _nonAssociatedOrderIds.Clear();
            _nonAssociatedStringOrderIds.Clear();
        }
Exemple #27
0
        /// <inheritdoc />
        protected override void OnSendInMessage(Message message)
        {
            switch (message.Type)
            {
            case MessageTypes.Reset:
                _subscriptionIds.Clear();
                break;

            case MessageTypes.MarketData:
                message = ProcessMarketDataRequest((MarketDataMessage)message);
                break;
            }

            base.OnSendInMessage(message);
        }
        /// <summary>
        /// Send message.
        /// </summary>
        /// <param name="message">Message.</param>
        public override void SendInMessage(Message message)
        {
            switch (message.Type)
            {
            case MessageTypes.Reset:
                _filteredMarketDepths.Clear();
                break;

            case MessageTypes.MarketData:
            {
                var mdMsg = (MarketDataMessage)message;

                if (mdMsg.DataType != FilteredMarketDepth)
                {
                    break;
                }

                if (mdMsg.IsSubscribe)
                {
                    var clone = (MarketDataMessage)mdMsg.Clone();
                    clone.DataType = MarketDataTypes.MarketDepth;
                    clone.Arg      = null;

                    base.SendInMessage(clone);

                    var data     = (Tuple <QuoteChangeMessage, ExecutionMessage[]>)mdMsg.Arg;
                    var info     = _filteredMarketDepths.SafeAdd(mdMsg.SecurityId, s => new FilteredMarketDepthInfo(data.Item2));
                    var quoteMsg = info.Process(data.Item1);

                    RaiseNewOutMessage(quoteMsg);
                }
                else
                {
                    var clone = (MarketDataMessage)mdMsg.Clone();
                    clone.DataType = MarketDataTypes.MarketDepth;

                    base.SendInMessage(clone);

                    _filteredMarketDepths.Remove(mdMsg.SecurityId);
                }

                return;
            }
            }

            base.SendInMessage(message);
        }
Exemple #29
0
            public void Clear()
            {
                _securityData.Clear();

                AllOrdersById.Clear();
                AllOrdersByStringId.Clear();
                AllOrdersByTransactionId.Clear();
                Orders.Clear();

                NewsById.Clear();
                NewsWithoutId.Clear();

                MyTrades.Clear();

                _trades.Clear();
                _tradeStat.Clear();
            }
Exemple #30
0
        private void Reset()
        {
            _transactionLogSubscriptions.Clear();
            _orderStatusIds.Clear();

            _orders.Clear();
            _secIds.Clear();

            _orderIds.Clear();
            _orderStringIds.Clear();

            lock (_nonAssociatedLock)
            {
                _nonAssociatedOrderIds.Clear();
                _nonAssociatedStringOrderIds.Clear();
            }
        }
Exemple #31
0
        public void SynchronizedDictionaryUnitTest()
        {
            SynchronizedDictionary<int, string> dictionary = new SynchronizedDictionary<int, string>();

            dictionary.Add(1, "one");
            dictionary.Add(2, "two");
            Assert.IsTrue(dictionary.Count == 2);

            foreach (KeyValuePair<int, string> keyValuePair in dictionary)
            {
                Assert.IsTrue(dictionary.ContainsKey(keyValuePair.Key));
                Assert.IsTrue(dictionary.ContainsValue(keyValuePair.Value));
            }

            dictionary.Remove(1);
            Assert.IsTrue(dictionary.Count == 1);

            dictionary.Clear();
            Assert.IsTrue(dictionary.Count == 0);
        }