public async Task PrepareToStart(IBuilder builder,
RecoverabilityComponent recoverabilityComponent,
MessageOperations messageOperations,
PipelineComponent pipelineComponent,
IPipelineCache pipelineCache)
{
if (configuration.IsSendOnlyEndpoint)
{
return;
}
var receivePipeline = pipelineComponent.CreatePipeline <ITransportReceiveContext>(builder);
mainPipelineExecutor = new MainPipelineExecutor(builder, pipelineCache, messageOperations, configuration.PipelineCompletedSubscribers, receivePipeline);
if (configuration.PurgeOnStartup)
{
Logger.Warn("All queues owned by the endpoint will be purged on startup.");
}
AddReceivers(builder, recoverabilityComponent.GetRecoverabilityExecutorFactory(builder), transportReceiveInfrastructure.MessagePumpFactory);
foreach (var receiver in receivers)
{
try
{
await receiver.Init().ConfigureAwait(false);
}
catch (Exception ex)
{
Logger.Fatal($"Receiver {receiver.Id} failed to initialize.", ex);
throw;
}
}
}
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);
}
}
EndpointCreator(SettingsHolder settings,
ContainerComponent containerComponent,
PipelineComponent pipelineComponent)
{
this.settings = settings;
this.containerComponent = containerComponent;
this.pipelineComponent = pipelineComponent;
}
public async Task Initialize(IServiceProvider builder,
RecoverabilityComponent recoverabilityComponent,
MessageOperations messageOperations,
PipelineComponent pipelineComponent,
IPipelineCache pipelineCache,
TransportInfrastructure transportInfrastructure,
CancellationToken cancellationToken = default)
{
if (configuration.IsSendOnlyEndpoint)
{
return;
}
var mainPump = transportInfrastructure.Receivers[MainReceiverId];
var receivePipeline = pipelineComponent.CreatePipeline <ITransportReceiveContext>(builder);
var mainPipelineExecutor = new MainPipelineExecutor(builder, pipelineCache, messageOperations, configuration.PipelineCompletedSubscribers, receivePipeline);
var recoverabilityExecutorFactory = recoverabilityComponent.GetRecoverabilityExecutorFactory(builder);
var recoverability = recoverabilityExecutorFactory
.CreateDefault(configuration.LocalAddress);
await mainPump.Initialize(configuration.PushRuntimeSettings, mainPipelineExecutor.Invoke,
recoverability.Invoke, cancellationToken).ConfigureAwait(false);
receivers.Add(mainPump);
if (transportInfrastructure.Receivers.TryGetValue(InstanceSpecificReceiverId, out var instanceSpecificPump))
{
var instanceSpecificRecoverabilityExecutor = recoverabilityExecutorFactory.CreateDefault(configuration.InstanceSpecificQueue);
await instanceSpecificPump.Initialize(configuration.PushRuntimeSettings, mainPipelineExecutor.Invoke,
instanceSpecificRecoverabilityExecutor.Invoke, cancellationToken).ConfigureAwait(false);
receivers.Add(instanceSpecificPump);
}
foreach (var satellite in configuration.SatelliteDefinitions)
{
try
{
var satellitePump = transportInfrastructure.Receivers[satellite.Name];
var satellitePipeline = new SatellitePipelineExecutor(builder, satellite);
var satelliteRecoverabilityExecutor = recoverabilityExecutorFactory.Create(satellite.RecoverabilityPolicy, satellite.ReceiveAddress);
await satellitePump.Initialize(satellite.RuntimeSettings, satellitePipeline.Invoke,
satelliteRecoverabilityExecutor.Invoke, cancellationToken).ConfigureAwait(false);
receivers.Add(satellitePump);
}
catch (Exception ex) when(!ex.IsCausedBy(cancellationToken))
{
Logger.Fatal("Satellite failed to start.", ex);
throw;
}
}
}
public MessageOperations CreateMessageOperations(IServiceProvider builder, PipelineComponent pipelineComponent)
{
return(new MessageOperations(
messageMapper,
pipelineComponent.CreatePipeline <IOutgoingPublishContext>(builder),
pipelineComponent.CreatePipeline <IOutgoingSendContext>(builder),
pipelineComponent.CreatePipeline <IOutgoingReplyContext>(builder),
pipelineComponent.CreatePipeline <ISubscribeContext>(builder),
pipelineComponent.CreatePipeline <IUnsubscribeContext>(builder)));
}
ReceiveComponent(ReceiveConfiguration transportReceiveConfiguration,
PipelineComponent pipelineComponent,
CriticalError criticalError,
string errorQueue)
{
this.transportReceiveConfiguration = transportReceiveConfiguration;
this.pipelineComponent = pipelineComponent;
this.criticalError = criticalError;
this.errorQueue = errorQueue;
}
public InitializableEndpoint(SettingsHolder settings,
IContainer container,
List <Action <IConfigureComponents> > registrations,
PipelineComponent pipelineComponent)
{
this.settings = settings;
this.pipelineComponent = pipelineComponent;
RegisterContainerAdapter(container);
RunUserRegistrations(registrations);
this.container.RegisterSingleton <ReadOnlySettings>(settings);
}
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(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,
PipelineComponent pipeline,
QueueBindings queueBindings,
EventAggregator eventAggregator)
{
var errorQueue = settings.ErrorQueueAddress();
var receiveComponent = new ReceiveComponent(settings,
receiveConfiguration,
receiveConfiguration != null ? transportInfrastructure.ConfigureReceiveInfrastructure() : null, //don't create the receive infrastructure for send-only endpoints
pipeline,
builder,
eventAggregator,
criticalError,
errorQueue);
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 StartableEndpoint(SettingsHolder settings,
ContainerComponent containerComponent,
FeatureComponent featureComponent,
TransportComponent transportComponent,
ReceiveComponent receiveComponent,
CriticalError criticalError,
PipelineComponent pipelineComponent,
RecoverabilityComponent recoverabilityComponent,
HostingComponent hostingComponent)
{
this.criticalError = criticalError;
this.settings = settings;
this.containerComponent = containerComponent;
this.featureComponent = featureComponent;
this.transportComponent = transportComponent;
this.receiveComponent = receiveComponent;
this.pipelineComponent = pipelineComponent;
this.recoverabilityComponent = recoverabilityComponent;
this.hostingComponent = hostingComponent;
}
public StartableEndpoint(SettingsHolder settings,
FeatureComponent featureComponent,
ReceiveComponent receiveComponent,
TransportSeam transportSeam,
PipelineComponent pipelineComponent,
RecoverabilityComponent recoverabilityComponent,
HostingComponent hostingComponent,
SendComponent sendComponent,
IServiceProvider builder)
{
this.settings = settings;
this.featureComponent = featureComponent;
this.receiveComponent = receiveComponent;
this.transportSeam = transportSeam;
this.pipelineComponent = pipelineComponent;
this.recoverabilityComponent = recoverabilityComponent;
this.hostingComponent = hostingComponent;
this.sendComponent = sendComponent;
this.builder = builder;
}
public StartableEndpoint(SettingsHolder settings,
FeatureComponent featureComponent,
ReceiveComponent receiveComponent,
TransportInfrastructure transportInfrastructure,
PipelineComponent pipelineComponent,
RecoverabilityComponent recoverabilityComponent,
HostingComponent hostingComponent,
SendComponent sendComponent,
IBuilder builder)
{
this.settings = settings;
this.featureComponent = featureComponent;
this.receiveComponent = receiveComponent;
this.transportInfrastructure = transportInfrastructure;
this.pipelineComponent = pipelineComponent;
this.recoverabilityComponent = recoverabilityComponent;
this.hostingComponent = hostingComponent;
this.sendComponent = sendComponent;
this.builder = builder;
}
/// <summary>
/// Initializes the endpoint configuration builder.
/// </summary>
/// <param name="endpointName">The name of the endpoint being configured.</param>
public EndpointConfiguration(string endpointName)
: base(new SettingsHolder())
{
ValidateEndpointName(endpointName);
Settings.Set(new StartupDiagnosticEntries());
Settings.Set("NServiceBus.Routing.EndpointName", endpointName);
pipelineComponent = new PipelineComponent(Settings);
Settings.Set(new QueueBindings());
Settings.SetDefault("Endpoint.SendOnly", false);
Settings.SetDefault("Transactions.IsolationLevel", IsolationLevel.ReadCommitted);
Settings.SetDefault("Transactions.DefaultTimeout", TransactionManager.DefaultTimeout);
Notifications = new Notifications();
Settings.Set(Notifications);
Settings.Set(new NotificationSubscriptions());
conventionsBuilder = new ConventionsBuilder(Settings);
}
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);
}
public MainPipelineExecutor(IBuilder builder, PipelineComponent pipelineComponent)
{
this.builder = builder;
this.pipelineComponent = pipelineComponent;
}
void Initialize()
{
var pipelineSettings = settings.Get <PipelineSettings>();
hostingConfiguration.Container.RegisterSingleton <ReadOnlySettings>(settings);
featureComponent = new FeatureComponent(settings);
// This needs to happen here to make sure that features enabled state is present in settings so both
// IWantToRunBeforeConfigurationIsFinalized implementations and transports can check access it
featureComponent.RegisterFeatureEnabledStatusInSettings(hostingConfiguration);
ConfigRunBeforeIsFinalized(hostingConfiguration);
var transportConfiguration = TransportComponent.PrepareConfiguration(settings.Get <TransportComponent.Settings>());
var receiveConfiguration = BuildReceiveConfiguration(transportConfiguration);
var routingComponent = RoutingComponent.Initialize(
settings.Get <RoutingComponent.Configuration>(),
transportConfiguration,
receiveConfiguration,
settings.Get <Conventions>(),
pipelineSettings);
var messageMapper = new MessageMapper();
settings.Set <IMessageMapper>(messageMapper);
recoverabilityComponent = new RecoverabilityComponent(settings);
var featureConfigurationContext = new FeatureConfigurationContext(settings, hostingConfiguration.Container, pipelineSettings, routingComponent, receiveConfiguration);
featureComponent.Initalize(featureConfigurationContext);
hostingConfiguration.CreateHostInformationForV7BackwardsCompatibility();
recoverabilityComponent.Initialize(receiveConfiguration, hostingConfiguration);
sendComponent = SendComponent.Initialize(pipelineSettings, hostingConfiguration, routingComponent, messageMapper);
pipelineComponent = PipelineComponent.Initialize(pipelineSettings, hostingConfiguration);
hostingConfiguration.Container.ConfigureComponent(b => settings.Get <Notifications>(), DependencyLifecycle.SingleInstance);
receiveComponent = ReceiveComponent.Initialize(
settings.Get <ReceiveComponent.Configuration>(),
receiveConfiguration,
transportConfiguration,
pipelineComponent,
settings.ErrorQueueAddress(),
hostingConfiguration,
pipelineSettings);
installationComponent = InstallationComponent.Initialize(settings.Get <InstallationComponent.Configuration>(),
hostingConfiguration);
// The settings can only be locked after initializing the feature component since it uses the settings to store & share feature state.
// As well as all the other components have been initialized
settings.PreventChanges();
transportComponent = TransportComponent.Initialize(transportConfiguration, hostingConfiguration);
settings.AddStartupDiagnosticsSection("Endpoint",
new
{
Name = settings.EndpointName(),
SendOnly = settings.Get <bool>("Endpoint.SendOnly"),
NServiceBusVersion = GitVersionInformation.MajorMinorPatch
}
);
}
void Initialize()
{
containerComponent.ContainerConfiguration.RegisterSingleton <ReadOnlySettings>(settings);
RegisterCriticalErrorHandler();
var concreteTypes = settings.GetAvailableTypes()
.Where(IsConcrete)
.ToList();
featureComponent = new FeatureComponent(settings);
// This needs to happen here to make sure that features enabled state is present in settings so both
// IWantToRunBeforeConfigurationIsFinalized implementations and transports can check access it
featureComponent.RegisterFeatureEnabledStatusInSettings(concreteTypes);
ConfigRunBeforeIsFinalized(concreteTypes);
transportComponent = TransportComponent.Initialize(settings.Get <TransportComponent.Configuration>(), settings);
var receiveConfiguration = BuildReceiveConfiguration(transportComponent);
var routingComponent = new RoutingComponent(settings);
var pipelineSettings = settings.Get <PipelineSettings>();
routingComponent.Initialize(transportComponent, pipelineSettings, receiveConfiguration);
var messageMapper = new MessageMapper();
settings.Set <IMessageMapper>(messageMapper);
recoverabilityComponent = new RecoverabilityComponent(settings);
var featureConfigurationContext = new FeatureConfigurationContext(settings, containerComponent.ContainerConfiguration, pipelineSettings, routingComponent, receiveConfiguration);
featureComponent.Initalize(containerComponent, featureConfigurationContext);
//The settings can only be locked after initializing the feature component since it uses the settings to store & share feature state.
settings.PreventChanges();
hostingComponent = HostingComponent.Initialize(settings.Get <HostingComponent.Configuration>(), containerComponent, pipelineSettings);
recoverabilityComponent.Initialize(receiveConfiguration, hostingComponent);
pipelineComponent = PipelineComponent.Initialize(pipelineSettings, containerComponent);
pipelineComponent.AddRootContextItem <IMessageMapper>(messageMapper);
containerComponent.ContainerConfiguration.ConfigureComponent(b => settings.Get <Notifications>(), DependencyLifecycle.SingleInstance);
var eventAggregator = new EventAggregator(settings.Get <NotificationSubscriptions>());
pipelineComponent.AddRootContextItem <IEventAggregator>(eventAggregator);
receiveComponent = ReceiveComponent.Initialize(receiveConfiguration,
transportComponent,
pipelineComponent,
eventAggregator,
criticalError,
settings.ErrorQueueAddress(),
hostingComponent);
installationComponent = InstallationComponent.Initialize(settings.Get <InstallationComponent.Configuration>(),
concreteTypes,
containerComponent,
transportComponent);
settings.AddStartupDiagnosticsSection("Endpoint",
new
{
Name = settings.EndpointName(),
SendOnly = settings.Get <bool>("Endpoint.SendOnly"),
NServiceBusVersion = GitVersionInformation.MajorMinorPatch
}
);
}
void Configure()
{
ConfigureMessageTypes();
var pipelineSettings = settings.Get <PipelineSettings>();
hostingConfiguration.Services.AddSingleton(typeof(ReadOnlySettings), settings);
featureComponent = new FeatureComponent(settings);
// This needs to happen here to make sure that features enabled state is present in settings so both
// IWantToRunBeforeConfigurationIsFinalized implementations and transports can check access it
featureComponent.RegisterFeatureEnabledStatusInSettings(hostingConfiguration);
transportSeam = TransportSeam.Create(settings.Get <TransportSeam.Settings>(), hostingConfiguration);
var receiveConfiguration = ReceiveComponent.PrepareConfiguration(
hostingConfiguration,
settings.Get <ReceiveComponent.Settings>(),
transportSeam);
var routingConfiguration = RoutingComponent.Configure(settings.Get <RoutingComponent.Settings>());
var messageMapper = new MessageMapper();
settings.Set <IMessageMapper>(messageMapper);
recoverabilityComponent = new RecoverabilityComponent(settings);
var featureConfigurationContext = new FeatureConfigurationContext(settings, hostingConfiguration.Services, pipelineSettings, routingConfiguration, receiveConfiguration);
featureComponent.Initalize(featureConfigurationContext);
recoverabilityComponent.Initialize(receiveConfiguration, hostingConfiguration, transportSeam);
var routingComponent = RoutingComponent.Initialize(
routingConfiguration,
transportSeam,
receiveConfiguration,
settings.Get <Conventions>(),
pipelineSettings);
sendComponent = SendComponent.Initialize(pipelineSettings, hostingConfiguration, routingComponent, messageMapper);
hostingConfiguration.Services.ConfigureComponent(b => settings.Get <Notifications>(), DependencyLifecycle.SingleInstance);
receiveComponent = ReceiveComponent.Configure(
receiveConfiguration,
settings.ErrorQueueAddress(),
hostingConfiguration,
pipelineSettings);
pipelineComponent = PipelineComponent.Initialize(pipelineSettings, hostingConfiguration);
// The settings can only be locked after initializing the feature component since it uses the settings to store & share feature state.
// As well as all the other components have been initialized
settings.PreventChanges();
// The pipeline settings can be locked after the endpoint is configured. It prevents end users from modyfing pipeline after an endpoint has started.
pipelineSettings.PreventChanges();
settings.AddStartupDiagnosticsSection("Endpoint",
new
{
Name = settings.EndpointName(),
SendOnly = settings.Get <bool>("Endpoint.SendOnly"),
NServiceBusVersion = GitVersionInformation.MajorMinorPatch
}
);
}
