public async Task StartAsync(EndpointConfiguration.ReadOnly configuration, Func <TransportMessage, Task> onMessage)
{
this.configuration = configuration;
onMessageAsync = onMessage;
receiver = await receiveMessages.StartAsync(this.configuration, OnMessageAsync)
.ConfigureAwait(false);
}
public async Task StartAsync(EndpointConfiguration.ReadOnly configuration, Func<TransportMessage, Task> onMessage)
{
this.configuration = configuration;
onMessageAsync = onMessage;
receiver = await receiveMessages.StartAsync(this.configuration, OnMessageAsync)
.ConfigureAwait(false);
}
public void Setup()
{
this.pipelineStepRaisingException = async() =>
{
await Task.Run(() => { throw new InvalidOperationException(); });
};
this.testTransportMessage = new TestTransportMessage(typeof(Message).AssemblyQualifiedName);
var readOnlyConfiguration = new EndpointConfiguration.ReadOnly(new EndpointConfiguration().MaximumImmediateRetryCount(MaxImmediateRetryCount).MaximumDelayedRetryCount(MaxDelayedRetryCount));
var logicalMessage = new LogicalMessage(typeof(Message), new Message(), null);
this.incomingLogicalContext = new IncomingLogicalContext(logicalMessage, this.testTransportMessage, readOnlyConfiguration);
this.busMock = new Mock <IBusForHandler>();
this.testee = new DelayMessagesWhenImmediateRetryCountIsReachedStep();
}
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 <AsyncClosable> StartAsync(
EndpointConfiguration.ReadOnly configuration,
Func <TransportMessage, Task> onMessage)
{
MessageReceiver client =
await this.factory
.CreateMessageReceiverAsync(configuration.DestinationQueue(), ReceiveMode.PeekLock)
.ConfigureAwait(false);
OnMessageOptions options = configuration.Options();
options.ExceptionReceived += (sender, args) => HandleExceptionReceived(configuration.DestinationQueue(), args);
configuration.Configure(client).OnMessageAsync(brokeredMessage => onMessage(new TransportMessage(brokeredMessage)), options);
return(new AsyncClosable(client.CloseAsync));
}
public async Task Invoke(IBusForHandler bus, TransportMessage message, EndpointConfiguration.ReadOnly configuration)
{
this.executingTransportPipeline = new Queue <IIncomingTransportStep>(this.registeredTransportPipeline);
var transportContext = new IncomingTransportContext(message, configuration);
transportContext.SetChain(this);
await this.InvokeTransport(transportContext, bus)
.ConfigureAwait(false);
// We assume that someone in the pipeline made logical message
var logicalMessage = transportContext.Get <LogicalMessage>();
this.executingLogicalPipeline = new Queue <IIncomingLogicalStep>(this.registeredLogicalPipeline);
var logicalContext = new IncomingLogicalContext(logicalMessage, message, configuration);
logicalContext.SetChain(this);
this.currentContext = logicalContext;
await this.InvokeLogical(logicalContext, bus)
.ConfigureAwait(false);
}
public void Setup()
{
try
{
throw new InvalidOperationException("Internal test exception");
}
catch (Exception exc)
{
this.internalException = exc;
}
this.pipelineStepRaisingException = async() =>
{
await Task.Run(() =>
{
throw new InvalidOperationException();
});
};
this.pipelineStepRaisingDeadletterMessageImmediatelyException = async() =>
{
await Task.Run(() =>
{
throw new DeadletterMessageImmediatelyException(this.internalException);
});
};
this.testTransportMessage = new TestTransportMessage(typeof(Message).AssemblyQualifiedName);
var readOnlyConfiguration = new EndpointConfiguration.ReadOnly(new EndpointConfiguration().MaximumImmediateRetryCount(10).MaximumDelayedRetryCount(10));
var logicalMessage = new LogicalMessage(typeof(Message), new Message(), null);
this.incomingLogicalContext = new IncomingLogicalContext(logicalMessage, this.testTransportMessage, readOnlyConfiguration);
this.busMock = new Mock <IBusForHandler>();
this.testee = new DeadletterMessageImmediatelyExceptionStep();
}
public IncomingLogicalContext(LogicalMessage logicalMessage, TransportMessage message, EndpointConfiguration.ReadOnly configuration)
: base(configuration)
{
this.Set(logicalMessage);
this.Set(message);
this.Set <MessageHandler>(null, ShouldBeSnapshotted.Yes);
this.Set(HandlerInvocationAbortPendingKey, false);
}
protected Context(EndpointConfiguration.ReadOnly configuration)
{
this.Set(configuration);
}
public Task <AsyncClosable> StartAsync(EndpointConfiguration.ReadOnly configuration, Func <TransportMessage, Task> onMessage)
{
this.onMessage = onMessage;
return(Task.FromResult(new AsyncClosable(() => Task.FromResult(0))));
}
public IncomingTransportContext(TransportMessage message, EndpointConfiguration.ReadOnly configuration)
: base(configuration)
{
this.Set(message);
}
public virtual async Task Invoke(LogicalMessage outgoingLogicalMessage, DeliveryOptions options, EndpointConfiguration.ReadOnly configuration, TransportMessage incomingTransportMessage = null)
{
this.executingLogicalPipeline = new Queue <IOutgoingLogicalStep>(this.registeredlogicalPipelineSteps);
var logicalContext = new OutgoingLogicalContext(outgoingLogicalMessage, options, configuration);
logicalContext.SetChain(this);
await this.InvokeLogical(logicalContext)
.ConfigureAwait(false);
// We assume that someone in the pipeline made transport message
var outgoingTransportMessage = logicalContext.Get <TransportMessage>();
this.executingTransportPipeline = new Queue <IOutgoingTransportStep>(this.registeredTransportPipelineSteps);
var transportContext = new OutgoingTransportContext(outgoingLogicalMessage, outgoingTransportMessage, options, configuration, incomingTransportMessage);
transportContext.SetChain(this);
await this.InvokeTransport(transportContext)
.ConfigureAwait(false);
}
public OutgoingTransportContext(LogicalMessage message, TransportMessage outgoingTransportMessage, DeliveryOptions options, EndpointConfiguration.ReadOnly configuration, TransportMessage incomingTransportMessage = null)
: base(configuration)
{
Set(message);
Set(OutgoingTransportMessageKey, outgoingTransportMessage);
Set(IncomingTransportMessageKey, incomingTransportMessage);
Set(options);
}
public OutgoingLogicalContext(LogicalMessage message, DeliveryOptions options, EndpointConfiguration.ReadOnly configuration)
: base(configuration)
{
this.Set(message);
this.Set(options);
}
public static OnMessageOptions Options(this EndpointConfiguration.ReadOnly configuration)
{
return(new OnMessageOptions {
AutoComplete = true, MaxConcurrentCalls = configuration.MaxConcurrency
});
}
public static string DestinationQueue(this EndpointConfiguration.ReadOnly configuration)
{
return(configuration.EndpointQueue.Destination);
}
public static MessageReceiver Configure(this EndpointConfiguration.ReadOnly configuration, MessageReceiver receiver)
{
receiver.PrefetchCount = configuration.PrefetchCount;
return(receiver);
}
public Task StartAsync(EndpointConfiguration.ReadOnly configuration, Func <TransportMessage, Task> onMessage)
{
return(Task.FromResult(0));
}
public Task StartAsync(EndpointConfiguration.ReadOnly configuration, Func <TransportMessage, Task> onMessage)
{
return(Task.CompletedTask);
}