public void Initialize(ReceiveConfiguration receiveConfiguration)
{
if (settings.GetOrDefault <bool>("Endpoint.SendOnly"))
{
//Message recoverability is only relevant for endpoints receiving messages.
return;
}
transactionsOn = receiveConfiguration.TransactionMode != TransportTransactionMode.None;
var errorQueue = settings.ErrorQueueAddress();
settings.Get <QueueBindings>().BindSending(errorQueue);
var delayedRetryConfig = GetDelayedRetryConfig();
var immediateRetryConfig = GetImmediateRetryConfig();
var failedConfig = new FailedConfig(errorQueue, settings.UnrecoverableExceptions());
recoverabilityConfig = new RecoverabilityConfig(immediateRetryConfig, delayedRetryConfig, failedConfig);
settings.AddStartupDiagnosticsSection("Recoverability", new
{
ImmediateRetries = recoverabilityConfig.Immediate.MaxNumberOfRetries,
DelayedRetries = recoverabilityConfig.Delayed.MaxNumberOfRetries,
DelayedRetriesTimeIncrease = recoverabilityConfig.Delayed.TimeIncrease.ToString("g"),
recoverabilityConfig.Failed.ErrorQueue,
UnrecoverableExceptions = recoverabilityConfig.Failed.UnrecoverableExceptionTypes.Select(t => t.FullName).ToArray()
});
WireUpLegacyNotifications();
}
ReceiveComponent(ReceiveConfiguration transportReceiveConfiguration,
PipelineComponent pipelineComponent,
CriticalError criticalError,
string errorQueue)
{
this.transportReceiveConfiguration = transportReceiveConfiguration;
this.pipelineComponent = pipelineComponent;
this.criticalError = criticalError;
this.errorQueue = errorQueue;
}
ReceiveComponent(ReceiveConfiguration configuration,
Func <IPushMessages> messagePumpFactory,
PipelineComponent pipeline,
IEventAggregator eventAggregator,
CriticalError criticalError,
string errorQueue)
{
this.configuration = configuration;
this.messagePumpFactory = messagePumpFactory;
this.pipeline = pipeline;
this.eventAggregator = eventAggregator;
this.criticalError = criticalError;
this.errorQueue = errorQueue;
}
public ReceiveComponent(ReceiveConfiguration configuration,
TransportReceiveInfrastructure receiveInfrastructure,
PipelineComponent pipeline,
IEventAggregator eventAggregator,
CriticalError criticalError,
string errorQueue)
{
this.configuration = configuration;
this.receiveInfrastructure = receiveInfrastructure;
this.pipeline = pipeline;
this.eventAggregator = eventAggregator;
this.criticalError = criticalError;
this.errorQueue = errorQueue;
}
public static ReceiveComponent Initialize(ReceiveConfiguration receiveConfiguration,
TransportComponent transportComponent,
PipelineComponent pipeline,
EventAggregator eventAggregator,
CriticalError criticalError,
string errorQueue,
HostingComponent hostingComponent)
{
Func <IPushMessages> messagePumpFactory = null;
//we don't need the message pump factory for send-only endpoints
if (receiveConfiguration != null)
{
messagePumpFactory = transportComponent.GetMessagePumpFactory();
}
var receiveComponent = new ReceiveComponent(receiveConfiguration,
messagePumpFactory,
pipeline,
eventAggregator,
criticalError,
errorQueue);
receiveComponent.BindQueues(transportComponent.QueueBindings);
if (receiveConfiguration != null)
{
hostingComponent.AddStartupDiagnosticsSection("Receiving", new
{
receiveConfiguration.LocalAddress,
receiveConfiguration.InstanceSpecificQueue,
receiveConfiguration.LogicalAddress,
receiveConfiguration.PurgeOnStartup,
receiveConfiguration.QueueNameBase,
TransactionMode = receiveConfiguration.TransactionMode.ToString("G"),
receiveConfiguration.PushRuntimeSettings.MaxConcurrency,
Satellites = receiveConfiguration.SatelliteDefinitions.Select(s => new
{
s.Name,
s.ReceiveAddress,
TransactionMode = s.RequiredTransportTransactionMode.ToString("G"),
s.RuntimeSettings.MaxConcurrency
}).ToArray()
});
}
return(receiveComponent);
}
public ReceiveComponent(ReceiveConfiguration configuration,
TransportReceiveInfrastructure receiveInfrastructure,
IPipelineExecutor mainPipelineExecutor,
IEventAggregator eventAggregator,
IBuilder builder,
CriticalError criticalError,
string errorQueue)
{
this.configuration = configuration;
this.receiveInfrastructure = receiveInfrastructure;
this.mainPipelineExecutor = mainPipelineExecutor;
this.eventAggregator = eventAggregator;
this.builder = builder;
this.criticalError = criticalError;
this.errorQueue = errorQueue;
}
public static RoutingComponent Initialize(Configuration configuration,
TransportComponent.Configuration transportConfiguration,
ReceiveConfiguration receiveConfiguration,
Conventions conventions,
PipelineSettings pipelineSettings)
{
var distributionPolicy = configuration.DistributionPolicy;
var unicastRoutingTable = configuration.UnicastRoutingTable;
var endpointInstances = configuration.EndpointInstances;
foreach (var distributionStrategy in configuration.DistributionStrategies)
{
distributionPolicy.SetDistributionStrategy(distributionStrategy);
}
configuration.ConfiguredUnicastRoutes?.Apply(unicastRoutingTable, conventions);
var isSendOnlyEndpoint = receiveConfiguration == null;
if (isSendOnlyEndpoint == false)
{
pipelineSettings.Register(new ApplyReplyToAddressBehavior(
receiveConfiguration.LocalAddress,
receiveConfiguration.InstanceSpecificQueue,
configuration.PublicReturnAddress),
"Applies the public reply to address to outgoing messages");
}
var sendRouter = new UnicastSendRouter(
isSendOnlyEndpoint,
receiveConfiguration?.QueueNameBase,
receiveConfiguration?.InstanceSpecificQueue,
distributionPolicy,
unicastRoutingTable,
endpointInstances,
i => transportConfiguration.ToTransportAddress(LogicalAddress.CreateRemoteAddress(i)));
return(new RoutingComponent(
unicastRoutingTable,
distributionPolicy,
endpointInstances,
configuration.Publishers,
sendRouter,
configuration.EnforceBestPractices,
new Validations(conventions)));
}
public ReceiveComponent(SettingsHolder settings,
ReceiveConfiguration configuration,
TransportReceiveInfrastructure receiveInfrastructure,
PipelineComponent pipeline,
IBuilder builder,
IEventAggregator eventAggregator,
CriticalError criticalError,
string errorQueue)
{
this.settings = settings;
this.configuration = configuration;
this.receiveInfrastructure = receiveInfrastructure;
this.pipeline = pipeline;
this.builder = builder;
this.eventAggregator = eventAggregator;
this.criticalError = criticalError;
this.errorQueue = errorQueue;
}
ReceiveComponent CreateReceiveComponent(ReceiveConfiguration receiveConfiguration,
TransportInfrastructure transportInfrastructure,
QueueBindings queueBindings,
IPipelineCache pipelineCache,
EventAggregator eventAggregator,
IMessageMapper messageMapper)
{
var errorQueue = settings.ErrorQueueAddress();
var receiveComponent = new ReceiveComponent(receiveConfiguration,
receiveConfiguration != null ? transportInfrastructure.ConfigureReceiveInfrastructure() : null, //don't create the receive infrastructure for send-only endpoints
pipelineCache,
pipelineConfiguration,
eventAggregator,
builder,
criticalError,
errorQueue,
messageMapper);
receiveComponent.BindQueues(queueBindings);
if (receiveConfiguration != null)
{
settings.AddStartupDiagnosticsSection("Receiving", new
{
receiveConfiguration.LocalAddress,
receiveConfiguration.InstanceSpecificQueue,
receiveConfiguration.LogicalAddress,
receiveConfiguration.PurgeOnStartup,
receiveConfiguration.QueueNameBase,
TransactionMode = receiveConfiguration.TransactionMode.ToString("G"),
receiveConfiguration.PushRuntimeSettings.MaxConcurrency,
Satellites = receiveConfiguration.SatelliteDefinitions.Select(s => new
{
s.Name,
s.ReceiveAddress,
TransactionMode = s.RequiredTransportTransactionMode.ToString("G"),
s.RuntimeSettings.MaxConcurrency
}).ToArray()
});
}
return(receiveComponent);
}
public ReceiveComponent(ReceiveConfiguration configuration,
TransportReceiveInfrastructure receiveInfrastructure,
IPipelineCache pipelineCache,
PipelineConfiguration pipelineConfiguration,
IEventAggregator eventAggregator,
IBuilder builder,
CriticalError criticalError,
string errorQueue,
IMessageMapper messageMapper)
{
this.configuration = configuration;
this.receiveInfrastructure = receiveInfrastructure;
this.pipelineCache = pipelineCache;
this.pipelineConfiguration = pipelineConfiguration;
this.eventAggregator = eventAggregator;
this.builder = builder;
this.criticalError = criticalError;
this.errorQueue = errorQueue;
this.messageMapper = messageMapper;
}
RoutingComponent InitializeRouting(TransportInfrastructure transportInfrastructure, ReceiveConfiguration receiveConfiguration)
{
// use GetOrCreate to use of instances already created during EndpointConfiguration.
var routing = new RoutingComponent(
settings.GetOrCreate <UnicastRoutingTable>(),
settings.GetOrCreate <DistributionPolicy>(),
settings.GetOrCreate <EndpointInstances>(),
settings.GetOrCreate <Publishers>());
routing.Initialize(settings, transportInfrastructure.ToTransportAddress, pipelineComponent.PipelineSettings, receiveConfiguration);
return(routing);
}
public void Initialize(TransportInfrastructure transportInfrastructure, PipelineComponent pipelineComponent, ReceiveConfiguration receiveConfiguration)
{
var conventions = settings.Get <Conventions>();
var configuredUnicastRoutes = settings.GetOrDefault <ConfiguredUnicastRoutes>();
if (settings.TryGet(out List <DistributionStrategy> distributionStrategies))
{
foreach (var distributionStrategy in distributionStrategies)
{
DistributionPolicy.SetDistributionStrategy(distributionStrategy);
}
}
configuredUnicastRoutes?.Apply(UnicastRoutingTable, conventions);
var pipelineSettings = pipelineComponent.PipelineSettings;
pipelineSettings.Register(b =>
{
var router = new UnicastSendRouter(receiveConfiguration == null, receiveConfiguration?.QueueNameBase, receiveConfiguration?.InstanceSpecificQueue, DistributionPolicy, UnicastRoutingTable, EndpointInstances, i => transportInfrastructure.ToTransportAddress(LogicalAddress.CreateRemoteAddress(i)));
return(new UnicastSendRouterConnector(router));
}, "Determines how the message being sent should be routed");
pipelineSettings.Register(new UnicastReplyRouterConnector(), "Determines how replies should be routed");
EnforceBestPractices = ShouldEnforceBestPractices(settings);
if (EnforceBestPractices)
{
EnableBestPracticeEnforcement(conventions, pipelineSettings);
}
}
public static ReceiveComponent Initialize(Configuration configuration,
ReceiveConfiguration transportReceiveConfiguration,
TransportComponent.Configuration transportConfiguration,
PipelineComponent pipelineComponent,
string errorQueue,
HostingComponent.Configuration hostingConfiguration,
PipelineSettings pipelineSettings)
{
var receiveComponent = new ReceiveComponent(transportReceiveConfiguration,
pipelineComponent,
hostingConfiguration.CriticalError,
errorQueue);
receiveComponent.BindQueues(transportConfiguration.QueueBindings);
pipelineSettings.Register("TransportReceiveToPhysicalMessageProcessingConnector", b =>
{
var storage = hostingConfiguration.Container.HasComponent <IOutboxStorage>() ? b.Build <IOutboxStorage>() : new NoOpOutboxStorage();
return(new TransportReceiveToPhysicalMessageConnector(storage));
}, "Allows to abort processing the message");
pipelineSettings.Register("LoadHandlersConnector", b =>
{
var adapter = hostingConfiguration.Container.HasComponent <ISynchronizedStorageAdapter>() ? b.Build <ISynchronizedStorageAdapter>() : new NoOpSynchronizedStorageAdapter();
var syncStorage = hostingConfiguration.Container.HasComponent <ISynchronizedStorage>() ? b.Build <ISynchronizedStorage>() : new NoOpSynchronizedStorage();
return(new LoadHandlersConnector(b.Build <MessageHandlerRegistry>(), syncStorage, adapter));
}, "Gets all the handlers to invoke from the MessageHandler registry based on the message type.");
pipelineSettings.Register("ExecuteUnitOfWork", new UnitOfWorkBehavior(), "Executes the UoW");
pipelineSettings.Register("InvokeHandlers", new InvokeHandlerTerminator(), "Calls the IHandleMessages<T>.Handle(T)");
if (!hostingConfiguration.Container.HasComponent <MessageHandlerRegistry>())
{
var orderedHandlers = configuration.ExecuteTheseHandlersFirst;
LoadMessageHandlers(configuration, orderedHandlers, hostingConfiguration.Container, hostingConfiguration.AvailableTypes);
}
if (transportReceiveConfiguration != null)
{
hostingConfiguration.AddStartupDiagnosticsSection("Receiving", new
{
transportReceiveConfiguration.LocalAddress,
transportReceiveConfiguration.InstanceSpecificQueue,
transportReceiveConfiguration.LogicalAddress,
transportReceiveConfiguration.PurgeOnStartup,
transportReceiveConfiguration.QueueNameBase,
TransactionMode = transportReceiveConfiguration.TransactionMode.ToString("G"),
transportReceiveConfiguration.PushRuntimeSettings.MaxConcurrency,
Satellites = transportReceiveConfiguration.SatelliteDefinitions.Select(s => new
{
s.Name,
s.ReceiveAddress,
TransactionMode = s.RequiredTransportTransactionMode.ToString("G"),
s.RuntimeSettings.MaxConcurrency
}).ToArray()
});
}
return(receiveComponent);
}
