public static InstallationComponent Initialize(Configuration configuration, List <Type> concreteTypes, ContainerComponent containerComponent, TransportComponent transportComponent)
{
var component = new InstallationComponent(configuration, containerComponent, transportComponent);
if (!configuration.ShouldRunInstallers)
{
return(component);
}
foreach (var installerType in concreteTypes.Where(t => IsINeedToInstallSomething(t)))
{
containerComponent.ContainerConfiguration.ConfigureComponent(installerType, DependencyLifecycle.InstancePerCall);
}
return(component);
}
public static InstallationComponent Initialize(Configuration configuration, HostingComponent.Configuration hostingConfiguration)
{
var component = new InstallationComponent(configuration);
if (!configuration.ShouldRunInstallers)
{
return(component);
}
foreach (var installerType in hostingConfiguration.AvailableTypes.Where(t => IsINeedToInstallSomething(t)))
{
hostingConfiguration.Container.ConfigureComponent(installerType, DependencyLifecycle.InstancePerCall);
}
return(component);
}
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
}
);
}