示例#1
0
        public RetryMessages()
        {
            Post["/errors/{messageid}/retry"] = parameters =>
            {
                var failedMessageId = parameters.MessageId;

                if (string.IsNullOrEmpty(failedMessageId))
                {
                    return(HttpStatusCode.BadRequest);
                }

                Bus.SendLocal <RetryMessage>(m =>
                {
                    m.FailedMessageId = failedMessageId;
                });

                return(HttpStatusCode.Accepted);
            };

            Post["/errors/retry"] = _ =>
            {
                var ids = this.Bind <List <string> >();

                if (ids.Any(string.IsNullOrEmpty))
                {
                    return(HttpStatusCode.BadRequest);
                }

                foreach (var id in ids)
                {
                    var request = new RetryMessage {
                        FailedMessageId = id
                    };

                    Bus.SendLocal(request);
                }

                return(HttpStatusCode.Accepted);
            };

            Post["/errors/retry/all"] = _ =>
            {
                var request = new RequestRetryAll();

                Bus.SendLocal(request);

                return(HttpStatusCode.Accepted);
            };

            Post["/errors/{name}/retry/all"] = parameters =>
            {
                var request = new RequestRetryAll {
                    Endpoint = parameters.name
                };

                Bus.SendLocal(request);

                return(HttpStatusCode.Accepted);
            };
        }
示例#2
0
        public void PublishOnRetryExchange(Channel channel, T message, RetryInformations retryInformations)
        {
            List <int> delays = _messageBrokerConfiguration.DelaysInMsBetweenEachRetry;
            int        delay  = 0;

            if (delays.Count >= retryInformations.NumberOfRetry)
            {
                delay = delays[retryInformations.NumberOfRetry];
            }
            else
            {
                delay = delays.Last();
            }
            retryInformations.NumberOfRetry++;
            RetryMessage <T> retryMessage = new RetryMessage <T>
            {
                OriginalMessage   = message,
                RetryInformations = retryInformations
            };

            string bindingValue = $"{channel.Value}.{delay}";

            using (var publisher = _messagingService.GetPublisher($"{_messageBrokerConfiguration.BusName}.{RetryStrategyConfiguration.RetryExchangeSuffix}", true))
            {
                TryPublishWithBrokerAcknowledgement(publisher, bindingValue, JsonConvert.SerializeObject(retryMessage));
            }
        }
示例#3
0
        public void Handle(RetryMessage message)
        {
            //do not allow retries if we have other retries in progress
            if (Data.RetryAttempts.Any(a => !a.Completed))
            {
                return;
            }

            var attemptToRetry = Data.ProcessingAttempts.Last();

            var retryId = Guid.NewGuid();

            Data.RetryAttempts.Add(new FailedMessagePolicyData.RetryAttempt
            {
                Id = retryId,
                FailedProcessingAttemptId = attemptToRetry.Id
            });

            Bus.SendLocal(new PerformRetry
            {
                FailedMessageId       = Data.FailedMessageId,
                TargetEndpointAddress = Data.ProcessingAttempts.Last().AddressOfFailingEndpoint,
                RetryId = retryId
            });
        }
示例#4
0
        public void Handle(RetryMessage message)
        {
            var msg = Rows.FirstOrDefault(x => x.Id == message.Id);

            if (msg != null)
            {
                msg.Status = MessageStatus.RetryIssued;
            }
        }
示例#5
0
        public void OnMessageReceived(EventHandler <T> callback, IMessagingEvent messagingEvent)
        {
            RetryMessage <T> retryMessage = JsonConvert.DeserializeObject <RetryMessage <T> >(messagingEvent.Message.GetBody());

            retryMessage.OriginalMessage.DeliveryTag = EncodeDeliveryTag(messagingEvent.DeliveryTag);
            RetryInformations.Add(retryMessage.OriginalMessage.DeliveryTag, retryMessage.RetryInformations);

            callback(this, retryMessage.OriginalMessage);
        }
        public RetryMessages()
        {
            Post["/errors/{messageid}/retry"] = parameters =>
            {
                var failedMessageId = parameters.MessageId;

                if (string.IsNullOrEmpty(failedMessageId))
                {
                    return HttpStatusCode.BadRequest;
                }

                Bus.SendLocal<RetryMessage>(m =>
                {
                    m.FailedMessageId = failedMessageId;
                });

                return HttpStatusCode.Accepted;
            };

            Post["/errors/retry"] = _ =>
            {
                var ids = this.Bind<List<string>>();

                if (ids.Any(string.IsNullOrEmpty))
                {
                    return HttpStatusCode.BadRequest;
                }

                foreach (var id in ids)
                {
                    var request = new RetryMessage { FailedMessageId = id };

                    Bus.SendLocal(request);    
                }

                return HttpStatusCode.Accepted;
            };

            Post["/errors/retry/all"] = _ =>
            {
                var request = new RequestRetryAll();

                Bus.SendLocal(request);

                return HttpStatusCode.Accepted;
            };

            Post["/errors/{name}/retry/all"] = parameters =>
            {
                var request = new RequestRetryAll { Endpoint = parameters.name };

                Bus.SendLocal(request);

                return HttpStatusCode.Accepted;
            };
        }
示例#7
0
        internal void PublishOnErrorExchange(Channel channel, T message, RetryInformations technicalInformations)
        {
            string           errorChanel  = $"{channel.Value}.error";
            RetryMessage <T> retryMessage = new RetryMessage <T>
            {
                OriginalMessage   = message,
                RetryInformations = technicalInformations
            };

            using (var publisher = _messagingService.GetPublisher($"{_messageBrokerConfiguration.BusName}.{RetryStrategyConfiguration.ErrorExchangeSuffix}", true))
            {
                TryPublishWithBrokerAcknowledgement(publisher, errorChanel, JsonConvert.SerializeObject(retryMessage));
            }
        }
示例#8
0
        public void Consumer_AcknowlegdeDeliveredMessage_ShouldRemoveMessageFromRetryInformationsList()
        {
            //Arrange
            RetryMessage <TestMessage> retryMessage = GetFilledRetryMessage(0);
            TestMessage testMessage = retryMessage.OriginalMessage;

            _consumer.RetryInformations.Add(testMessage.DeliveryTag, retryMessage.RetryInformations);

            //Act
            _consumer.AcknowlegdeDeliveredMessage(new Channel(""), testMessage);

            //Assert
            Assert.True(!_consumer.RetryInformations.ContainsKey(testMessage.DeliveryTag));
        }
        public void Handle(RequestRetryAll message)
        {
            var query = Session.Query <FailedMessageViewIndex.SortAndFilterOptions, FailedMessageViewIndex>();

            if (message.Endpoint != null)
            {
                query = query.Where(fm => fm.ReceivingEndpointName == message.Endpoint);
            }

            using (var ie = Session.Advanced.Stream(query.OfType <FailedMessage>()))
            {
                while (ie.MoveNext())
                {
                    var retryMessage = new RetryMessage {
                        FailedMessageId = ie.Current.Document.UniqueMessageId
                    };

                    Bus.SendLocal(retryMessage);
                }
            }
        }
示例#10
0
        public void Consumer_OnMessageReceived_ShouldCallCallbackWithOriginalMessage()
        {
            //Arrange
            RetryMessage <TestMessage> messageInBody = GetFilledRetryMessage(0);

            Mock <IMessagingEvent> mockMessagingEvent = new Mock <IMessagingEvent>();

            mockMessagingEvent.Setup(p => p.Message.GetBody()).Returns(JsonConvert.SerializeObject(messageInBody));

            bool        callbackCalled = false;
            TestMessage deliveredMessageFromCallback = null;

            //Act
            _consumer.OnMessageReceived((object sender, TestMessage deliveredMessage) =>
            {
                callbackCalled = true;
                deliveredMessageFromCallback = deliveredMessage;
            }
                                        , mockMessagingEvent.Object);

            //Assert
            Assert.True(callbackCalled);
            Assert.True(_consumer.RetryInformations.ContainsKey(deliveredMessageFromCallback.DeliveryTag));
        }
示例#11
0
 public Task Handle(RetryMessage message, IMessageHandlerContext context)
 {
     return(Retries.StartRetryForSingleMessage(message.FailedMessageId));
 }
示例#12
0
 public void Handle(RetryMessage message)
 {
     Retries.StageRetryByUniqueMessageIds(message.FailedMessageId, RetryType.SingleMessage, new[] { message.FailedMessageId }, DateTime.UtcNow);
 }
示例#13
0
 public void Handle(RetryMessage message)
 {
     Retries.StartRetryForSingleMessage(message.FailedMessageId);
 }