/// <summary>
 /// Handles processing the specified message with the context
 /// </summary>
 /// <param name="context">The context.</param>
 /// <param name="transportMessage">The transport message.</param>
 /// <returns></returns>
 public async Task Handle(IMessageContext context, IReceivedMessageInternal transportMessage)
 {
     using (var heartBeat = _heartBeatWorkerFactory.Create(context))
     {
         try
         {
             await _methodToRun.HandleAsync(transportMessage, context.WorkerNotification).ConfigureAwait(false);
             _commitMessage.Commit(context);
         }
         // ReSharper disable once UncatchableException
         catch (ThreadAbortException)
         {
             heartBeat.Stop();
             throw;
         }
         catch (OperationCanceledException)
         {
             heartBeat.Stop();
             throw;
         }
         catch (Exception exception)
         {
             heartBeat.Stop();
             _messageExceptionHandler.Handle(transportMessage, context, exception.InnerException ?? exception);
         }
     }
 }
 public Task Respond(ChatContextHolder chatContextHolder, IMessageContext context)
 {
     return Task.Run(() =>
     {
         foreach (LightPin pin in _lights)
         {
             pin.Set(context.Text, _pinManager);
         }
         LightPin[] allOn = _lights.Where(x => x.ContainsSection(context.Text) && x.IsOn(context.Text)).ToArray();
         if (!allOn.Select(x => x.Color).Any())
         {
             context.Respond(string.Format("{0} lights are now off",
                 _lights.Where(x => x.ContainsSection(context.Text))
                     .Select(x => x.Section)
                     .Distinct()
                     .StringJoin()));
         }
         else
         {
             context.Respond(string.Format("{0} {1} lights are now on",
                 allOn.Select(x => x.Section).Distinct().StringJoin(),
                 allOn.Select(x => x.Color).Distinct().StringJoin()));
         }
     });
 }
示例#3
0
        internal static MessageContext Enter(IDictionary<string, string> headers)
        {
            if (current != null)
            {
#if DEBUG
                throw new InvalidOperationException(
                    string.Format(
                        @"Cannot establish new message context when one is already present!

Stacktrace of when the current message context was created:
{0}",
                        current.StackTrace));
#else
                throw new InvalidOperationException(
                    string.Format("Cannot establish new message context when one is already present"));
#endif

            }
            var messageContext = new MessageContext(headers);

            current = messageContext;

            Established(current);

            return messageContext;
        }
示例#4
0
 /// <summary>
 /// Handles processing the specified message with the context
 /// </summary>
 /// <param name="context">The context.</param>
 /// <param name="transportMessage">The transport message.</param>
 /// <returns></returns>
 public bool Handle(IMessageContext context, IReceivedMessageInternal transportMessage)
 {
     using (var heartBeat = _heartBeatWorkerFactory.Create(context))
     {
         try
         {
             _methodToRun.Handle(transportMessage, context.WorkerNotification);
             _commitMessage.Commit(context);
             return true;
         }
         // ReSharper disable once UncatchableException
         catch (ThreadAbortException)
         {
             heartBeat.Stop();
             throw;
         }
         catch (OperationCanceledException)
         {
             heartBeat.Stop();
             throw;
         }
         catch (Exception exception)
         {
             heartBeat.Stop();
             _messageExceptionHandler.Handle(transportMessage, context, exception);
         }
     }
     return false;
 }
示例#5
0
 public void End(IServiceLocator childServiceLocator, IMessageContext messageContext, Exception ex)
 {
     if (ex == null)
         LogMessage("Commit");
     else
         LogMessage("Rollback, reason: " + ex);
 }
        /// <summary>
        /// Receives a new message.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <returns></returns>
        public IReceivedMessageInternal ReceiveMessage(IMessageContext context)
        {
            context.Commit += ContextOnCommit;
            context.Rollback += ContextOnRollback;
            context.Cleanup += context_Cleanup;

            TimeSpan? timeout = null;
            IMessageId messageId = null;
            var rpc = context.Get(_headers.StandardHeaders.RpcContext);
            if (rpc?.Timeout != null)
            {
                timeout = rpc.Timeout;
            }
            if (rpc?.MessageId != null)
            {
                messageId = rpc.MessageId;
            }

            using (
                var workSub = rpc?.MessageId != null && rpc.MessageId.HasValue
                    ? _workSubFactory.Create(rpc.MessageId)
                    : _workSubFactory.Create())
            {
                while (true)
                {
                    if (_cancelWork.Tokens.Any(m => m.IsCancellationRequested))
                    {
                        return null;
                    }

                    var message = GetMessage(context, messageId);
                    if (message != null && !message.Expired)
                    {
                        return message.Message;
                    }

                    if (_cancelWork.Tokens.Any(m => m.IsCancellationRequested))
                    {
                        return null;
                    }

                    workSub.Reset();
                    message = GetMessage(context, messageId);
                    if (message != null && !message.Expired)
                    {
                        return message.Message;
                    }
                    if (message != null && message.Expired)
                    {
                        continue;
                    }
                    if (workSub.Wait(timeout))
                    {
                        continue;
                    }

                    return null;
                }
            }
        }
 /// <summary>
 /// Updates the heart beat for a record.
 /// </summary>
 /// <param name="context">The context.</param>
 /// <returns></returns>
 public IHeartBeatStatus Send(IMessageContext context)
 {
     using (_timer.NewContext())
     {
         return _handler.Send(context);
     }
 }
        /// <summary>
        /// Get a validation message
        /// </summary>
        /// <param name="context">Context</param>
        /// <returns>
        /// String if found; otherwise <c>null</c>.
        /// </returns>
        public string GetMessage(IMessageContext context)
        {
            if (context.Attribute is CompareAttribute)
                return "The {0} and {1} fields to not match.";

            return null;
        }
示例#9
0
        /// <summary>
        /// Returns the next message, if any.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <returns>
        /// A message if one is found; null otherwise
        /// </returns>
        public IReceivedMessageInternal GetMessage(IMessageContext context)
        {
            //if stopping, exit now
            if (_cancelToken.Tokens.Any(t => t.IsCancellationRequested))
            {
                return null;
            }

            //check for a specific MessageID to pull
            IMessageId messageId = null;
            var rpc = context.Get(_configuration.HeaderNames.StandardHeaders.RpcContext);
            if (rpc?.MessageId != null && rpc.MessageId.HasValue)
            {
                messageId = rpc.MessageId;
            }

            //ask for the next message, or a specific message if we have a messageID
            var receivedTransportMessage =
                _receiveMessage.Handle(new ReceiveMessageQuery(messageId, _configuration.Routes));

            //if no message (null) run the no message action and return
            if (receivedTransportMessage == null)
            {
                return null;
            }

            //set the message ID on the context for later usage
            context.MessageId = receivedTransportMessage.MesssageId;
            
            return receivedTransportMessage;
        }
示例#10
0
        /// <summary>
        /// Initializes a new instance of the <see cref="HeartBeatWorker" /> class.
        /// </summary>
        /// <param name="configuration">The configuration.</param>
        /// <param name="context">The context.</param>
        /// <param name="sendHeartBeat">The send heart beat.</param>
        /// <param name="threadPool">The thread pool.</param>
        /// <param name="log">The log.</param>
        /// <param name="heartBeatNotificationFactory">The heart beat notification factory.</param>
        public HeartBeatWorker(IHeartBeatConfiguration configuration, 
            IMessageContext context,
            ISendHeartBeat sendHeartBeat,
            IHeartBeatThreadPool threadPool,
            ILogFactory log,
            IWorkerHeartBeatNotificationFactory heartBeatNotificationFactory)
        {
            Guard.NotNull(() => configuration, configuration);
            Guard.NotNull(() => context, context);
            Guard.NotNull(() => sendHeartBeat, sendHeartBeat);
            Guard.NotNull(() => threadPool, threadPool);
            Guard.NotNull(() => log, log);
            Guard.NotNull(() => heartBeatNotificationFactory, heartBeatNotificationFactory);

            _context = context;
            _checkTimespan = configuration.CheckTime;
            _sendHeartbeat = sendHeartBeat;
            _smartThreadPool = threadPool;
            _logger = log.Create();

            _runningLock = new ReaderWriterLockSlim();
            _stoppedLock = new ReaderWriterLockSlim();

            _cancel = new CancellationTokenSource();
            context.WorkerNotification.HeartBeat = heartBeatNotificationFactory.Create(_cancel.Token);
        }
 protected Command(Guid aggregateId, int version, IMessageContext context)
 {
     AggregateId = aggregateId;
     UtcDate = SystemClock.UtcNow;
     Version = version;
     Metadata = context.Metadata;
 }
示例#12
0
 public void Publish(IMessage message, IMessageContext sender)
 {
     var messageTpye = message.GetType();
     if (handlers.ContainsKey(messageTpye))
     {
         foreach (var handler in handlers[messageTpye])
         {
             dynamic instance = handlerFactory(handler);
             try
             {
                 if (HasResponse(message))
                 {
                     var result = instance.Handle((dynamic)(message.ToPublishedMessage(sender)));
                     sender.Respond(result);
                 }
                 else
                     instance.Handle((dynamic)(message.ToPublishedMessage(sender)));
             }
             catch (Exception ex)
             {
                 sender.ErrorFormat("{0} , {1}", ex.Message, ex.StackTrace);
             }
         }
     }
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="MoveRecordToErrorQueueCommand" /> class.
 /// </summary>
 /// <param name="exception">The exception.</param>
 /// <param name="queueId">The queue identifier.</param>
 /// <param name="context">The context.</param>
 public MoveRecordToErrorQueueCommand(Exception exception, long queueId, IMessageContext context)
 {
     Guard.NotNull(() => context, context);
     Exception = exception;
     QueueId = queueId;
     MessageContext = context;
 }
示例#14
0
 /// <summary>
 /// messaging callback
 /// see com.db4o.messaging.MessageRecipient#ProcessMessage()
 /// </summary>
 public void ProcessMessage(IMessageContext con, object message)
 {
     if (message is StopServer)
     {
         Close();
     }
 }
示例#15
0
        public HandleResult Handle(IMessageContext msg)
        {
            if (msg.IsInitiallyPolled)
                return HandleResult.Ignored;

            var update = msg.Update;

            if (update.Message.Chat.Id == -1001013065325)
            {
                var eva = new Regex(@"\b[eе]+[vв]+[aа]+\b", RegexOptions.IgnoreCase);

                if (eva.IsMatch(update.Message.Text ?? ""))
                {
                    _ctx.BotApi.SendMessageAsync(-1001013065325, "чо");
                    return HandleResult.HandledCompletely;
                }

                if (update.Message.From.Id == 146268050)
                {
                    var roll = new Random().Next(10);
                    if (roll == 7)
                        _ctx.BotApi.SendMessageAsync(-1001013065325, "юль, ну впиши по-братски");
                    return HandleResult.HandledCompletely;
                }
            }

            return HandleResult.Ignored;
        }
示例#16
0
 /// <summary>
 /// Commits the processed message, by deleting the message
 /// </summary>
 /// <param name="context">The context.</param>
 public void Commit(IMessageContext context)
 {
     if (context.MessageId != null && context.MessageId.HasValue)
     {
         _deleteMessageCommand.Handle(new DeleteMessageCommand((long)context.MessageId.Id.Value));
     }
 }
 /// <summary>
 /// Invoked when we have dequeued a message, but a failure occurred during re-assembly.
 /// </summary>
 /// <param name="context">The context.</param>
 /// <param name="exception">The exception.</param>
 public void Handle(IMessageContext context, PoisonMessageException exception)
 {
     if (context.MessageId != null && context.MessageId.HasValue)
     {
         _commandMoveRecord.Handle(new MoveRecordToErrorQueueCommand((RedisQueueId)context.MessageId));
     }
     context.MessageId = null;
 }
 public Task Respond(ChatContextHolder chatContextHolder, IMessageContext context)
 {
     var volumeLevel = ValueConverterHelper.ToInt(ExtractStartsWith(context, "set volume"),10);
     var result = string.Format("volume set to {0}", volumeLevel);
     _textToSpeech.Play(result);
     _volumeSetter.SetVolume(volumeLevel);
     return context.Respond(result);
 }
        public MessageSender(IMessageContext context)
        {
            m_Context = context;
            m_MessageBuffer = new ConcurrentQueue<string>();

            m_MessageThread = new Thread(OnThreadStarted);
            m_MessageThread.Start();
        }
示例#20
0
 void IQueueMessageHandler.Handle(QueueMessage queueMessage, IMessageContext context)
 {
     var message = _jsonSerializer.Deserialize<EventStreamMessage>(Encoding.UTF8.GetString(queueMessage.Body));
     var domainEventStreamMessage = ConvertToDomainEventStream(message);
     var processContext = new DomainEventStreamProcessContext(this, domainEventStreamMessage, queueMessage, context);
     var processingMessage = new ProcessingDomainEventStreamMessage(domainEventStreamMessage, processContext);
     _processor.Process(processingMessage);
 }
 void IQueueMessageHandler.Handle(QueueMessage queueMessage, IMessageContext context)
 {
     var applicationMessageType = _typeNameProvider.GetType(queueMessage.Tag);
     var message = _jsonSerializer.Deserialize(Encoding.UTF8.GetString(queueMessage.Body), applicationMessageType) as IApplicationMessage;
     var processContext = new EQueueProcessContext(queueMessage, context);
     var processingMessage = new ProcessingApplicationMessage(message, processContext);
     _processor.Process(processingMessage);
 }
 /// <summary>
 /// Commits the message associated with the message context
 /// </summary>
 /// <param name="context"></param>
 /// <returns></returns>
 public bool Commit(IMessageContext context)
 {
     var result = _handler.Commit(context);
     if (result)
     {
         _commitCounter.Increment();
     }
     return result;
 }
示例#23
0
 public Command(IMessageContext messageContext, Exception ex = null)
     : base(messageContext)
 {
     if (ex != null)
     {
         Error = ex.GetBaseException().Message;
         StackTrace = ex.StackTrace;
     }
 }
示例#24
0
 public void Handle(QueueMessage message, IMessageContext context)
 {
     var count = Interlocked.Increment(ref _handledCount);
     if (count % 1000 == 0)
     {
         Console.WriteLine("Total handled {0} messages.", count);
     }
     context.OnMessageHandled(message);
 }
        public MessageReceiver(IMessageContext context)
        {
            m_Context = context;

            m_Lock = new object();

            m_MessageThread = new Thread(SubscribeAndWait);
            m_MessageThread.Start();
        }
示例#26
0
 public Task HandleMessage(object content, IMessageContext messageContext,
     CancellationToken cancellationToken = default(CancellationToken))
 {
     Log.DebugFormat("Handling message ID {0}...", messageContext.Headers.MessageId);
     HandledMessageQueue.Enqueue(content);
     messageContext.Acknowledge();
     MessageReceivedEvent.Set();
     return Task.FromResult(true);
 }
示例#27
0
        static void DecodeUserContextHeadersIfPossible(IBus bus, IMessageContext messageContext)
        {
            var headers = messageContext.Headers;
            if (!headers.ContainsKey(UserContextHeaderKey)) return;

            var encodedUserContext = (string) headers[UserContextHeaderKey];

            messageContext.Items[UserContextItemKey] = Decode(encodedUserContext);
        }
 /// <summary>
 /// Rolls back the message associated to the context
 /// </summary>
 /// <param name="context"></param>
 /// <returns>
 /// true if the message was rolled back
 /// </returns>
 public bool Rollback(IMessageContext context)
 {
     var result = _handler.Rollback(context);
     if (result)
     {
         _rollbackCounter.Increment();
     }
     return result;
 }
 public async Task Respond(ChatContextHolder chatContextHolder, IMessageContext context)
 {
     var oneLiner = RandomTextHelper.OneLiner.Split('.');
     foreach (var message in oneLiner)
     {
         await context.Respond(message);
         await Task.Delay(5000);
     }
 }
示例#30
0
        /// <summary>
        /// Constructs the saga context, registering the context under the key
        /// <see cref="SagaContextItemKey"/> in the current message context
        /// (if one is available)
        /// </summary>
        public SagaContext(Guid id)
        {
            Id = id;

            if (MessageContext.HasCurrent)
            {
                messageContext = MessageContext.GetCurrent();
                messageContext.Items[SagaContextItemKey] = this;
            }
        }
        public Task Execute(IMessagingRoot root, IMessageContext context, DateTime utcNow)
        {
            var envelope = context.Envelope;

            return(envelope.Callback.MoveToScheduledUntil(utcNow.Add(Delay), envelope));
        }
示例#32
0
 /// <summary>
 /// Aborts the current message processing pipeline by making the currently executing handler the last one.
 /// This means that any message handlers following the current one in the current pipeline will NOT be executed.
 /// If no errors occurred, the queue transaction will be committed as if everything is allright.
 /// This method can be used to ABORT message process to allow for a handler to FUNCTION AS A FILTER.
 /// </summary>
 public static void AbortDispatch(this IMessageContext messageContext)
 {
     messageContext.IncomingStepContext.Save(DispatchIncomingMessageStep.AbortDispatchContextKey, true);
 }
示例#33
0
        public async Task <bool> TryHandleAsync(IMessageContext context,
                                                CancellationToken cancellationToken = default)
        {
            switch (context.Event)
            {
            case MessageEvent.Create: break;

            default: return(false);
            }

            var content = context.Message.Content;

            // ignore urls in commands
            if (content.StartsWith(_settings.Discord.Prefix))
            {
                return(false);
            }

            // match gallery urls
            var ids = GalleryUtility.ParseMany(content);

            if (ids.Length == 0)
            {
                return(false);
            }

            if (_logger.IsEnabled(LogLevel.Debug))
            {
                _logger.LogDebug($"Matched galleries: {string.Join(", ", ids.Select((s, i) => $"{s}/{i}"))}");
            }

            // send interactive
            using (context.BeginTyping())
            {
                // send one interactive if only one id detected
                if (ids.Length == 1)
                {
                    var(source, id) = ids[0];

                    Doujin doujin;

                    using (var scope = _services.CreateScope())
                    {
                        doujin = await scope.ServiceProvider
                                 .GetRequiredService <IDatabase>()
                                 .GetDoujinAsync(source, id, cancellationToken);
                    }

                    if (doujin == null)
                    {
                        await context.ReplyAsync("doujinNotFound");
                    }
                    else
                    {
                        await _interactive.SendInteractiveAsync(
                            new DoujinMessage(doujin),
                            context,
                            cancellationToken);
                    }
                }

                // send as a list
                else
                {
                    await _interactive.SendInteractiveAsync(
                        new GalleryUrlDetectedMessage(ids),
                        context,
                        cancellationToken);
                }
            }

            return(true);
        }
示例#34
0
 public Task PublishAsync(IMessageContext messageContext, string topic, CancellationToken cancellationToken)
 {
     return(_producer.SendAsync(GetEQueueMessage(messageContext, topic), messageContext.Key, cancellationToken));
 }
示例#35
0
            public void ProcessMessage(IMessageContext context, object message)
            {
                var sender = context.Sender;

                sender.Send("reply: " + message);
            }
示例#36
0
        protected async virtual Task ConsumeMessage(IMessageContext commandContext)
        {
            var             command      = commandContext.Message as ICommand;
            IMessageContext messageReply = null;

            if (command == null)
            {
                return;
            }
            var needRetry = command.NeedRetry;

            using (var scope = IoCFactory.Instance.CurrentContainer.CreateChildContainer())
            {
                scope.RegisterInstance(typeof(IMessageContext), commandContext);
                var eventMessageStates = new List <MessageState>();
                var messageStore       = scope.Resolve <IMessageStore>();
                var eventBus           = scope.Resolve <IEventBus>();
                var commandHasHandled  = messageStore.HasCommandHandled(commandContext.MessageID);
                if (commandHasHandled)
                {
                    messageReply = _messageQueueClient.WrapMessage(new MessageDuplicatelyHandled(), commandContext.MessageID, commandContext.ReplyToEndPoint);
                    eventMessageStates.Add(new MessageState(messageReply));
                }
                else
                {
                    var messageHandlerType = _handlerProvider.GetHandlerTypes(command.GetType()).FirstOrDefault();
                    _logger.InfoFormat("Handle command, commandID:{0}", commandContext.MessageID);

                    if (messageHandlerType == null)
                    {
                        messageReply = _messageQueueClient.WrapMessage(new NoHandlerExists(), commandContext.MessageID, commandContext.ReplyToEndPoint);
                        eventMessageStates.Add(new MessageState(messageReply));
                    }
                    else
                    {
                        object messageHandler = null;
                        do
                        {
                            try
                            {
                                if (messageHandler == null)
                                {
                                    messageHandler = scope.Resolve(messageHandlerType.Type);
                                }

                                using (var transactionScope = new TransactionScope(TransactionScopeOption.Required,
                                                                                   new TransactionOptions {
                                    IsolationLevel = System.Transactions.IsolationLevel.ReadUncommitted
                                },
                                                                                   TransactionScopeAsyncFlowOption.Enabled))
                                {
                                    if (messageHandlerType.IsAsync)
                                    {
                                        await((dynamic)messageHandler).Handle((dynamic)command)
                                        .ConfigureAwait(false);
                                    }
                                    else
                                    {
                                        await Task.Run(() =>
                                        {
                                            ((dynamic)messageHandler).Handle((dynamic)command);
                                        }).ConfigureAwait(false);
                                    }

                                    messageReply = _messageQueueClient.WrapMessage(commandContext.Reply, commandContext.MessageID, commandContext.ReplyToEndPoint);
                                    eventMessageStates.Add(new MessageState(messageReply));
                                    eventBus.GetEvents().ForEach(@event =>
                                    {
                                        var topic = @event.GetTopic();
                                        if (!string.IsNullOrEmpty(topic))
                                        {
                                            topic = Configuration.Instance.FormatAppName(topic);
                                        }
                                        var eventContext = _messageQueueClient.WrapMessage(@event, commandContext.MessageID, topic, @event.Key);
                                        eventMessageStates.Add(new MessageState(eventContext));
                                    });

                                    messageStore.SaveCommand(commandContext, eventMessageStates.Select(s => s.MessageContext).ToArray());
                                    transactionScope.Complete();
                                }
                                needRetry = false;
                            }
                            catch (Exception e)
                            {
                                eventMessageStates.Clear();
                                if (e is OptimisticConcurrencyException && needRetry)
                                {
                                    eventBus.ClearMessages();
                                }
                                else
                                {
                                    messageStore.Rollback();
                                    messageReply = _messageQueueClient.WrapMessage(e.GetBaseException(), commandContext.MessageID, commandContext.ReplyToEndPoint);
                                    eventMessageStates.Add(new MessageState(messageReply));
                                    eventBus.GetToPublishAnywayMessages().ForEach(@event =>
                                    {
                                        var topic = @event.GetTopic();
                                        if (!string.IsNullOrEmpty(topic))
                                        {
                                            topic = Configuration.Instance.FormatAppName(topic);
                                        }
                                        var eventContext = _messageQueueClient.WrapMessage(@event, commandContext.MessageID, topic, @event.Key);
                                        eventMessageStates.Add(new MessageState(eventContext));
                                    });

                                    if (e is DomainException)
                                    {
                                        _logger.Warn(command.ToJson(), e);
                                    }
                                    else
                                    {
                                        _logger.Error(command.ToJson(), e);
                                    }
                                    messageStore.SaveFailedCommand(commandContext, e, eventMessageStates.Select(s => s.MessageContext).ToArray());
                                    needRetry = false;
                                }
                            }
                        } while (needRetry);
                    }
                }
                try
                {
                    if (_messagePublisher != null && eventMessageStates.Count > 0)
                    {
                        _messagePublisher.SendAsync(eventMessageStates.ToArray());
                    }
                }
                catch (Exception ex)
                {
                    _logger.Error($"_messagePublisher SendAsync error", ex);
                }
                _removeMessageContext(commandContext);
            }
        }
示例#37
0
        public static void SetStateData <T>(this IMessageContext messageContext, string key, T data)
        {
            var stateDataKey = GetStateDataKey(key);

            messageContext.Set(stateDataKey, data);
        }
 /// <summary>
 /// Clean up the message context when processing is done
 /// </summary>
 /// <param name="context">The context.</param>
 private void ContextCleanup(IMessageContext context)
 {
     context.Commit   -= ContextOnCommit;
     context.Rollback -= ContextOnRollback;
     context.Cleanup  -= Context_Cleanup;
 }
示例#39
0
 public CommandExecuteContext(IRepository repository, IAggregateStorage aggregateRootStorage, QueueMessage queueMessage, IMessageContext messageContext, CommandMessage commandMessage, SendReplyService sendReplyService)
 {
     _trackingAggregateRootDict = new ConcurrentDictionary <string, IAggregateRoot>();
     _repository           = repository;
     _aggregateRootStorage = aggregateRootStorage;
     _sendReplyService     = sendReplyService;
     _queueMessage         = queueMessage;
     _commandMessage       = commandMessage;
     _messageContext       = messageContext;
 }
示例#40
0
 private void AddMessageIdToMessageTracker(IMessageContext <AircraftLeftRunway> context)
 => _messageTracker.Ids.Add(context.MessageId);
示例#41
0
 public async Task <TagDTO[]> HandleAsync(IMessageContext context, GetTags query)
 {
     return((await _repository.GetTagsAsync(query.ApplicationId, query.IncidentId)).Select(ConvertTag).ToArray());
 }
        /// <summary>
        /// Handles a message that has failed processing
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="context">The context.</param>
        /// <param name="exception">The exception.</param>
        public ReceiveMessagesErrorResult MessageFailedProcessing(IReceivedMessageInternal message, IMessageContext context,
                                                                  Exception exception)
        {
            //message failed to process
            if (context.MessageId == null || !context.MessageId.HasValue)
            {
                return(ReceiveMessagesErrorResult.NoActionPossible);
            }

            var info =
                _configuration.TransportConfiguration.RetryDelayBehavior.GetRetryAmount(exception);
            string exceptionType = null;

            if (info.ExceptionType != null)
            {
                exceptionType = info.ExceptionType.ToString();
            }

            var bSendErrorQueue = false;

            if (string.IsNullOrEmpty(exceptionType) || info.MaxRetries <= 0)
            {
                bSendErrorQueue = true;
            }
            else
            {
                //determine how many times this exception has been seen for this message
                var metadata = _queryGetMetaData.Handle(new GetMetaDataQuery((RedisQueueId)context.MessageId));
                var retries  = metadata.ErrorTracking.GetExceptionCount(exceptionType);
                if (retries >= info.MaxRetries)
                {
                    bSendErrorQueue = true;
                }
                else
                {
                    context.Set(_headers.IncreaseQueueDelay, new RedisQueueDelay(info.Times[retries]));
                    metadata.ErrorTracking.IncrementExceptionCount(exceptionType);
                    _saveMetaData.Handle(new SaveMetaDataCommand((RedisQueueId)context.MessageId, metadata));
                }
            }

            if (!bSendErrorQueue)
            {
                return(ReceiveMessagesErrorResult.Retry);
            }

            _commandMoveRecord.Handle(
                new MoveRecordToErrorQueueCommand <string>(exception, context.MessageId.Id.Value.ToString(), context));
            //we are done doing any processing - remove the messageID to block other actions
            context.SetMessageAndHeaders(null, context.Headers);
            _log.LogError($"Message with ID {message.MessageId} has failed and has been moved to the error queue", exception);
            return(ReceiveMessagesErrorResult.Error);
        }
示例#43
0
 public static void Error(this IMessageContext context, string message)
 {
     context.Respond(new WriteToOutput(MessageType.Error, message));
 }
示例#44
0
 public static void InfoFormat(this IMessageContext context, string message, params object[] args)
 {
     context.Respond(new WriteToOutput(MessageType.Info, string.Format(message, args)));
 }
示例#45
0
 public Task Handle(Envelope envelope, IMessageContext context)
 {
     return(context
            .Advanced
            .SendFailureAcknowledgement("I don't know how to process this message"));
 }
示例#46
0
 void RaiseMessageContextEstablished(IMessageContext messageContext)
 {
     events.RaiseMessageContextEstablished(this, messageContext);
 }
 public MessageRepository(IMessageContext messageContext)
 {
     _context = messageContext;
 }
示例#48
0
 /// <summary>
 /// Rolls back the message associated to the context
 /// </summary>
 /// <param name="context"></param>
 /// <returns>
 /// true if the message was rolled back
 /// </returns>
 public bool Rollback(IMessageContext context)
 {
     context.RaiseRollback();
     return(true);
 }
示例#49
0
        public static T GetStateData <T>(this IMessageContext messageContext, string key) where T : class
        {
            var stateDataKey = GetStateDataKey(key);

            return(messageContext.Get <T>(stateDataKey));
        }
示例#50
0
 async Task IMessageHandler <B> .HandleMessage(B content, IMessageContext messageContext, CancellationToken cancellationToken)
 {
     await messageContext.SendReply("B", cancellationToken : cancellationToken);
 }
示例#51
0
 internal static void Set <T>(this IMessageContext messageContext, string key, T data)
 {
     messageContext.Headers[key] = SerializeToString(data);
 }
示例#52
0
 public Task Handle(Test command, IMessageContext context) => CompletedTask;
示例#53
0
 public Task SendAsync(IMessageContext messageContext, string queue, CancellationToken cancellationToken)
 {
     return(_producer.SendAsync(GetEQueueMessage(messageContext, queue), messageContext.Key, cancellationToken));
 }
示例#54
0
 public Handler(IMessageContext messageContext, IBus bus, ManualResetEvent hasDeferredMessage)
 {
     _messageContext     = messageContext;
     _bus                = bus;
     _hasDeferredMessage = hasDeferredMessage;
 }
示例#55
0
 public MySaga(int targetMessageCount, IMessageContext messageContext, IBus bus)
 {
     _targetMessageCount = targetMessageCount;
     _messageContext     = messageContext;
     _bus = bus;
 }
        public void Dispose()
        {
            current = null;

            Disposed();
        }
 //made an interface 'context' so i can switch to any other context with those specified methods.
 public MessageRepository(IMessageContext context)
 {
     this.context = context;
 }
示例#58
0
 public SomeHandler(IMessageContext context)
 {
     this.context = context;
 }
示例#59
0
 public Task SendAsync(IMessageContext messageContext, string queue, CancellationToken cancellationToken)
 {
     return(Task.FromResult <object>(null));
 }
示例#60
0
 public Task PublishAsync(IMessageContext messageContext, string topic, CancellationToken cancellationToken)
 {
     return(Task.FromResult <object>(null));
 }