public FeaturesReport SetupFeatures(IConfigureComponents container, PipelineSettings pipelineSettings)
{
// featuresToActivate is enumerated twice because after setting defaults some new features might got activated.
var sourceFeatures = Sort(features);
var enabledFeatures = new List<FeatureInfo>();
while (true)
{
var featureToActivate = sourceFeatures.FirstOrDefault(x => settings.IsFeatureEnabled(x.Feature.GetType()));
if (featureToActivate == null)
{
break;
}
sourceFeatures.Remove(featureToActivate);
enabledFeatures.Add(featureToActivate);
featureToActivate.Feature.ConfigureDefaults(settings);
}
foreach (var feature in enabledFeatures)
{
ActivateFeature(feature, enabledFeatures, container, pipelineSettings);
}
settings.PreventChanges();
return new FeaturesReport(features.Select(t => t.Diagnostics).ToList());
}
public FeaturesReport SetupFeatures(IConfigureComponents container, PipelineSettings pipelineSettings, RoutingComponent routing)
{
// featuresToActivate is enumerated twice because after setting defaults some new features might got activated.
var sourceFeatures = Sort(features);
var enabledFeatures = new List <FeatureInfo>();
while (true)
{
var featureToActivate = sourceFeatures.FirstOrDefault(x => settings.IsFeatureEnabled(x.Feature.GetType()));
if (featureToActivate == null)
{
break;
}
sourceFeatures.Remove(featureToActivate);
enabledFeatures.Add(featureToActivate);
featureToActivate.Feature.ConfigureDefaults(settings);
}
foreach (var feature in enabledFeatures)
{
ActivateFeature(feature, enabledFeatures, container, pipelineSettings, routing);
}
settings.PreventChanges();
return(new FeaturesReport(features.Select(t => t.Diagnostics).ToList()));
}
/// <summary>
/// Starts the configuration process for the saga infrastructure.
/// </summary>
/// <param name="configurer"></param>
/// <param name="builder"></param>
/// <returns></returns>
public static Configure With(IConfigureComponents configurer, IBuilder builder)
{
_builderStatic = builder;
configurer.ConfigureComponent<ReplyingToNullOriginatorDispatcher>(ComponentCallModelEnum.Singleton);
return new Configure { configurer = configurer };
}
internal FeatureConfigurationContext(ReadOnlySettings settings, IConfigureComponents container, PipelineSettings pipelineSettings)
{
Settings = settings;
Container = container;
Pipeline = pipelineSettings;
TaskControllers = new List <FeatureStartupTaskController>();
}
internal void ApplyContainerRegistration(ReadOnlySettings settings, IConfigureComponents container)
{
if (!IsEnabled(settings) || factoryMethod != null)
{
return;
}
container.ConfigureComponent(BehaviorType, DependencyLifecycle.InstancePerCall);
}
internal void ApplyContainerRegistration(ReadOnlySettings settings, IConfigureComponents container)
{
if (!IsEnabled(settings) || factoryMethod != null)
{
return;
}
container.ConfigureComponent(BehaviorType, DependencyLifecycle.InstancePerCall);
}
internal void ApplyContainerRegistration(IConfigureComponents container)
{
if (factoryMethod != null)
{
return;
}
container.ConfigureComponent(BehaviorType, DependencyLifecycle.InstancePerCall);
}
/// <summary>
/// Starts the configuration process for the saga infrastructure.
/// </summary>
/// <param name="configurer"></param>
/// <param name="builder"></param>
/// <returns></returns>
public static Configure With(IConfigureComponents configurer, IBuilder builder)
{
configurer.ConfigureComponent <ReplyingToNullOriginatorDispatcher>(DependencyLifecycle.SingleInstance);
configurer.ConfigureComponent <SagaIdEnricher>(DependencyLifecycle.InstancePerCall);
return(new Configure {
configurer = configurer
});
}
static void RegisterInheritanceHierarchyOfContextOnContainer(RunDescriptor runDescriptor, IConfigureComponents r)
{
var type = runDescriptor.ScenarioContext.GetType();
while (type != typeof(object))
{
r.RegisterSingleton(type, runDescriptor.ScenarioContext);
type = type.BaseType;
}
}
internal FeatureConfigurationContext(ReadOnlySettings settings, IConfigureComponents container, PipelineSettings pipelineSettings, RoutingComponent routing, ReceiveConfiguration receiving)
{
Settings = settings;
Container = container;
Pipeline = pipelineSettings;
Routing = routing;
this.receiving = receiving;
TaskControllers = new List <FeatureStartupTaskController>();
}
public void RegisterStartupTasks(IConfigureComponents container)
{
foreach (var feature in features.Where(f => f.Feature.IsActive))
{
foreach (var taskType in feature.Feature.StartupTasks)
{
container.ConfigureComponent(taskType, DependencyLifecycle.SingleInstance);
}
}
}
public static async Task <IStartableEndpoint> CreateWithInternallyManagedContainer(EndpointConfiguration endpointConfiguration)
{
var settings = endpointConfiguration.Settings;
CheckIfSettingsWhereUsedToCreateAnotherEndpoint(settings);
var assemblyScanningComponent = AssemblyScanningComponent.Initialize(settings.Get <AssemblyScanningComponent.Configuration>(), settings);
endpointConfiguration.FinalizeConfiguration(assemblyScanningComponent.AvailableTypes);
var hostingSetting = settings.Get <HostingComponent.Settings>();
var useDefaultBuilder = hostingSetting.CustomObjectBuilder == null;
var container = useDefaultBuilder ? new LightInjectObjectBuilder() : hostingSetting.CustomObjectBuilder;
var commonObjectBuilder = new CommonObjectBuilder(container);
IConfigureComponents internalContainer = commonObjectBuilder;
IBuilder internalBuilder = commonObjectBuilder;
//for backwards compatibility we need to make the IBuilder available in the container
internalContainer.ConfigureComponent(_ => internalBuilder, DependencyLifecycle.SingleInstance);
var hostingConfiguration = HostingComponent.PrepareConfiguration(settings.Get <HostingComponent.Settings>(), assemblyScanningComponent, internalContainer);
if (useDefaultBuilder)
{
hostingConfiguration.AddStartupDiagnosticsSection("Container", new
{
Type = "internal"
});
}
else
{
var containerType = internalContainer.GetType();
hostingConfiguration.AddStartupDiagnosticsSection("Container", new
{
Type = containerType.FullName,
Version = FileVersionRetriever.GetFileVersion(containerType)
});
}
var endpointCreator = EndpointCreator.Create(settings, hostingConfiguration);
var hostingComponent = HostingComponent.Initialize(hostingConfiguration);
var startableEndpoint = endpointCreator.CreateStartableEndpoint(internalBuilder, hostingComponent);
hostingComponent.RegisterBuilder(internalBuilder, true);
await hostingComponent.RunInstallers().ConfigureAwait(false);
return(new InternallyManagedContainerHost(startableEndpoint, hostingComponent));
}
public static IConfigureComponents MongoDbPersistence(this IConfigureComponents config, Func <string> getConnectionString)
{
var connectionString = getConnectionString();
if (String.IsNullOrWhiteSpace(connectionString))
{
throw new ConfigurationErrorsException("Cannot configure Mongo Persister. No connection string was found");
}
return(MongoPersistenceWithConectionString(config, connectionString));
}
public async Task CallActionOnBuildWhenComponentRegistrationsDefined()
{
IConfigureComponents configureComponents = null;
var endpoint = await _target.Create(EndpointAddress)
.WithTransport <LearningTransport>(tc => tc.StorageDirectory(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)))
.WithRegisteredComponents(c => configureComponents = c)
.Build();
configureComponents.Should().NotBeNull();
configureComponents.Should().BeAssignableTo <IConfigureComponents>();
}
/// <summary>
/// Holds storage queue address.
/// </summary>
public DistributorStorageQueueCreator(Configure config, IConfigureComponents container)
{
disabled = !container.HasComponent<MsmqWorkerAvailabilityManager>();
if (disabled)
{
return;
}
address = config.LocalAddress.SubScope("distributor.storage");
}
/// <summary>
/// Holds storage queue address.
/// </summary>
public DistributorStorageQueueCreator(Configure config, IConfigureComponents container)
{
disabled = !container.HasComponent <MsmqWorkerAvailabilityManager>();
if (disabled)
{
return;
}
address = config.LocalAddress.SubScope("distributor.storage");
}
private static void RegisterBusComponents(IConfigureComponents configureComponents)
{
if (!configureComponents.HasComponent<UnitOfWorkManager>())
{
configureComponents.ConfigureComponent<UnitOfWorkManager>(DependencyLifecycle.SingleInstance);
}
if (!configureComponents.HasComponent<ConfigurationRunner>())
{
configureComponents.ConfigureComponent<ConfigurationRunner>(DependencyLifecycle.InstancePerCall);
}
}
public void RegisterBehaviorsInContainer(SettingsHolder settings, IConfigureComponents container)
{
foreach (var registeredBehavior in Modifications.Replacements)
{
container.ConfigureComponent(registeredBehavior.BehaviorType, DependencyLifecycle.InstancePerCall);
}
foreach (var step in Modifications.Additions)
{
step.ApplyContainerRegistration(settings, container);
}
}
private static void RegisterBusComponents(IConfigureComponents configureComponents)
{
if (!configureComponents.HasComponent <UnitOfWorkManager>())
{
configureComponents.ConfigureComponent <UnitOfWorkManager>(DependencyLifecycle.SingleInstance);
}
if (!configureComponents.HasComponent <ConfigurationRunner>())
{
configureComponents.ConfigureComponent <ConfigurationRunner>(DependencyLifecycle.InstancePerCall);
}
}
static void RegisterCustomFindersInContainer(IConfigureComponents container, IEnumerable <SagaMetadata> sagaMetaModel)
{
foreach (var finder in sagaMetaModel.SelectMany(m => m.Finders))
{
container.ConfigureComponent(finder.Type, DependencyLifecycle.InstancePerCall);
if (finder.Properties.TryGetValue("custom-finder-clr-type", out var customFinderType))
{
container.ConfigureComponent((Type)customFinderType, DependencyLifecycle.InstancePerCall);
}
}
}
void RegisterBehaviorsInContainer(IConfigureComponents container)
{
foreach (var registeredBehavior in modifications.Replacements)
{
container.ConfigureComponent(registeredBehavior.BehaviorType, DependencyLifecycle.InstancePerCall);
}
foreach (var step in modifications.Additions)
{
step.ApplyContainerRegistration(container);
}
}
public static IConfigureComponents MongoDbPersistence(this IConfigureComponents config, string connectionStringName)
{
var connectionStringEntry = ConfigurationManager.ConnectionStrings[connectionStringName];
if (connectionStringEntry == null)
{
throw new ConfigurationErrorsException(string.Format("Cannot configure Mongo Persister. No connection string named {0} was found", connectionStringName));
}
var connectionString = connectionStringEntry.ConnectionString;
return(MongoPersistenceWithConectionString(config, connectionString));
}
public static void ConfigureComponents(this IConfigureComponents componentConfig, IMessageBus bus, IMessageBusConfiguration configuration)
{
var nsbHandlerType = typeof(NSBMessageHandler <,>);
var handlers = configuration.MessageDefinitions
.Where(md => md.HandlerType != null)
.Select(md => nsbHandlerType.MakeGenericType(md.MessageType, md.HandlerType));
foreach (var handler in handlers)
{
componentConfig.ConfigureComponent(handler, DependencyLifecycle.InstancePerCall).ConfigureProperty("Bus", bus);
}
}
static void RegisterCustomFindersInContainer(IConfigureComponents container, IEnumerable<SagaMetadata> sagaMetaModel)
{
foreach (var finder in sagaMetaModel.SelectMany(m => m.Finders))
{
container.ConfigureComponent(finder.Type, DependencyLifecycle.InstancePerCall);
object customFinderType;
if (finder.Properties.TryGetValue("custom-finder-clr-type", out customFinderType))
{
container.ConfigureComponent((Type) customFinderType, DependencyLifecycle.InstancePerCall);
}
}
}
public static IConfigureComponents MongoPersistenceWithConectionString(IConfigureComponents config, string connectionString)
{
var databaseName = MongoUrl.Create(connectionString).DatabaseName;
if (String.IsNullOrWhiteSpace(databaseName))
{
throw new Exception("Cannot configure Mongo Persister. Database name not present in the connection string.");
}
var client = new MongoClient(connectionString);
var database = client.GetDatabase(databaseName);
return(MongoDbPersistence(config, database));
}
/// <summary>
/// Starts the configuration process for the saga infrastructure.
/// </summary>
/// <param name="configurer"></param>
/// <param name="builder"></param>
/// <returns></returns>
public static Configure With(IConfigureComponents configurer, IBuilder builder)
{
configurer.ConfigureComponent <ReplyingToNullOriginatorDispatcher>(DependencyLifecycle.SingleInstance);
configurer.ConfigureComponent <SagaIdEnricher>(DependencyLifecycle.InstancePerCall);
//Defining ITimeoutState and TimeoutMessage as valid system messages
NServiceBus.Configure.Instance.DefiningSystemMessagesAs(t => typeof(ITimeoutState).IsAssignableFrom(t) || t == typeof(TimeoutMessage));
//NServiceBus.Configure.Instance.DefiningSystemMessagesAs(t => t == typeof(TimeoutMessage));
//NServiceBus.Configure.Instance.DefiningSystemMessagesAs(t => typeof(ITimeoutState).IsAssignableFrom(t));
return(new Configure {
configurer = configurer
});
}
private void Registration(IConfigureComponents configureComponents)
{
var store = new DocumentStore {
Url = "http://localhost:8082", DefaultDatabase = "MyDatabase"
};
store.Initialize();
configureComponents.ConfigureComponent <DocumentStore>(() => store, DependencyLifecycle.SingleInstance);
configureComponents.ConfigureComponent <IManageUnitsOfWork>(() => new MyRavenUnitOfWork(),
DependencyLifecycle.InstancePerUnitOfWork);
configureComponents.ConfigureComponent <IDocumentSession>(
builder => builder.Build <DocumentStore>().OpenSession(), DependencyLifecycle.InstancePerUnitOfWork);
}
public static IConfigureComponents MongoDbPersistence(this IConfigureComponents config, IMongoDatabase database)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (database == null)
{
throw new ArgumentNullException(nameof(database));
}
config.RegisterSingleton(database);
return(config);
}
void Application_Start(object sender, EventArgs e)
{
// Code that runs on application startup
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
RouteConfig.RegisterRoutes(RouteTable.Routes);
var configuration = new BusConfiguration();
configuration.UsePersistence <InMemoryPersistence>();
configuration.UseSerialization <JsonSerializer>();
configuration.UseTransport <RabbitMQTransport>()
.ConnectionString("host=localhost");
var busInstance = Bus.Create(configuration).Start();
var builder = ((NServiceBus.Unicast.UnicastBus)busInstance).Builder;
IConfigureComponents configurer = null;
configuration.RegisterComponents(r =>
{
configurer = r;
r.RegisterSingleton <IControllerFactory>(new BuilderControllerFactory(builder));
});
System.Web.Mvc.DependencyResolver.SetResolver(t =>
{
if (configurer.HasComponent(t))
{
return(builder.Build(t));
}
//default value expected by MVC to signal that we have no components of type "t"
return(null);
},
t =>
{
if (configurer.HasComponent(t))
{
return(builder.BuildAll(t));
}
//default value expected by MVC to signal that we have no components of type "t"
return(new List <Object>());
});
}
void DefaultAction(Configure configure)
{
//https://github.com/Particular/NServiceBus/blob/support-5.0/src/NServiceBus.Core/CriticalError/CriticalError.cs
#region DefaultCriticalErrorAction
IConfigureComponents components = configure.Builder.Build <IConfigureComponents>();
if (!components.HasComponent <IBus>())
{
return;
}
configure.Builder.Build <IStartableBus>()
.Dispose();
#endregion
}
public void InitializeWithExternallyManagedContainer(IConfigureComponents configureComponents)
{
if (customContainer != null)
{
throw new InvalidOperationException("An internally managed container has already been configured using 'EndpointConfiguration.UseContainer'. It is not possible to use both an internally managed container and an externally managed container.");
}
ownsContainer = false;
ContainerConfiguration = configureComponents;
settings.AddStartupDiagnosticsSection("Container", new
{
Type = "external"
});
ApplyRegistrations();
}
public Configuration(Settings settings,
List <Type> availableTypes,
CriticalError criticalError,
StartupDiagnosticEntries startupDiagnostics,
string diagnosticsPath,
Func <string, Task> hostDiagnosticsWriter,
string endpointName,
IConfigureComponents container)
{
this.settings = settings;
AvailableTypes = availableTypes;
CriticalError = criticalError;
StartupDiagnostics = startupDiagnostics;
DiagnosticsPath = diagnosticsPath;
HostDiagnosticsWriter = hostDiagnosticsWriter;
EndpointName = endpointName;
Container = container;
}
async Task Usage(EndpointConfiguration endpointConfiguration, MyCustomContainer myCustomContainer)
{
#region ExternalPrepare
IConfigureComponents configureComponents =
AdaptContainerForRegistrationPhase(myCustomContainer);
var startableEndpoint = EndpointWithExternallyManagedContainer.Create(endpointConfiguration, configureComponents);
#endregion
#region ExternalStart
IBuilder builder = AdaptContainerForResolutionPhase(myCustomContainer);
var startedEndpoint = await startableEndpoint.Start(builder);
#endregion
}
static void Main()
{
Console.Title = "Samples.Headers";
Configure configure = Configure.With();
configure.Log4Net();
configure.DefineEndpointName("Samples.Headers");
configure.DefaultBuilder();
configure.MsmqTransport();
configure.InMemorySagaPersister();
configure.RunTimeoutManagerWithInMemoryPersistence();
configure.InMemorySubscriptionStorage();
configure.JsonSerializer();
IConfigureComponents components = configure.Configurer;
components.ConfigureComponent <MutateIncomingMessages>(DependencyLifecycle.InstancePerCall);
components.ConfigureComponent <MutateIncomingTransportMessages>(DependencyLifecycle.InstancePerCall);
components.ConfigureComponent <MutateOutgoingMessages>(DependencyLifecycle.InstancePerCall);
components.ConfigureComponent <MutateOutgoingTransportMessages>(DependencyLifecycle.InstancePerCall);
components.ConfigureComponent <MessageMutator>(DependencyLifecycle.InstancePerCall);
components.ConfigureComponent <MutateTransportMessages>(DependencyLifecycle.InstancePerCall);
#region global-all-outgoing
using (IStartableBus startableBus = configure.UnicastBus().CreateBus())
{
IDictionary <string, string> outgoingHeaders = ((IBus)startableBus).OutgoingHeaders;
outgoingHeaders.Add("AllOutgoing", "ValueAllOutgoing");
#endregion
IBus bus = startableBus.Start(() => configure.ForInstallationOn <Windows>().Install());
#region sending
MyMessage myMessage = new MyMessage();
myMessage.SetHeader("SendingMessage", "ValueSendingMessage");
bus.SendLocal(myMessage);
#endregion
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
static void Main()
{
Configure.Serialization.Json();
Configure configure = Configure.With();
configure.Log4Net();
configure.DefineEndpointName("Samples.Headers");
configure.DefaultBuilder();
configure.InMemorySagaPersister();
configure.UseInMemoryTimeoutPersister();
configure.InMemorySubscriptionStorage();
configure.UseTransport <Msmq>();
IConfigureComponents components = configure.Configurer;
components.ConfigureComponent <MutateIncomingMessages>(DependencyLifecycle.InstancePerCall);
components.ConfigureComponent <MutateIncomingTransportMessages>(DependencyLifecycle.InstancePerCall);
components.ConfigureComponent <MutateOutgoingMessages>(DependencyLifecycle.InstancePerCall);
components.ConfigureComponent <MutateOutgoingTransportMessages>(DependencyLifecycle.InstancePerCall);
components.ConfigureComponent <MessageMutator>(DependencyLifecycle.InstancePerCall);
components.ConfigureComponent <MutateTransportMessages>(DependencyLifecycle.InstancePerCall);
#region global-all-outgoing
using (IStartableBus startableBus = configure.UnicastBus().CreateBus())
{
startableBus.OutgoingHeaders.Add("AllOutgoing", "ValueAllOutgoing");
#endregion
IBus bus = startableBus.Start(() => configure.ForInstallationOn <Windows>().Install());
#region sending
MyMessage myMessage = new MyMessage();
bus.SetMessageHeader(myMessage, "SendingMessage", "ValueSendingMessage");
bus.SendLocal(myMessage);
#endregion
Console.WriteLine("\r\nPress any key to stop program\r\n");
Console.ReadKey();
}
}
public Configuration(Settings settings,
List <Type> availableTypes,
CriticalError criticalError,
StartupDiagnosticEntries startupDiagnostics,
string diagnosticsPath,
Func <string, Task> hostDiagnosticsWriter,
string endpointName,
IConfigureComponents container,
string installationUserName,
bool shouldRunInstallers)
{
AvailableTypes = availableTypes;
CriticalError = criticalError;
StartupDiagnostics = startupDiagnostics;
DiagnosticsPath = diagnosticsPath;
HostDiagnosticsWriter = hostDiagnosticsWriter;
EndpointName = endpointName;
Container = container;
InstallationUserName = installationUserName;
ShouldRunInstallers = shouldRunInstallers;
settings.ApplyHostIdDefaultIfNeeded();
HostInformation = new HostInformation(settings.HostId, settings.DisplayName, settings.Properties);
}
/// <summary>
/// Starts the configuration process for the saga infrastructure.
/// </summary>
/// <param name="configurer"></param>
/// <param name="builder"></param>
/// <returns></returns>
public static Configure With(IConfigureComponents configurer, IBuilder builder)
{
configurer.ConfigureComponent<ReplyingToNullOriginatorDispatcher>(DependencyLifecycle.SingleInstance);
configurer.ConfigureComponent<SagaIdEnricher>(DependencyLifecycle.InstancePerCall);
//Defining ITimeoutState and TimeoutMessage as valid system messages
NServiceBus.Configure.Instance.DefiningSystemMessagesAs(t => typeof (ITimeoutState).IsAssignableFrom(t) || t == typeof(TimeoutMessage));
//NServiceBus.Configure.Instance.DefiningSystemMessagesAs(t => t == typeof(TimeoutMessage));
//NServiceBus.Configure.Instance.DefiningSystemMessagesAs(t => typeof(ITimeoutState).IsAssignableFrom(t));
return new Configure { configurer = configurer };
}
/// <summary>
/// Lets you inject your services into dependency injection <see cref="IContainer"/>
/// </summary>
/// <param name="componentsConfigurator"></param>
/// <returns></returns>
public Configure With(IConfigureComponents componentsConfigurator)
{
Helper.GuardNotNull(componentsConfigurator);
_configurators.Add(componentsConfigurator);
return this;
}
public BuilderDependencyScope( IBuilder scopedBuilder, IConfigureComponents configurer )
{
this.scopedBuilder = scopedBuilder;
this.configurer = configurer;
}
public static StartableEndpointWithExternallyManagedContainer CreateWithExternallyManagedContainer(EndpointConfiguration endpointConfiguration, IConfigureComponents configureComponents)
{
FinalizeConfiguration(endpointConfiguration);
endpointConfiguration.ContainerComponent.InitializeWithExternallyManagedContainer(configureComponents);
var creator = new EndpointCreator(endpointConfiguration.Settings, endpointConfiguration.ContainerComponent, endpointConfiguration.PipelineComponent);
creator.Initialize();
return(new StartableEndpointWithExternallyManagedContainer(creator));
}
public void RegisterStartupTasks(IConfigureComponents container)
{
foreach (var feature in features.Where(f => f.Feature.IsActive))
{
foreach (var taskType in feature.Feature.StartupTasks)
{
container.ConfigureComponent(taskType, DependencyLifecycle.SingleInstance);
}
}
}
public NServiceBusWebApiDependencyResolverAdapter(IBuilder container, IConfigureComponents configurer)
: base(container, configurer)
{
}
public NServiceBusSignalRDependencyResolverAdapter(IBuilder builder, IConfigureComponents configurer)
{
_builder = builder;
_configurer = configurer;
}
public BuilderDependencyResolver( IBuilder builder, IConfigureComponents configurer )
{
this.builder = builder;
this.configurer = configurer;
}
public NServiceBusWebApiDependencyScopeAdapter(IBuilder builder, IConfigureComponents configurer)
{
Configurer = configurer;
Builder = builder;
}
/// <summary>
/// Starts the configuration process for the saga infrastructure.
/// </summary>
/// <param name="configurer"></param>
/// <param name="builder"></param>
/// <returns></returns>
public static Configure With(IConfigureComponents configurer, IBuilder builder)
{
configurer.ConfigureComponent<ReplyingToNullOriginatorDispatcher>(DependencyLifecycle.SingleInstance);
configurer.ConfigureComponent<SagaIdEnricher>(DependencyLifecycle.InstancePerCall);
return new Configure { configurer = configurer };
}
static void RegisterInheritanceHierarchyOfContextOnContainer(RunDescriptor runDescriptor, IConfigureComponents r)
{
var type = runDescriptor.ScenarioContext.GetType();
while (type != typeof(object))
{
r.RegisterSingleton(type, runDescriptor.ScenarioContext);
type = type.BaseType;
}
}
bool ActivateFeature(FeatureInfo featureInfo, List<FeatureInfo> featuresToActivate, IConfigureComponents container, PipelineSettings pipelineSettings)
{
if (featureInfo.Feature.IsActive)
{
return true;
}
Func<List<string>, bool> dependencyActivator = dependencies =>
{
var dependantFeaturesToActivate = new List<FeatureInfo>();
foreach (var dependency in dependencies.Select(dependencyName => featuresToActivate
.SingleOrDefault(f => f.Feature.Name == dependencyName))
.Where(dependency => dependency != null))
{
dependantFeaturesToActivate.Add(dependency);
}
return dependantFeaturesToActivate.Aggregate(false, (current, f) => current | ActivateFeature(f, featuresToActivate, container, pipelineSettings));
};
var featureType = featureInfo.Feature.GetType();
if (featureInfo.Feature.Dependencies.All(dependencyActivator))
{
featureInfo.Diagnostics.DependenciesAreMet = true;
var context = new FeatureConfigurationContext(settings, container, pipelineSettings);
if (!HasAllPrerequisitesSatisfied(featureInfo.Feature, featureInfo.Diagnostics, context))
{
settings.MarkFeatureAsDeactivated(featureType);
return false;
}
settings.MarkFeatureAsActive(featureType);
featureInfo.Feature.SetupFeature(context);
featureInfo.TaskControllers = context.TaskControllers;
featureInfo.Diagnostics.StartupTasks = context.TaskControllers.Select(d => d.Name).ToList();
featureInfo.Diagnostics.Active = true;
return true;
}
settings.MarkFeatureAsDeactivated(featureType);
featureInfo.Diagnostics.DependenciesAreMet = false;
return false;
}
