public async Task Invoke(IncomingTransportContext context, IBusForHandler bus, Func<Task> next) { ExceptionDispatchInfo serializationException = null; try { await next() .ConfigureAwait(false); } catch (SerializationException exception) { // We can't do async in a catch block, therefore we have to capture the exception! serializationException = ExceptionDispatchInfo.Capture(exception); } if (SerializationExceptionHasBeenCaught(serializationException)) { var message = context.TransportMessage; // ReSharper disable PossibleNullReferenceException message.SetFailureHeaders(serializationException.SourceException, "Messages which can't be deserialized are deadlettered immediately"); // ReSharper restore PossibleNullReferenceException await message.DeadLetterAsync() .ConfigureAwait(false); // Because we instructed the message to deadletter it is safe to rethrow. The broker will not redeliver. serializationException.Throw(); } }
public async Task Invoke(IncomingLogicalContext context, IBusForHandler bus, Func <Task> next) { ExceptionDispatchInfo exceptionDispatchInfo = null; try { await next() .ConfigureAwait(false); } catch (Exception exception) { if (ShouldMessageBeDelayed(context)) { // We can't do async in a catch block, therefore we have to capture the exception! exceptionDispatchInfo = ExceptionDispatchInfo.Capture(exception); } else { throw; } } if (exceptionDispatchInfo != null) { var message = context.TransportMessage; var scheduledEnqueueTimeUtc = DateTime.UtcNow + TimeSpan.FromSeconds(DelayTimeSpanInSeconds(context)); message.DelayedDeliveryCount++; await bus.Postpone(context.LogicalMessage.Instance, scheduledEnqueueTimeUtc); // Don't rethrow, the current message is consumed and a new message is postponed. } }
public async Task Invoke(IncomingLogicalContext context, IBusForHandler bus, Func <Task> next) { var messageType = context.LogicalMessage.Instance.GetType(); var handlers = registry.GetHandlers(messageType); foreach (var handler in handlers) { var messageHandler = new MessageHandler { Instance = handler, Invocation = (handlerInstance, message) => registry.InvokeHandle(handlerInstance, message, bus) }; context.Handler = messageHandler; await next() .ConfigureAwait(false); if (context.HandlerInvocationAbortPending) { break; } } }
public async Task Invoke(IncomingTransportContext context, IBusForHandler bus, Func <Task> next) { ExceptionDispatchInfo serializationException = null; try { await next() .ConfigureAwait(false); } catch (SerializationException exception) { // We can't do async in a catch block, therefore we have to capture the exception! serializationException = ExceptionDispatchInfo.Capture(exception); } if (SerializationExceptionHasBeenCaught(serializationException)) { var message = context.TransportMessage; // ReSharper disable PossibleNullReferenceException message.SetFailureHeaders(serializationException.SourceException, "Messages which can't be deserialized are deadlettered immediately"); // ReSharper restore PossibleNullReferenceException await message.DeadLetterAsync() .ConfigureAwait(false); // Because we instructed the message to deadletter it is safe to rethrow. The broker will not redeliver. serializationException.Throw(); } }
public async Task Invoke(IncomingLogicalContext context, IBusForHandler bus, Func <Task> next) { ExceptionDispatchInfo exceptionDispatchInfo = null; try { await next() .ConfigureAwait(false); } catch (DeadletterMessageImmediatelyException exception) { // We can't do async in a catch block, therefore we have to capture the exception! exceptionDispatchInfo = ExceptionDispatchInfo.Capture(exception); } if (HandleMessageCriticalExceptionHasBeenCaught(exceptionDispatchInfo)) { var message = context.TransportMessage; // ReSharper disable PossibleNullReferenceException var exceptionToHeader = exceptionDispatchInfo.SourceException.InnerException ?? exceptionDispatchInfo.SourceException; message.SetFailureHeaders(exceptionToHeader, "Message is deadlettered immediately on DeadletterMessageImmediatelyException"); // ReSharper restore PossibleNullReferenceException await message.DeadLetterAsync() .ConfigureAwait(false); // Because we instructed the message to deadletter it is safe to rethrow. The broker will not redeliver. // Already deadlettered message should not be unlocked - throw for it exceptionDispatchInfo.Throw(); } }
public async Task Invoke(IncomingLogicalContext context, IBusForHandler bus, Func<Task> next) { var messageType = context.LogicalMessage.Instance.GetType(); var handlers = registry.GetHandlers(messageType); foreach (var handler in handlers) { using (context.CreateSnapshot()) { var messageHandler = new MessageHandler { Instance = handler, Invocation = (handlerInstance, message) => registry.InvokeHandle(handlerInstance, message, bus) }; context.Handler = messageHandler; await next() .ConfigureAwait(false); if (context.HandlerInvocationAbortPending) { break; } } } }
public virtual Task InvokeHandle(object handler, object message, IBusForHandler bus) { dynamic h = handler; dynamic m = message; return(h.Handle(m, bus)); }
public async Task Invoke(IncomingLogicalContext context, IBusForHandler bus, Func <Task> next) { ExceptionDispatchInfo serializationException = null; try { await next() .ConfigureAwait(false); } catch (Exception exception) { if (IsRetryCountReached(context)) { // We can't do async in a catch block, therefore we have to capture the exception! serializationException = ExceptionDispatchInfo.Capture(exception); } else { throw; } } if (serializationException != null) { var message = context.TransportMessage; message.SetFailureHeaders(serializationException.SourceException, "Max number of retries has been reached!"); await message.DeadLetterAsync() .ConfigureAwait(false); // Because we instructed the message to deadletter it is safe to rethrow. The broker will not redeliver. serializationException.Throw(); } }
public async Task Invoke(IncomingLogicalContext context, IBusForHandler bus, Func<Task> next) { ExceptionDispatchInfo serializationException = null; try { await next() .ConfigureAwait(false); } catch (Exception exception) { if (IsRetryCountReached(context)) { // We can't do async in a catch block, therefore we have to capture the exception! serializationException = ExceptionDispatchInfo.Capture(exception); } else { throw; } } if (serializationException != null) { var message = context.TransportMessage; message.SetFailureHeaders(serializationException.SourceException, "Max number of retries has been reached!"); await message.DeadLetterAsync() .ConfigureAwait(false); // Because we instructed the message to deadletter it is safe to rethrow. The broker will not redeliver. serializationException.Throw(); } }
public void Handle(Message message, IBusForHandler bus) { this.context.HandlerCalled(); bus.Reply(new ReplyMessage { Answer = "MessageHandler" }).Wait(); }
public Task Handle(object message, IBusForHandler bus) { IDictionary <string, string> headers = bus.Headers(message); var exceptionMessage = string.Format(CultureInfo.InvariantCulture, "The message with id {0} of type {1} has been rejected.", headers[HeaderKeys.MessageId], message.GetType()); throw new InvalidOperationException(exceptionMessage); }
public Task Handle(Message message, IBusForHandler bus) { context.SecondHandlerCalls += 1; return(bus.Reply(new ReplyMessage { Answer = "SecondHandler" })); }
public void Handle(Message message, IBusForHandler bus) { this.context.HandlerCalled(); if (message.AbortSync) { bus.DoNotContinueDispatchingCurrentMessageToHandlers(); } }
public void Handle(Message message, IBusForHandler bus) { Debug.WriteLine("Sync {0}", message.Bar); if (message.Bar % 2 == 0) { throw new InvalidOperationException(); } this.context.HandlerCalled(); }
public async Task Handle(Message message, IBusForHandler bus) { this.context.AsyncHandlerCalls += 1; await bus.Reply(new ReplyMessage { Answer = "AsyncMessageHandler" }); var options = new ReplyOptions(); options.Headers.Add("Key", "Value"); await bus.Reply(new ReplyMessage { Answer = "AsyncMessageHandlerWithHeaders" }, options); }
public Task Handle(ReplyMessage message, IBusForHandler bus) { this.context.ReplyHandlerCalls += 1; if (bus.Headers(message).ContainsKey("Key")) { this.context.HeaderValue = bus.Headers(message)["Key"]; } return(Task.FromResult(0)); }
public void Handle(Message message, IBusForHandler bus) { Debug.WriteLine("{0}s: Sync {1}, delayed {2}", DateTime.Now.Subtract(startTime).Seconds, message.Bar, bus.Headers(message)[HeaderKeys.DelayedDeliveryCount]); if (message.Bar % 2 == 0) { throw new InvalidOperationException(); } this.context.HandlerCalled(); }
public async Task Invoke(IncomingLogicalContext context, IBusForHandler bus, Func <Task> next) { var messageHandler = context.Handler; await messageHandler.Invocation(messageHandler.Instance, context.LogicalMessage.Instance) .ConfigureAwait(false); await next() .ConfigureAwait(false); }
public Task Handle(ReplyMessage message, IBusForHandler bus) { context.ReplyHandlerCalls += 1; if (bus.Headers(message).ContainsKey("Key")) { context.HeaderValue = bus.Headers(message)["Key"]; } return(Task.CompletedTask); }
public async Task Invoke(IncomingLogicalContext context, IBusForHandler bus, Func<Task> next) { var messageHandler = context.Handler; await messageHandler.Invocation(messageHandler.Instance, context.LogicalMessage.Instance) .ConfigureAwait(false); await next() .ConfigureAwait(false); }
private Task InvokeTransport(IncomingTransportContext context, IBusForHandler bus) { if (this.executingTransportPipeline.Count == 0) { return(Task.FromResult(0)); } IIncomingTransportStep step = this.executingTransportPipeline.Dequeue(); return(step.Invoke(context, bus, () => this.InvokeTransport(context, bus))); }
public Task Handle(Message message, IBusForHandler bus) { context.FirstHandlerCalls += 1; if (message.AbortFirstHandler) { bus.DoNotContinueDispatchingCurrentMessageToHandlers(); } return(Task.CompletedTask); }
public Task Handle(AsyncMessage message, IBusForHandler bus) { Debug.WriteLine("ASync {0}, delayed {1}", message.Bar, bus.Headers(message)[HeaderKeys.DelayedDeliveryCount]); if (message.Bar % 2 == 0) { throw new InvalidOperationException(); } this.context.HandlerCalled(); return(Task.FromResult(0)); }
Task InvokeLogical(IncomingLogicalContext context, IBusForHandler bus) { if (executingLogicalPipeline.Count == 0) { return(Task.FromResult(0)); } IIncomingLogicalStep step = executingLogicalPipeline.Dequeue(); return(step.Invoke(context, bus, () => InvokeLogical(context, bus))); }
public Task Handle(AsyncMessage message, IBusForHandler bus) { Debug.WriteLine("Async {0}", message.Bar); if (message.Bar % 2 == 0) { throw new InvalidOperationException(); } this.context.HandlerCalled(); return(Task.FromResult(0)); }
Task InvokeLogical(IncomingLogicalContext context, IBusForHandler bus, int currentIndex = 0) { if (currentIndex == registeredLogicalPipeline.Count) { return(Task.CompletedTask); } IIncomingLogicalStep step = registeredLogicalPipeline[currentIndex]; return(step.Invoke(context, bus, () => InvokeLogical(context, bus, currentIndex + 1))); }
public Task Handle(Message message, IBusForHandler bus) { this.context.AsyncHandlerCalled(); if (message.AbortAsync) { bus.DoNotContinueDispatchingCurrentMessageToHandlers(); } return(Task.FromResult(0)); }
public async Task Handle(Message message, IBusForHandler bus) { this.context.AsyncHandlerCalled(); await bus.Reply(new ReplyMessage { Bar = message.Bar }); if (message.Throw) { throw new InvalidOperationException(); } }
Task InvokeLogical(IncomingLogicalContext context, IBusForHandler bus, int currentIndex = 0) { if (currentIndex == registeredLogicalPipeline.Count) { return Task.CompletedTask; } IIncomingLogicalStep step = registeredLogicalPipeline[currentIndex]; return step.Invoke(context, bus, () => InvokeLogical(context, bus, currentIndex + 1)); }
Task InvokeTransport(IncomingTransportContext context, IBusForHandler bus, int currentIndex = 0) { if (currentIndex == registeredTransportPipeline.Count) { return(Task.CompletedTask); } IIncomingTransportStep step = registeredTransportPipeline[currentIndex]; return(step.Invoke(context, bus, () => InvokeTransport(context, bus, currentIndex + 1))); }
public Task Handle(Message message, IBusForHandler bus) { context.SecondHandlerCalls += 1; if (message.AbortSecondHandler) { bus.DoNotContinueDispatchingCurrentMessageToHandlers(); } return(Task.FromResult(0)); }
public async Task Handle(Message message, IBusForHandler bus) { var time = TimeSpan.FromSeconds(6); IRenewLock renewLock = bus as IRenewLock; context.Start(); await Task.Delay(time); renewLock?.RenewLock(); await Task.Delay(time); this.context.Done(); }
public Task Handle(Message message, IBusForHandler bus) { int delayedDeliveryCount; string delayedDeliveryCountString; bus.Headers(message).TryGetValue(HeaderKeys.DelayedDeliveryCount, out delayedDeliveryCountString); int.TryParse(delayedDeliveryCountString, out delayedDeliveryCount); if (delayedDeliveryCount == actualDelayedRetryCount) { throw new InvalidOperationException(); } return(Task.FromResult(0)); }
public async Task Invoke(IBusForHandler bus, TransportMessage message, EndpointConfiguration.ReadOnly configuration) { var transportContext = new IncomingTransportContext(message, configuration); await InvokeTransport(transportContext, bus) .ConfigureAwait(false); // We assume that someone in the pipeline made logical message var logicalMessage = transportContext.Get<LogicalMessage>(); var logicalContext = new IncomingLogicalContext(logicalMessage, message, configuration); currentContext = logicalContext; await InvokeLogical(logicalContext, bus) .ConfigureAwait(false); }
public Task Invoke(IncomingTransportContext context, IBusForHandler bus, Func <Task> next) { var transportMessage = context.TransportMessage; try { context.Set(Extract(transportMessage)); } catch (Exception exception) { throw new SerializationException(string.Format("An error occurred while attempting to extract logical messages from transport message {0}", transportMessage), exception); } return(next()); }
public Task Invoke(IncomingTransportContext context, IBusForHandler bus, Func<Task> next) { var transportMessage = context.TransportMessage; try { context.Set(this.Extract(transportMessage)); } catch (Exception exception) { throw new SerializationException(string.Format("An error occurred while attempting to extract logical messages from transport message {0}", transportMessage), exception); } return next(); }
public async Task Invoke(IBusForHandler bus, TransportMessage message, EndpointConfiguration.ReadOnly configuration) { var transportContext = new IncomingTransportContext(message, configuration); await InvokeTransport(transportContext, bus) .ConfigureAwait(false); // We assume that someone in the pipeline made logical message var logicalMessage = transportContext.Get <LogicalMessage>(); var logicalContext = new IncomingLogicalContext(logicalMessage, message, configuration); currentContext = logicalContext; await InvokeLogical(logicalContext, bus) .ConfigureAwait(false); }
public async Task Invoke(IBusForHandler bus, TransportMessage message, EndpointConfiguration.ReadOnly configuration) { executingTransportPipeline = new Queue<IIncomingTransportStep>(registeredTransportPipeline); var transportContext = new IncomingTransportContext(message, configuration); transportContext.SetChain(this); await InvokeTransport(transportContext, bus) .ConfigureAwait(false); // We assume that someone in the pipeline made logical message var logicalMessage = transportContext.Get<LogicalMessage>(); executingLogicalPipeline = new Queue<IIncomingLogicalStep>(registeredLogicalPipeline); var logicalContext = new IncomingLogicalContext(logicalMessage, message, configuration); logicalContext.SetChain(this); currentContext = logicalContext; await InvokeLogical(logicalContext, bus) .ConfigureAwait(false); }
public async Task Invoke(IncomingTransportContext context, IBusForHandler bus, Func<Task> next) { try { await next() .ConfigureAwait(false); } catch (SerializationException exception) { var message = context.TransportMessage; message.SetFailureHeaders(exception, "Messages which can't be deserialized are deadlettered immediately"); await deadLetter.DeadLetterAsync(message) .ConfigureAwait(false); // Because we instructed the message to deadletter it is safe to rethrow. The broker will not redeliver. throw; } }
public async Task Invoke(IncomingLogicalContext context, IBusForHandler bus, Func<Task> next) { try { await next() .ConfigureAwait(false); } catch (Exception exception) { var message = context.TransportMessage; if (IsRetryCountReached(context)) { message.SetFailureHeaders(exception, "Max number of retries has been reached!"); // C# 6 can do this! await deadLetter.DeadLetterAsync(message).ConfigureAwait(false); } else { message.DeliveryCount++; throw; } } }
public Task Invoke(IncomingLogicalContext context, IBusForHandler bus, Func<Task> next) { var step = this.factory(); return step.Invoke(context, bus, next); }
Task InvokeTransport(IncomingTransportContext context, IBusForHandler bus, int currentIndex = 0) { if (currentIndex == registeredTransportPipeline.Count) { return Task.CompletedTask; } IIncomingTransportStep step = registeredTransportPipeline[currentIndex]; return step.Invoke(context, bus, () => InvokeTransport(context, bus, currentIndex + 1)); }
Task InvokeLogical(IncomingLogicalContext context, IBusForHandler bus) { if (executingLogicalPipeline.Count == 0) { return Task.FromResult(0); } IIncomingLogicalStep step = executingLogicalPipeline.Dequeue(); return step.Invoke(context, bus, () => InvokeLogical(context, bus)); }
public Task Invoke(IncomingTransportContext context, IBusForHandler bus, Func<Task> next) { var step = factory(); return step.Invoke(context, bus, next); }
Task InvokeTransport(IncomingTransportContext context, IBusForHandler bus) { if (executingTransportPipeline.Count == 0) { return Task.FromResult(0); } IIncomingTransportStep step = executingTransportPipeline.Dequeue(); return step.Invoke(context, bus, () => InvokeTransport(context, bus)); }
public Task Invoke(IncomingLogicalContext context, IBusForHandler bus, Func<Task> next) { this.collector.Add(context.LogicalMessage); return next(); }
public Task Invoke(IncomingLogicalContext context, IBusForHandler bus, Func<Task> next) { var delay = 100; return InvokeWithDelay(context, next, delay); }
public virtual Task InvokeHandle(object handler, object message, IBusForHandler bus) { dynamic h = handler; dynamic m = message; return h.Handle(m, bus); }