protected void ApplySpecifications(IReceiveEndpointBuilder builder)
{
for (var i = 0; i < _specifications.Count; i++)
{
_specifications[i].Configure(builder);
}
}
protected IReceivePipe CreateReceivePipe(IBusBuilder builder, Func <IConsumePipe, IReceiveEndpointBuilder> endpointBuilderFactory)
{
IConsumePipe consumePipe = _consumePipe ?? builder.CreateConsumePipe(_consumePipeConfigurator);
IReceiveEndpointBuilder endpointBuilder = endpointBuilderFactory(consumePipe);
foreach (IReceiveEndpointSpecification specification in _specifications)
{
specification.Configure(endpointBuilder);
}
ConfigureAddDeadLetterFilter(builder.SendTransportProvider);
var publishEndpointProvider = builder.CreatePublishEndpointProvider(_publishPipeConfigurator);
ConfigureRescueFilter(publishEndpointProvider, builder.SendTransportProvider);
ISendEndpointProvider sendEndpointProvider = builder.CreateSendEndpointProvider(_sendPipeConfigurator);
IMessageDeserializer messageDeserializer = builder.GetMessageDeserializer(sendEndpointProvider, publishEndpointProvider);
_receiveConfigurator.UseFilter(new DeserializeFilter(messageDeserializer, consumePipe));
var receivePipe = _receiveConfigurator.Build();
return(new ReceivePipe(receivePipe, consumePipe));
}
public void Configure(IReceiveEndpointBuilder builder)
{
IPipe <RequestContext> executeActivityPipe = _pipeSpecifications.Build(new ExecuteActivityFilter <TActivity, TArguments>());
_routingSlipConfigurator.UseFilter(_filterFactory(executeActivityPipe));
builder.ConnectConsumePipe(_routingSlipConfigurator.Build());
}
public void Configure(IReceiveEndpointBuilder builder)
{
_pipeConfigurator.AddPipeSpecification(_handlerConfigurator);
IPipe <ConsumeContext <TMessage> > pipe = _pipeConfigurator.Build();
builder.ConnectConsumePipe(pipe);
}
public void Configure(IReceiveEndpointBuilder builder)
{
IPipe <RequestContext> compensateActivityPipe = _pipeSpecifications.Build(new CompensateActivityFilter <TActivity, TLog>());
IPipe <ConsumeContext <RoutingSlip> > messagePipe = Pipe.New <ConsumeContext <RoutingSlip> >(x =>
{
x.UseFilter(_filterFactory(compensateActivityPipe));
});
builder.ConnectConsumePipe(messagePipe);
}
void AddDeadLetterFilter(IReceiveEndpointBuilder builder)
{
IPipe <ReceiveContext> moveToDeadLetterPipe = Pipe.New <ReceiveContext>(x =>
{
Func <Task <ISendTransport> > getDeadLetterTransport = () => builder.SendTransportProvider.GetSendTransport(_deadLetterAddress.Value);
x.UseFilter(new MoveToTransportFilter(_deadLetterAddress.Value, getDeadLetterTransport, "dead-letter"));
});
_receiveConfigurator.UseDeadLetterQueue(moveToDeadLetterPipe);
}
public void Configure(IReceiveEndpointBuilder builder)
{
var connectPipeMethod =
GetType().GetMethod(nameof(ConnectPipe), BindingFlags.NonPublic | BindingFlags.Instance);
Debug.Assert(connectPipeMethod != null, nameof(connectPipeMethod) + " != null");
foreach (var type in _workflow.ConsumedMessages)
{
connectPipeMethod.MakeGenericMethod(type).Invoke(this, new object[] { builder });
}
}
public void Configure(IReceiveEndpointBuilder builder)
{
var filter = new MethodConsumerMessageFilter <TConsumer, Batch <TMessage> >();
var consumerPipe = _messageSpecification.Build(filter);
var batchConsumerFactory = new BatchConsumerFactory <TConsumer, TMessage>(_consumerFactory, _messageLimit, _timeLimit, consumerPipe);
var specification = ConsumerConnectorCache <IConsumer <TMessage> > .Connector.CreateConsumerSpecification <IConsumer <TMessage> >();
ConsumerConnectorCache <IConsumer <TMessage> > .Connector.ConnectConsumer(builder, batchConsumerFactory, specification);
}
void AddRescueFilter(IReceiveEndpointBuilder builder)
{
IPipe <ExceptionReceiveContext> moveToErrorPipe = Pipe.New <ExceptionReceiveContext>(x =>
{
Func <Task <ISendTransport> > getErrorTransport = () => builder.SendTransportProvider.GetSendTransport(_errorAddress.Value);
var publishEndpointProvider = builder.CreatePublishEndpointProvider(InputAddress, _publishPipeConfigurator);
x.UseFilter(new MoveExceptionToTransportFilter(publishEndpointProvider, _errorAddress.Value, getErrorTransport));
});
_receiveConfigurator.UseRescue(moveToErrorPipe);
}
public void Configure(IReceiveEndpointBuilder builder)
{
_observers.All(observer =>
{
observer.HandlerConfigured(this);
return(true);
});
_pipeConfigurator.AddPipeSpecification(_handlerConfigurator);
IPipe <ConsumeContext <TMessage> > pipe = _pipeConfigurator.Build();
builder.ConnectConsumePipe(pipe);
}
/// <summary>
/// Adds a configuration callback to the builder that is used to configure the receiving endpoint.
/// </summary>
/// <param name="builder"><see cref="IReceiveEndpointBuilder{THost,TEndpoint}"/></param>
/// <param name="endpointConfigurator">The configuration callback to configure the receiving endpoint.</param>
public static void AddConfigurator <THost, TEndpoint>(this IReceiveEndpointBuilder <THost, TEndpoint> builder, Action <TEndpoint, IServiceProvider> endpointConfigurator)
where THost : class, IHost
where TEndpoint : class, IReceiveEndpointConfigurator
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (endpointConfigurator == null)
{
throw new ArgumentNullException(nameof(endpointConfigurator));
}
builder.AddConfigurator((host, endpoint, serviceProvider) => endpointConfigurator(endpoint, serviceProvider));
}
protected IReceivePipe CreateReceivePipe(IReceiveEndpointBuilder builder)
{
foreach (var specification in _specifications)
{
specification.Configure(builder);
}
_receiveConfigurator.UseDeadLetterQueue(Pipe.New <ReceiveContext>(x => x.UseFilter(new MoveToTransportFilter(DeadLetterAddress, "dead-letter"))));
_receiveConfigurator.UseRescue(Pipe.New <ExceptionReceiveContext>(x => x.UseFilter(new MoveExceptionToTransportFilter(ErrorAddress))));
_receiveConfigurator.UseFilter(new DeserializeFilter(builder.MessageDeserializer, builder.ConsumePipe));
IPipe <ReceiveContext> receivePipe = _receiveConfigurator.Build();
return(new ReceivePipe(receivePipe, builder.ConsumePipe));
}
/// <summary>
/// Adds a configuration callback to the builder that is used to connect a consumer to the receiving endpoint.
/// </summary>
/// <typeparam name="TConsumer">The type of the consumer.</typeparam>
/// <param name="builder"><see cref="IReceiveEndpointBuilder"/></param>
/// <param name="consumerConfigurator">The configuration callback to configure the consumer.</param>
public static void AddConsumer <TConsumer>(this IReceiveEndpointBuilder builder, Action <IConsumerConfigurator <TConsumer>, IServiceProvider> consumerConfigurator)
where TConsumer : class, IConsumer
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.Services.TryAddTransient <TConsumer>();
builder.AddConfigurator((host, endpoint, serviceProvider) =>
{
var consumerFactory = serviceProvider.GetRequiredService <IConsumerFactory <TConsumer> >();
endpoint.Consumer(consumerFactory, consumerConfigure => consumerConfigurator?.Invoke(consumerConfigure, serviceProvider));
});
}
public void Configure(IReceiveEndpointBuilder builder)
{
_activityPipeConfigurator.UseFilter(new CompensateActivityFilter <TActivity, TLog>(_observers));
IPipe <CompensateActivityContext <TActivity, TLog> > compensateActivityPipe = _activityPipeConfigurator.Build();
_compensatePipeConfigurator.UseFilter(new CompensateActivityFactoryFilter <TActivity, TLog>(_activityFactory, compensateActivityPipe));
IPipe <CompensateContext <TLog> > compensatePipe = _compensatePipeConfigurator.Build();
var host = new CompensateActivityHost <TActivity, TLog>(compensatePipe);
_routingSlipConfigurator.UseFilter(host);
builder.ConnectConsumePipe(_routingSlipConfigurator.Build());
}
public void Configure(IReceiveEndpointBuilder builder)
{
_activityPipeConfigurator.UseFilter(new ExecuteActivityFilter <TActivity, TArguments>(_observers));
IPipe <ExecuteActivityContext <TActivity, TArguments> > executeActivityPipe = _activityPipeConfigurator.Build();
_executePipeConfigurator.UseFilter(new ExecuteActivityFactoryFilter <TActivity, TArguments>(_activityFactory, executeActivityPipe));
IPipe <ExecuteContext <TArguments> > executePipe = _executePipeConfigurator.Build();
var host = new ExecuteActivityHost <TActivity, TArguments>(executePipe, _compensateAddress);
_routingSlipConfigurator.UseFilter(host);
builder.ConnectConsumePipe(_routingSlipConfigurator.Build());
}
protected IReceivePipe CreateReceivePipe(IReceiveEndpointBuilder builder)
{
foreach (var specification in _specifications)
{
specification.Configure(builder);
}
AddDeadLetterFilter(builder);
AddRescueFilter(builder);
_receiveConfigurator.UseFilter(new DeserializeFilter(builder.MessageDeserializer, builder.ConsumePipe));
IPipe <ReceiveContext> receivePipe = _receiveConfigurator.Build();
return(new ReceivePipe(receivePipe, builder.ConsumePipe));
}
protected IPipe <ReceiveContext> CreateReceivePipe(IBusBuilder builder, Func <IConsumePipe, IReceiveEndpointBuilder> endpointBuilderFactory)
{
IConsumePipe consumePipe = _consumePipe ?? builder.CreateConsumePipe(_consumePipeSpecification);
IReceiveEndpointBuilder endpointBuilder = endpointBuilderFactory(consumePipe);
foreach (IReceiveEndpointSpecification specification in _specifications)
{
specification.Configure(endpointBuilder);
}
ConfigureAddDeadLetterFilter(builder.SendTransportProvider);
ConfigureRescueFilter(builder.SendTransportProvider);
_receiveConfigurator.UseFilter(new DeserializeFilter(builder.MessageDeserializer, consumePipe));
return(_receiveConfigurator.Build());
}
public void Configure(IReceiveEndpointBuilder builder)
{
var builders = new ConsumerPipeBuilder <RoutingSlip>();
for (int i = 0; i < _pipeSpecifications.Count; i++)
{
_pipeSpecifications[i].Apply(builders);
}
IPipe <ConsumeContext <RoutingSlip> > messagePipe = Pipe.New <ConsumeContext <RoutingSlip> >(x =>
{
foreach (var filter in builders.Filters)
{
x.UseFilter(filter);
}
x.UseFilter(_filterFactory());
});
builder.ConnectConsumePipe(messagePipe);
}
protected void ApplyReceiveEndpoint(IReceiveEndpointBuilder builder, IReceivePipe receivePipe, params IFilter <NamespaceContext>[] filters)
{
_sendEndpointProvider = CreateSendEndpointProvider(builder);
_publishEndpointProvider = CreatePublishEndpointProvider(builder);
IPipeSpecification <NamespaceContext>[] specifications = filters
.Concat(Enumerable.Repeat(_settings.RequiresSession
? (IFilter <NamespaceContext>) new MessageSessionReceiverFilter(receivePipe, _sendEndpointProvider, _publishEndpointProvider)
: new MessageReceiverFilter(receivePipe, _sendEndpointProvider, _publishEndpointProvider), 1))
.Select(x => (IPipeSpecification <NamespaceContext>) new FilterPipeSpecification <NamespaceContext>(x))
.ToArray();
var transport = new ReceiveTransport(Host, _settings, specifications);
var serviceBusHost = Host as ServiceBusHost;
if (serviceBusHost == null)
{
throw new ConfigurationException("Must be a ServiceBusHost");
}
serviceBusHost.ReceiveEndpoints.Add(_settings.Path, new ReceiveEndpoint(transport, receivePipe));
}
public void AddConfigurator_GivenNonGeneric_ThenValid()
{
var services = new ServiceCollection();
var receiveEndpointBuilder = new ReceiveEndpointBuilder <IHost, IReceiveEndpointConfigurator>(services);
var mockHost = new Mock <IHost>(MockBehavior.Strict);
var mockServiceProvider = new Mock <IServiceProvider>(MockBehavior.Strict);
var mockReceiveEndpointConfigurator = new Mock <IReceiveEndpointConfigurator>(MockBehavior.Strict);
var configuratorWasCalled = false;
IReceiveEndpointBuilder receiveEndpointBuilderNonGeneric = receiveEndpointBuilder;
receiveEndpointBuilderNonGeneric.AddConfigurator((host, configurator, serviceProvider) =>
{
configuratorWasCalled = true;
Assert.Same(mockHost.Object, host);
Assert.Same(mockServiceProvider.Object, serviceProvider);
Assert.Same(mockReceiveEndpointConfigurator.Object, configurator);
});
receiveEndpointBuilder.Configure(mockHost.Object, mockReceiveEndpointConfigurator.Object, mockServiceProvider.Object);
Assert.True(configuratorWasCalled);
}
public void Configure(IReceiveEndpointBuilder builder)
{
InstanceConnectorCache.GetInstanceConnector(_instance.GetType()).ConnectInstance(builder, _instance);
}
public void Configure(IReceiveEndpointBuilder builder)
{
}
public void Configure(IReceiveEndpointBuilder builder)
{
_connector.ConnectSaga(builder, _repository, _specification);
}
public void Configure(IReceiveEndpointBuilder builder)
{
ConsumerConnectorCache <TConsumer> .Connector.ConnectConsumer(builder, _consumerFactory, _specification);
}
public void Configure(IReceiveEndpointBuilder builder)
{
builder.AddMessageDeserializer(_contentType, _deserializerFactory);
}
public void Configure(IReceiveEndpointBuilder builder)
{
ConsumerConnectorCache <TConsumer> .Connector.ConnectConsumer(builder, _consumerFactory, new IPipeSpecification <ConsumerConsumeContext <TConsumer> > [0]);
}
public void Configure(IReceiveEndpointBuilder builder)
{
builder.SetMessageSerializer(CreateSerializer);
builder.AddMessageDeserializer(EncryptedMessageSerializer.EncryptedContentType, CreateDeserializer);
}
protected ISendEndpointProvider CreateSendEndpointProvider(IReceiveEndpointBuilder builder)
{
return(builder.CreateSendEndpointProvider(InputAddress, _sendPipeConfigurator));
}
public void Configure(IReceiveEndpointBuilder builder)
{
builder.AddMessageDeserializer(_contentType, _deserializerFactory);
}
public void Configure(IReceiveEndpointBuilder builder)
{
SagaConnectorCache <TSaga> .Connector.ConnectSaga(builder, _sagaRepository, _specification);
}
public void Configure(IReceiveEndpointBuilder builder)
{
InstanceConnectorCache.GetInstanceConnector(_instance.GetType()).ConnectInstance(builder, _instance);
}
public void Configure(IReceiveEndpointBuilder builder)
{
builder.SetMessageSerializer(CreateSerializer);
builder.AddMessageDeserializer(EncryptedMessageSerializer.EncryptedContentType, CreateDeserializer);
}
protected IPublishEndpointProvider CreatePublishEndpointProvider(IReceiveEndpointBuilder builder)
{
return(builder.CreatePublishEndpointProvider(InputAddress, _publishPipeConfigurator));
}
