예제 #1
0
 public async Task SendEventAsync(string outputName, Message message)
 {
     lock (MessageQueues)
     {
         if (!MessageQueues.ContainsKey(outputName))
         {
             MessageQueues[outputName] = new List <Message>();
         }
         MessageQueues[outputName].Add(message);
     }
     Log.Information($"Message Sent to {outputName}");
     await Task.FromResult(0);
 }
예제 #2
0
        public void SendToQueue(string queueName, bool sendToError)
        {
            Logger.InfoFormat("Отправка в [{0}]: [{1}]", queueName, ToString());
            if (string.IsNullOrEmpty(Title))
            {
                var stack = new System.Diagnostics.StackTrace();
                Logger.ErrorFormat("Для сообщения не указан обязательный параметр Title: {0}", stack);
                throw new ArgumentException("Для сообщения не указан обязательный параметр Title");
            }
            if (!sendToError)
            {
                SentCount++;
            }

            var          fullQueueName = MessageQueues.FormatQueueName(HostName.MessageQueueHostName, queueName);
            MessageQueue queue;

            try
            {
                queue = new MessageQueue(fullQueueName);
            }
            catch (Exception ex)
            {
                Logger.ErrorFormat("Ошибка создания экземпляра очереди [{0}]: {1}",
                                   fullQueueName, ex);
                throw;
            }
            using (queue)
            {
                var msgProperties = new DefaultPropertiesToSend
                {
                    Priority    = QueueMessagePriority,
                    Label       = Title,
                    Recoverable = true
                };
                queue.Formatter = new BinaryMessageFormatter();
                queue.DefaultPropertiesToSend = msgProperties;
                TimeSent = DateTime.Now;
                try
                {
                    queue.Send(this);
                    Logger.Info("Сообщение отправлено в очередь");
                }
                catch (Exception ex)
                {
                    Logger.ErrorFormat("Ошибка доставки сообщения [{0}] в [{1}]: {2}", Title, fullQueueName, ex);
                    throw;
                }
                queue.Close();
            }
        }
예제 #3
0
        private void LoopRoutine()
        {
            // очередь сообщений от провайдера
            MessageQueue mq;

            try
            {
                var queueName = MessageQueues.FormatQueueName(HostName.MessageQueueHostName, MessageQueues.QueueFromProvider);
                mq = new MessageQueue(queueName)
                {
                    Formatter = new BinaryMessageFormatter()
                };
                Logger.InfoFormat("ProviderQueueReader: слушает очередь {0}", queueName);
            }
            catch (Exception ex)
            {
                Logger.ErrorFormat("Ошибка при обращении к очереди [{0}]: {1}",
                                   MessageQueues.QueueFromProvider, ex);
                throw;
            }

            const int messageRecvTimeout = 50;
            var       timeout            = new TimeSpan(0, 0, 0, 0, messageRecvTimeout);

            using (mq)
                while (!isStopping)
                {
                    Thread.Sleep(messagePollInterval);
                    Message msg;
                    try
                    {
                        msg = mq.Receive(timeout);
                    }
                    catch (MessageQueueException ex)
                    {
                        loggerNoFlood.LogMessageFormatCheckFlood(LogEntryType.Error,
                                                                 1, "Ошибка получения сообщения из очереди (MQE) [{0}]: {1}", MessageQueues.QueueFromProvider, ex.Message);
                        continue;
                    }
                    catch (Exception ex)
                    {
                        loggerNoFlood.LogMessageFormatCheckFlood(LogEntryType.Error,
                                                                 2, "Ошибка получения сообщения из очереди [{0}]: {1}", MessageQueues.QueueFromProvider, ex.Message);
                        continue;
                    }
                    if (msg == null)
                    {
                        continue;
                    }
                    // состояние сервиса
                    ModuleStatusController.Instance.lastProviderMessageTime.Value = DateTime.Now;

                    if (msg.Body is Nullable)
                    {
                        Logger.Error("В очереди сообщений от провайдера пустое сообщение");
                        continue;
                    }
                    if (msg.Body is ExecutionReport == false)
                    {
                        Logger.ErrorFormat("В очереди сообщений от провайдера сообщение типа {0}",
                                           msg.Body.GetType());
                        continue;
                    }
                    var execReport = (ExecutionReport)msg.Body;
                    if (execReport.brokerResponse == null)
                    {
                        Logger.ErrorFormat("ProviderQueueReader: тело ExecutionReport пустое");
                        continue;
                    }
                    // раздать сообщения получателям (FIX-дилерам)
                    ProcessExecutionReports(new List <BrokerResponse> {
                        execReport.brokerResponse
                    });
                }
        }
예제 #4
0
        private void LoopRoutine()
        {
            // очередь сообщений от провайдера
            MessageQueue mq;

            try
            {
                mq = new MessageQueue(MessageQueues.FormatQueueName(
                                          HostName.MessageQueueHostName, queueName))
                {
                    Formatter = new BinaryMessageFormatter()
                };
            }
            catch (Exception ex)
            {
                Logger.ErrorFormat("Ошибка при обращении к очереди [{0}]: {1}",
                                   MessageQueues.QueueFromProvider, ex);
                throw;
            }
            var timeout = new TimeSpan(0, 0, 0, 0, messageRecvTimeout);

            using (mq)
                while (!isStopping)
                {
                    Thread.Sleep(messagePollInterval);
                    Message msg;
                    try
                    {
                        msg = mq.Receive(timeout);
                    }
                    catch (MessageQueueException)
                    {
                        //LoggerNoFlood.LogMessageFormatCheckFlood(LogEntryType.Error,
                        //    LogMsgReadQueueError, "Ошибка получения сообщения из очереди (MQE) [{0}]: {1}", queueName, ex);
                        continue;
                    }
                    catch (Exception ex)
                    {
                        LoggerNoFlood.LogMessageFormatCheckFlood(LogEntryType.Error,
                                                                 LogMsgReadQueueError, "Ошибка получения сообщения из очереди [{0}]: {1}", queueName, ex.GetType().Name);
                        continue;
                    }
                    if (msg == null)
                    {
                        continue;
                    }
                    // раздать сообщения получателям (FIX-дилерам)
                    object body;
                    try
                    {
                        body = msg.Body;
                    }
                    catch (Exception ex)
                    {
                        LoggerNoFlood.LogMessageFormatCheckFlood(LogEntryType.Error,
                                                                 LogMsgReadQueueBodyError, "Ошибка получения чтения тела сообщения в очереди [{0}]: {1}", queueName, ex);
                        continue;
                    }
                    if (body == null)
                    {
                        Logger.ErrorFormat("В очереди сообщений от дилера [{0}] пустое сообщение",
                                           queueName);
                        continue;
                    }
                    if (body is MarketOrder == false)
                    {
                        Logger.ErrorFormat("В очереди сообщений от дилера [{0}] сообщение типа [{1}]",
                                           queueName, body.GetType());
                        continue;
                    }
                    var order = (MarketOrder)body;
                    // проверка на устаревание
                    var timeElapsed = DateTime.Now - order.TimeSent;
                    if (timeElapsed.Milliseconds > MarketOrder.MillisecondsToStale)
                    {
                        Logger.InfoFormat("Ордер [{1} {2} {3}] устарел (прошло {0} сек.)",
                                          timeElapsed.TotalSeconds,
                                          order.brokerOrder.Side > 0 ? "BUY" : "SELL", order.brokerOrder.Volume, order.brokerOrder.Ticker);
                        continue;
                    }
                    onMarketOrderReceived(queueName, new [] { order });
                }
        }