/// <inheritdoc />
        public ReceiveMessagesErrorResult MessageFailedProcessing(IReceivedMessageInternal message, IMessageContext context, Exception exception)
        {
            var spanContext = message.Extract(_tracer, _headers);

            if (spanContext != null)
            {
                using (IScope scope = _tracer.BuildSpan("Error").AddReference(References.FollowsFrom, spanContext).StartActive(finishSpanOnDispose: true))
                {
                    scope.Span.Log(exception.ToString());
                    Tags.Error.Set(scope.Span, true);
                    var result = _handler.MessageFailedProcessing(message, context, exception);
                    scope.Span.SetTag("WillRetry", result == ReceiveMessagesErrorResult.Retry);
                    return(result);
                }
            }
            else
            {
                using (IScope scope = _tracer.BuildSpan("Error").StartActive(finishSpanOnDispose: true))
                {
                    scope.Span.AddMessageIdTag(message);
                    scope.Span.Log(exception.ToString());
                    Tags.Error.Set(scope.Span, true);
                    var result = _handler.MessageFailedProcessing(message, context, exception);
                    scope.Span.SetTag("WillRetry", result == ReceiveMessagesErrorResult.Retry);
                    return(result);
                }
            }
        }
 /// <summary>
 /// Handles the specified message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="workerNotification">The worker notification.</param>
 /// <returns>
 /// an awaitable task
 /// </returns>
 public async Task Handle(IReceivedMessageInternal message, IWorkerNotification workerNotification)
 {
     using (_runCodeTimer.NewContext())
     {
         await _handler.Handle(message, workerNotification).ConfigureAwait(false);
     }
 }
 /// <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);
 }
Exemple #4
0
        /// <summary>
        /// Handles the specified message.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="context">The context.</param>
        /// <param name="exception">The exception.</param>
        /// <exception cref="DotNetWorkQueueException">An error has occurred in the error handling code</exception>
        /// <exception cref="MessageException">An unhanded exception has occurred while processing a message</exception>
        public void Handle(IReceivedMessageInternal message, IMessageContext context, Exception exception)
        {
            ReceiveMessagesErrorResult result;

            try
            {
                result = _transportErrorHandler.MessageFailedProcessing(message, context,
                                                                        exception);
            }
            catch (Exception errorHandlingError)
            {
                _log.ErrorException(
                    "An error has occurred while trying to move message {0} to the error queue", exception,
                    message.MessageId);
                throw new DotNetWorkQueueException("An error has occurred in the error handling code",
                                                   errorHandlingError);
            }

            switch (result)
            {
            case ReceiveMessagesErrorResult.Retry:
            case ReceiveMessagesErrorResult.NotSpecified:
            case ReceiveMessagesErrorResult.NoActionPossible:
                throw new MessageException("An unhanded exception has occurred while processing a message",
                                           exception, message.MessageId, message.CorrelationId);

            case ReceiveMessagesErrorResult.Error:     //don't throw exception, as the message has been moved
                break;
            }
        }
 /// <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);
         }
     }
 }
        /// <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 HandleAsync(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);
                }
            }
        }
        /// <summary>
        /// Generates a <see cref="IReceivedMessage{T}" /> from a <see cref="IReceivedMessageInternal" />
        /// </summary>
        /// <param name="messageType">Type of the output message.</param>
        /// <param name="message">The message.</param>
        /// <returns></returns>
        public dynamic GenerateMessage(Type messageType, IReceivedMessageInternal message)
        {
            var getHandlerGenericMethod = GetType().GetMethod("GetMessage", new[] { message.GetType() });
            var generic = getHandlerGenericMethod.MakeGenericMethod(messageType);

            return(generic.Invoke(this, new object[] { message }));
        }
        public MessageProcessingRpcReceive <FakeMessage> Create()
        {
            var fixture         = new Fixture().Customize(new AutoNSubstituteCustomization());
            var receiveMessages = fixture.Create <IReceiveMessagesFactory>();

            fixture.Inject(receiveMessages);
            var fakeMessage = fixture.Create <IMessage>();

            fakeMessage.Body.Returns(new FakeMessage());
            fixture.Inject(fakeMessage);
            ICommitMessage commitMessage = fixture.Create <CommitMessage>();

            fixture.Inject(commitMessage);

            IReceivedMessageInternal message = fixture.Create <ReceivedMessageInternal>();

            var messageHandlerRegistration = fixture.Create <IMessageHandlerRegistration>();

            messageHandlerRegistration.GenerateMessage(message)
            .Returns(new ReceivedMessage <FakeMessage>(message));
            fixture.Inject(messageHandlerRegistration);

            receiveMessages.Create().ReceiveMessage(null).ReturnsForAnyArgs(message);

            return(fixture.Create <MessageProcessingRpcReceive <FakeMessage> >());
        }
 /// <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;
 }
Exemple #10
0
 /// <summary>
 /// Adds the message identifier tag.
 /// </summary>
 /// <param name="span">The span.</param>
 /// <param name="message">The message.</param>
 public static void AddMessageIdTag(this ISpan span, IReceivedMessageInternal message)
 {
     if (message.MessageId.HasValue)
     {
         span.SetTag("MessageId", message.MessageId.Id.Value.ToString());
     }
 }
 /// <summary>
 /// Handles the specified message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="workerNotification">The worker notification.</param>
 public void Handle(IReceivedMessageInternal message, IWorkerNotification workerNotification)
 {
     using (_runCodeTimer.NewContext())
     {
         _handler.Handle(message, workerNotification);
     }
 }
Exemple #12
0
 /// <summary>
 /// Handles the specified message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="workerNotification">The worker notification.</param>
 public async Task HandleAsync(IReceivedMessageInternal message, IWorkerNotification workerNotification)
 {
     using (_runCodeTimer.NewContext())
     {
         await _handler.HandleAsync(message, workerNotification).ConfigureAwait(false);
     }
 }
 /// <summary>
 /// Handles the specified message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="workerNotification">The worker notification.</param>
 public void Handle(IReceivedMessageInternal message, IWorkerNotification workerNotification)
 {
     using (_runCodeTimer.NewContext())
     {
         _handler.Handle(message, workerNotification);
     }
 }
Exemple #14
0
        /// <inheritdoc />
        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 retries =
                    _queryErrorRetryCount.Handle(
                        new GetErrorRetryCountQuery(exceptionType,
                                                    (long)context.MessageId.Id.Value));
                if (retries >= info.MaxRetries)
                {
                    bSendErrorQueue = true;
                }
                else
                {
                    context.Set(_headers.QueueDelay, new QueueDelay(info.Times[retries]));
                    //note zero based index - use the current count not count +1
                    _commandSetErrorCount.Handle(
                        new SetErrorCountCommand(
                            exceptionType, (long)context.MessageId.Id.Value));
                }
            }

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

            _commandMoveRecord.Handle(
                new MoveRecordToErrorQueueCommand(exception, (long)context.MessageId.Id.Value, context));
            //we are done doing any processing - remove the messageID to block other actions
            context.SetMessageAndHeaders(null, context.Headers);
            _log.ErrorException("Message with ID {0} has failed and has been moved to the error queue", exception,
                                message.MessageId);
            return(ReceiveMessagesErrorResult.Error);
        }
Exemple #15
0
        /// <inheritdoc />
        public void Handle(IReceivedMessageInternal message, IWorkerNotification workerNotification)
        {
            var ActivityContext = message.Extract(_tracer, _headers);

            using (var scope = _tracer.StartActivity("MessageHandler", ActivityKind.Internal, parentContext: ActivityContext))
            {
                _handler.Handle(message, workerNotification);
            }
        }
Exemple #16
0
        /// <summary>
        /// Initializes a new instance of the <see cref="IReceivedMessage{T}" /> class.
        /// </summary>
        /// <param name="message">The internal message.</param>
        public ReceivedMessage(IReceivedMessageInternal message)
        {
            Guard.NotNull(() => message, message);

            Body    = (T)message.Body;
            Headers = new ReadOnlyDictionary <string, object>(message.Headers.ToDictionary(entry => entry.Key,
                                                                                           entry => entry.Value));
            MessageId     = message.MessageId;
            CorrelationId = message.CorrelationId;
        }
        /// <summary>
        /// Handles the specified message.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="workerNotification">The worker notification.</param>
        /// <returns></returns>
        public async Task HandleAsync(IReceivedMessageInternal message, IWorkerNotification workerNotification)
        {
            var activityContext = message.Extract(_tracer, _headers.StandardHeaders);

            using (var scope = _tracer.StartActivity("MessageHandlerAsync", ActivityKind.Internal, activityContext))
            {
                scope?.AddMessageIdTag(message);
                await _handler.HandleAsync(message, workerNotification);
            }
        }
Exemple #18
0
 /// <summary>
 /// Extracts the specified tracer.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="tracer">The tracer.</param>
 /// <param name="headers">The headers.</param>
 /// <returns></returns>
 public static ISpanContext Extract(this IReceivedMessageInternal message, ITracer tracer, IStandardHeaders headers)
 {
     if (message.Headers.ContainsKey(headers.TraceSpan.Name))
     {
         var mapping =
             (DataMappingTextMap)message.Headers[headers.TraceSpan.Name];
         return(tracer.Extract(BuiltinFormats.TextMap, mapping));
     }
     return(null);
 }
        /// <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((RedisQueueId)context.MessageId));
            //we are done doing any processing - remove the messageID to block other actions
            context.MessageId = null;
            _log.ErrorException("Message with ID {0} has failed and has been moved to the error queue", exception,
                                message.MessageId);
            return(ReceiveMessagesErrorResult.Error);
        }
        /// <summary>
        /// Generates a <see cref="IReceivedMessage{T}" /> from a <see cref="IReceivedMessageInternal" />
        /// </summary>
        /// <param name="messageType">Type of the output message.</param>
        /// <param name="message">The message.</param>
        /// <returns></returns>
        public dynamic GenerateMessage(Type messageType, IReceivedMessageInternal message)
        {
            var getHandlerGenericMethod = GetType().GetMethod("GetMessage", new[] { message.GetType() });

            if (getHandlerGenericMethod == null)
            {
                throw new NullReferenceException("getHandlerGenericMethod is null");
            }
            var generic = getHandlerGenericMethod.MakeGenericMethod(messageType);

            return(generic.Invoke(this, new object[] { message }));
        }
        /// <summary>
        /// Generates a <see cref="IReceivedMessage{T}" /> from a <see cref="IReceivedMessageInternal" />
        /// </summary>
        /// <typeparam name="T">The type of the output message</typeparam>
        /// <param name="internalMessage">The internal message.</param>
        /// <returns></returns>
        public IReceivedMessage <T> GetMessage <T>(IReceivedMessageInternal internalMessage) where T : class
        {
            var d1 = Type.GetType("DotNetWorkQueue.Messages.ReceivedMessage`1");

            Type[] typeArgs = { typeof(T) };

            //if d1 is null, just let it throw an exception; this would indicate that something strange has happened
            // ReSharper disable once PossibleNullReferenceException
            var make = d1.MakeGenericType(typeArgs);

            return((IReceivedMessage <T>)Activator.CreateInstance(make, internalMessage, _getErrors));
        }
        /// <summary>Initializes a new instance of the <see cref="IReceivedMessage{T}"/> class.</summary>
        /// <param name="message">The internal message.</param>
        /// <param name="getErrors">Gets any previous errors that have occured for this specific message</param>
        public ReceivedMessage(IReceivedMessageInternal message, IGetPreviousMessageErrors getErrors)
        {
            Guard.NotNull(() => message, message);
            Guard.NotNull(() => getErrors, getErrors);

            _getErrors = getErrors;

            Body    = (T)message.Body;
            Headers = new ReadOnlyDictionary <string, object>(message.Headers.ToDictionary(entry => entry.Key,
                                                                                           entry => entry.Value));
            MessageId     = message.MessageId;
            CorrelationId = message.CorrelationId;
        }
Exemple #23
0
        /// <inheritdoc />
        public ReceiveMessagesErrorResult MessageFailedProcessing(IReceivedMessageInternal message, IMessageContext context, Exception exception)
        {
            var activityContext = message.Extract(_tracer, _headers);

            using (var scope = _tracer.StartActivity("Error", ActivityKind.Internal, parentContext: activityContext))
            {
                scope?.AddMessageIdTag(message);
                scope?.RecordException(exception);
                scope?.SetStatus(Status.Error);;
                var result = _handler.MessageFailedProcessing(message, context, exception);
                scope?.SetTag("WillRetry", result == ReceiveMessagesErrorResult.Retry);
                return(result);
            }
        }
Exemple #24
0
 private void ProcessResult(IReceivedMessageInternal message)
 {
     if (message.Headers.ContainsKey(_headers.StandardHeaders.FirstPossibleDeliveryDate.Name))
     {
         var waitTime =
             (ValueTypeWrapper <DateTime>)message.Headers[_headers.StandardHeaders.FirstPossibleDeliveryDate.Name];
         if (waitTime != null)
         {
             var difference = _getTime.Create().GetCurrentUtcDate() - waitTime.Value;
             _waitTimer.Record((long)difference.TotalMilliseconds, TimeUnits.Milliseconds);
         }
     }
     _meter.Mark();
 }
        /// <summary>
        /// Invoked when a message has failed to process.
        /// </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 retries =
                    _queryErrorRetryCount.Handle(
                        new GetErrorRetryCountQuery(exceptionType,
                            (long) context.MessageId.Id.Value));
                if (retries >= info.MaxRetries)
                {
                    bSendErrorQueue = true;
                }
                else
                {
                    context.Set(_headers.IncreaseQueueDelay, new SqlQueueDelay(info.Times[retries]));
                    //note zero based index - use the current count not count +1
                    _commandSetErrorCount.Handle(
                        new SetErrorCountCommand(
                            exceptionType, (long) context.MessageId.Id.Value));
                }
            }

            if (!bSendErrorQueue) return ReceiveMessagesErrorResult.Retry;

            _commandMoveRecord.Handle(
                new MoveRecordToErrorQueueCommand(exception, (long)context.MessageId.Id.Value, context));
            //we are done doing any processing - remove the messageID to block other actions
            context.MessageId = null;
            _log.ErrorException("Message with ID {0} has failed and has been moved to the error queue", exception,
                message.MesssageId);
            return ReceiveMessagesErrorResult.Error;
        }
Exemple #26
0
        /// <summary>
        /// Invoked when a message has failed to process.
        /// </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);
            }

            _dataDataStorage.MoveToErrorQueue(exception, (Guid)context.MessageId.Id.Value, 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);
        }
 /// <summary>
 /// Invoked when a message has failed to process.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="context">The context.</param>
 /// <param name="exception">The exception.</param>
 /// <returns>
 /// Result of error processing
 /// </returns>
 public ReceiveMessagesErrorResult MessageFailedProcessing(IReceivedMessageInternal message, IMessageContext context,
     Exception exception)
 {
     var result = _handler.MessageFailedProcessing(message, context, exception);
     switch (result)
     {
         case ReceiveMessagesErrorResult.Error:
             _meterError.Mark();
             break;
         case ReceiveMessagesErrorResult.Retry:
             _meterRetry.Mark();
             break;
     }
     return result;
 }
        /// <summary>
        /// Invoked when a message has failed to process.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="context">The context.</param>
        /// <param name="exception">The exception.</param>
        /// <returns>
        /// Result of error processing
        /// </returns>
        public ReceiveMessagesErrorResult MessageFailedProcessing(IReceivedMessageInternal message, IMessageContext context,
                                                                  Exception exception)
        {
            var result = _handler.MessageFailedProcessing(message, context, exception);

            switch (result)
            {
            case ReceiveMessagesErrorResult.Error:
                _meterError.Mark();
                break;

            case ReceiveMessagesErrorResult.Retry:
                _meterRetry.Mark();
                break;
            }
            return(result);
        }
 /// <summary>
 /// Handles the specified message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="context">The context.</param>
 /// <param name="exception">The exception.</param>
 /// <exception cref="DotNetWorkQueueException">An error has occurred in the error handling code</exception>
 /// <exception cref="MessageException">An unhanded exception has occurred while processing a message</exception>
 public void Handle(IReceivedMessageInternal message, IMessageContext context, Exception exception)
 {
     try
     {
         _transportErrorHandler.MessageFailedProcessing(message, context,
             exception);
     }
     catch (Exception errorHandlingError)
     {
         _log.ErrorException(
             "An error has occurred while trying to move message {0} to the error queue", exception,
             message.MesssageId);
         throw new DotNetWorkQueueException("An error has occurred in the error handling code",
             errorHandlingError);
     }
     throw new MessageException("An unhanded exception has occurred while processing a message",
         exception, message.MesssageId, message.CorrelationId);
 }
 /// <summary>
 /// Handles the specified message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="context">The context.</param>
 /// <param name="exception">The exception.</param>
 /// <exception cref="DotNetWorkQueueException">An error has occurred in the error handling code</exception>
 /// <exception cref="MessageException">An unhanded exception has occurred while processing a message</exception>
 public void Handle(IReceivedMessageInternal message, IMessageContext context, Exception exception)
 {
     try
     {
         _transportErrorHandler.MessageFailedProcessing(message, context,
                                                        exception);
     }
     catch (Exception errorHandlingError)
     {
         _log.ErrorException(
             "An error has occurred while trying to move message {0} to the error queue", exception,
             message.MessageId);
         throw new DotNetWorkQueueException("An error has occurred in the error handling code",
                                            errorHandlingError);
     }
     throw new MessageException("An unhanded exception has occurred while processing a message",
                                exception, message.MessageId, message.CorrelationId);
 }
Exemple #31
0
        /// <inheritdoc />
        public async Task <IReceivedMessageInternal> ReceiveMessageAsync(IMessageContext context)
        {
            IReceivedMessageInternal result = null;

            if (_policyAsync == null)
            {
                _policies.Registry.TryGet(_policies.Definition.ReceiveMessageFromTransportAsync, out _policyAsync);
            }

            if (_policyAsync != null)
            {
                await _policyAsync.ExecuteAsync(async() => result = await _handler.ReceiveMessageAsync(context).ConfigureAwait(false)).ConfigureAwait(false);
            }
            else //no policy found
            {
                result = await _handler.ReceiveMessageAsync(context).ConfigureAwait(false);
            }
            return(result);
        }
Exemple #32
0
        /// <inheritdoc />
        public IReceivedMessageInternal ReceiveMessage(IMessageContext context)
        {
            IReceivedMessageInternal result = null;

            if (_policy == null)
            {
                _policies.Registry.TryGet(_policies.Definition.ReceiveMessageFromTransport, out _policy);
            }

            if (_policy != null)
            {
                _policy.Execute(() => result = _handler.ReceiveMessage(context));
            }
            else //no policy found
            {
                result = _handler.ReceiveMessage(context);
            }
            return(result);
        }
        /// <inheritdoc />
        public void Handle(IReceivedMessageInternal message, IWorkerNotification workerNotification)
        {
            var spanContext = message.Extract(_tracer, _headers);

            if (spanContext != null)
            {
                using (IScope scope = _tracer.BuildSpan("MessageHandler").AddReference(References.FollowsFrom, spanContext).StartActive(finishSpanOnDispose: true))
                {
                    _handler.Handle(message, workerNotification);
                }
            }
            else
            {
                using (IScope scope = _tracer.BuildSpan("MessageHandler").StartActive(finishSpanOnDispose: true))
                {
                    _handler.Handle(message, workerNotification);
                }
            }
        }
        public void TestCreation()
        {
            var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());

            IGenerateReceivedMessage gen = fixture.Create <GenerateReceivedMessage>();
            var inputMessage             = fixture.Create <IMessage>();

            inputMessage.Body.Returns(new FakeMessage());
            fixture.Inject(inputMessage);
            IReceivedMessageInternal rec = fixture.Create <ReceivedMessageInternal>();

            var message = gen.GenerateMessage(typeof(FakeMessage), rec);

            IReceivedMessage <FakeMessage> translatedMessage = message;

            Assert.Equal(translatedMessage.Body, rec.Body);
            Assert.Equal(translatedMessage.CorrelationId, rec.CorrelationId);
            Assert.Equal(translatedMessage.Headers, rec.Headers);
            Assert.Equal(translatedMessage.MessageId, rec.MessageId);
        }
Exemple #35
0
        /// <summary>
        /// Handles the specified message.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="workerNotification">The worker notification.</param>
        /// <returns></returns>
        public async Task HandleAsync(IReceivedMessageInternal message, IWorkerNotification workerNotification)
        {
            var spanContext = message.Extract(_tracer, _headers.StandardHeaders);

            if (spanContext != null)
            {
                using (IScope scope = _tracer.BuildSpan("MessageHandlerAsync").AddReference(References.FollowsFrom, spanContext).StartActive(finishSpanOnDispose: true))
                {
                    scope.Span.AddMessageIdTag(message);
                    await _handler.HandleAsync(message, workerNotification);
                }
            }
            else
            {
                using (IScope scope = _tracer.BuildSpan("MessageHandlerAsync").StartActive(finishSpanOnDispose: true))
                {
                    scope.Span.AddMessageIdTag(message);
                    await _handler.HandleAsync(message, workerNotification);
                }
            }
        }
        public void GenerateMessage()
        {
            var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
            IGenerateReceivedMessage gen = fixture.Create <GenerateReceivedMessage>();
            var inputMessage             = fixture.Create <IMessage>();

            inputMessage.Body.Returns(new FakeMessage());
            fixture.Inject(gen);
            fixture.Inject(inputMessage);
            var test = fixture.Create <MessageHandlerRegistrationAsync>();

            Task Func(IReceivedMessage <FakeMessage> recMessage, IWorkerNotification worker) => null;

            test.Set((Func <IReceivedMessage <FakeMessage>, IWorkerNotification, Task>)Func);

            IReceivedMessageInternal rec = fixture.Create <ReceivedMessageInternal>();

            var message = test.GenerateMessage(rec);

            Assert.IsAssignableFrom <FakeMessage>(message.Body);
        }
Exemple #37
0
        private IReceivedMessageInternal ProcessMessage(IReceivedMessageInternal receivedTransportMessage,
                                                        IConnectionHolder <NpgsqlConnection, NpgsqlTransaction, NpgsqlCommand> connectionHolder,
                                                        IMessageContext context,
                                                        Action <IConnectionHolder <NpgsqlConnection, NpgsqlTransaction, NpgsqlCommand> > noMessageFoundActon)
        {
            //if no message (null) run the no message action and return
            if (receivedTransportMessage == null)
            {
                noMessageFoundActon(connectionHolder);
                return(null);
            }

            //set the message ID on the context for later usage
            context.SetMessageAndHeaders(receivedTransportMessage.MessageId, receivedTransportMessage.Headers);

            //we need to update the status table here, as we don't do it as part of the de-queue
            if (_configuration.Options().EnableStatusTable)
            {
                _setStatusCommandHandler.Handle(
                    new SetStatusTableStatusCommand <long>(
                        (long)receivedTransportMessage.MessageId.Id.Value, QueueStatuses.Processing));
            }
            return(receivedTransportMessage);
        }
 /// <summary>
 /// Handles the specified message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="workerNotification">The worker notification.</param>
 /// <returns></returns>
 public Task Handle(IReceivedMessageInternal message, IWorkerNotification workerNotification)
 {
     Guard.NotNull(() => message, message);
     Guard.NotNull(() => workerNotification, workerNotification);
     return _messageHandlerRegistration.GetHandler().Invoke(_messageHandlerRegistration.GenerateMessage(message), workerNotification);
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="RedisMessage" /> class.
 /// </summary>
 /// <param name="messageId">The message identifier.</param>
 /// <param name="message">The message.</param>
 /// <param name="expired">if set to <c>true</c> [expired].</param>
 public RedisMessage(string messageId, IReceivedMessageInternal message, bool expired)
 {
     MessageId = messageId;
     Message = message;
     Expired = expired;
 }
 public ReceiveMessagesErrorResult MessageFailedProcessing(IReceivedMessageInternal message, IMessageContext context, Exception exception)
 {
     throw new NotImplementedException();
 }