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(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 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 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);
}
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 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)));
}
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)));
}
private static async Task InvokeWithDelay(IncomingLogicalContext context, Func <Task> next, int delay)
{
try
{
await next().ConfigureAwait(false);
}
catch (Exception)
{
delay += 100;
await Task.Delay(delay);
await InvokeWithDelay(context, next, delay);
}
}
private static async Task InvokeWithDelay(IncomingLogicalContext context, Func<Task> next, int delay)
{
try
{
await next().ConfigureAwait(false);
}
catch (Exception)
{
delay += 100;
await Task.Delay(delay);
await InvokeWithDelay(context, next, delay);
}
}
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)
{
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(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 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)
{
collector.Add(context.LogicalMessage);
return next();
}
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 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 Task Invoke(IncomingLogicalContext context, IBusForHandler bus, Func<Task> next)
{
var step = factory();
return step.Invoke(context, bus, next);
}
public Task Invoke(IncomingLogicalContext context, IBusForHandler bus, Func<Task> next)
{
var delay = 100;
return InvokeWithDelay(context, next, delay);
}
public Task Invoke(IncomingLogicalContext context, IBusForHandler bus, Func <Task> next)
{
var delay = 100;
return(InvokeWithDelay(context, next, delay));
}
static bool IsRetryCountReached(IncomingLogicalContext context)
{
const int HardcodedMaxRetryOfServiceBusLibrary = 10;
return(context.TransportMessage.DeliveryCount > HardcodedMaxRetryOfServiceBusLibrary - 1);
}
static bool IsRetryCountReached(IncomingLogicalContext context)
{
const int HardcodedMaxRetryOfServiceBusLibrary = 10;
return context.TransportMessage.DeliveryCount > HardcodedMaxRetryOfServiceBusLibrary - 1;
}
public Task Invoke(IncomingLogicalContext context, IBusForHandler bus, Func <Task> next)
{
var step = factory();
return(step.Invoke(context, bus, next));
}
