/// <inheritdoc/>
public void Perform(DiscoverySettings settings, IBootStageBuilder builder)
{
var entryAssembly = builder.GetAssociation(WellKnownAssociations.EntryAssembly) as Assembly;
var loggerManager = builder.GetAssociation(WellKnownAssociations.LoggerManager) as ILoggerManager;
var logger = loggerManager.CreateLogger <Discovery>();
var scheduler = builder.GetAssociation(WellKnownAssociations.Scheduler) as IScheduler;
logger.Debug(" Discovery");
var assemblies = Assemblies.Bootstrap.Boot.Start(logger, entryAssembly, settings.AssemblyProvider, _ =>
{
if (settings.IncludeAssembliesStartWith?.Count() > 0)
{
settings.IncludeAssembliesStartWith.ForEach(name => logger.Trace("Including assemblies starting with '{name}'", name));
_.ExceptAssembliesStartingWith(settings.IncludeAssembliesStartWith.ToArray());
}
});
logger.Debug(" Set up type system for discovery");
var typeFinder = Types.Bootstrap.Boot.Start(assemblies, scheduler, logger, entryAssembly);
logger.Debug(" Type system ready");
builder.Bindings.Bind <IAssemblies>().To(assemblies);
builder.Bindings.Bind <ITypeFinder>().To(typeFinder);
builder.Associate(WellKnownAssociations.Assemblies, assemblies);
builder.Associate(WellKnownAssociations.TypeFinder, typeFinder);
}
/// <inheritdoc/>
public void Perform(NoSettings settings, IBootStageBuilder builder)
{
var typeFinder = builder.GetAssociation(WellKnownAssociations.TypeFinder) as ITypeFinder;
var parsers = new ConfigurationFileParsers(typeFinder, builder.Container);
builder.Bindings.Bind <IConfigurationFileParsers>().To(parsers);
}
/// <inheritdoc/>
public void Perform(LoggingSettings settings, IBootStageBuilder builder)
{
var entryAssembly = builder.GetAssociation(WellKnownAssociations.EntryAssembly) as Assembly;
var environment = builder.GetAssociation(WellKnownAssociations.Environment) as Environment;
_initialExecutionContext = ExecutionContextManager.SetInitialExecutionContext();
#pragma warning disable CA2000
var loggerFactory = settings.LoggerFactory ?? new LoggerFactory();
#pragma warning restore CA2000
_isProduction = environment == Environment.Production;
var logAppender = settings.LogAppender;
if (logAppender == null)
{
logAppender = (_isProduction && !settings.UseDefaultInAllEnvironments) ?
new JsonLogAppender(GetCurrentLoggingContext) :
new DefaultLogAppender(GetCurrentLoggingContext, loggerFactory) as ILogAppender;
}
var logAppenders = Dolittle.Logging.Bootstrap.Boot.Start(logAppender, entryAssembly);
Dolittle.Logging.ILogger logger = settings.Logger ?? new Logger(logAppenders);
logger.Information($"<********* BOOTSTAGE : Logging *********>");
builder.Associate(WellKnownAssociations.Logger, logger);
_executionContextManager = new ExecutionContextManager(logger);
builder.Bindings.Bind <Dolittle.Logging.ILogger>().To(logger);
builder.Bindings.Bind <ILoggerFactory>().To(loggerFactory);
builder.Bindings.Bind <IExecutionContextManager>().To(_executionContextManager);
}
/// <inheritdoc/>
public void Perform(ContainerSettings settings, IBootStageBuilder builder)
{
IBindingCollection resultingBindings;
var loggerManager = builder.GetAssociation(WellKnownAssociations.LoggerManager) as ILoggerManager;
var logger = loggerManager.CreateLogger <Container>();
var typeFinder = builder.GetAssociation(WellKnownAssociations.TypeFinder) as ITypeFinder;
var scheduler = builder.GetAssociation(WellKnownAssociations.Scheduler) as IScheduler;
var bindings = builder.GetAssociation(WellKnownAssociations.Bindings) as IBindingCollection;
var assemblies = builder.GetAssociation(WellKnownAssociations.Assemblies) as IAssemblies;
var fileSystem = new FileSystem();
if (settings.ContainerType != null)
{
logger.Trace("Starting DependencyInversion with predefined container type '{containerType}'", settings.ContainerType.AssemblyQualifiedName);
resultingBindings = Boot.Start(assemblies, typeFinder, scheduler, fileSystem, loggerManager, settings.ContainerType, bindings, builder.Container as BootContainer);
}
else
{
var bootResult = Boot.Start(assemblies, typeFinder, scheduler, fileSystem, loggerManager, bindings, builder.Container as BootContainer);
resultingBindings = bootResult.Bindings;
builder.UseContainer(bootResult.Container);
logger.Trace("Using container of type '{containerType}'", builder.Container.GetType().AssemblyQualifiedName);
}
builder.Associate(WellKnownAssociations.Bindings, resultingBindings);
}
/// <inheritdoc/>
public void Perform(BootProceduresSettings settings, IBootStageBuilder builder)
{
if (settings.Enabled)
{
builder.Container.Get <IBootProcedures>().Perform();
}
}
/// <inheritdoc/>
public void Perform(NoSettings settings, IBootStageBuilder builder)
{
var bindings = builder.GetAssociation(WellKnownAssociations.Bindings) as IBindingCollection;
var newBindingsNotifier = builder.GetAssociation(WellKnownAssociations.NewBindingsNotificationHub) as ICanNotifyForNewBindings;
var bootContainer = new BootContainer(bindings, newBindingsNotifier);
builder.UseContainer(bootContainer);
}
public void Perform(NoSettings settings, IBootStageBuilder builder)
{
var artifactTypeMap = builder.Container.Get <IArtifactTypeMap>();
artifactTypeMap.Register(new Artifact(Guid.Parse("ac14f174-572e-4c07-8cd1-e4e8ecc0fea9"), 1), typeof(MyAggregate));
artifactTypeMap.Register(new Artifact(Guid.Parse("bc26f986-5515-4506-9944-cd7e93bec7fe"), 1), typeof(MyEvent));
artifactTypeMap.Register(new Artifact(Guid.Parse("2626352e-41d2-4d40-b3dd-e8efdee9bcac"), 1), typeof(MySecondEvent));
artifactTypeMap.Register(new Artifact(Guid.Parse("522c007d-9498-4aa2-a9ee-f43e8d5aec2a"), 1), typeof(MyCommand));
}
/// <inheritdoc/>
public void Perform(BootProceduresSettings settings, IBootStageBuilder builder)
{
if( settings.Enabled )
{
var logger = builder.GetAssociation(WellKnownAssociations.Logger) as ILogger;
var typeFinder = builder.GetAssociation(WellKnownAssociations.TypeFinder) as ITypeFinder;
builder.Container.Get<IBootProcedures>().Perform();
}
}
/// <inheritdoc/>
public void Perform(BasicsSettings settings, IBootStageBuilder builder)
{
var entryAssembly = settings.EntryAssembly ?? Assembly.GetEntryAssembly();
var environment = settings.Environment ?? Environment.Production;
builder.Associate(WellKnownAssociations.EntryAssembly, entryAssembly);
builder.Associate(WellKnownAssociations.Environment, environment);
builder.Bindings.Bind <Environment>().To(environment);
}
/// <inheritdoc/>
public void Perform(InitialSystemSettings settings, IBootStageBuilder builder)
{
var scheduler = settings.Scheduler ?? new AsyncScheduler();
builder.Associate(WellKnownAssociations.Scheduler, scheduler);
builder.Bindings.Bind <ISystemClock>().To(settings.SystemClock ?? new SystemClock());;
builder.Bindings.Bind <IFileSystem>().To(settings.FileSystem ?? new FileSystem());
builder.Bindings.Bind <IScheduler>().To(scheduler);
}
/// <inheritdoc/>
public void Perform(NoSettings settings, IBootStageBuilder builder)
{
var file = Path.Combine(".dolittle", "server.json");
if (File.Exists(file))
{
var json = File.ReadAllText(file);
var configuration = JsonConvert.DeserializeObject <ServerConfiguration>(json);
EndpointConfigurationDefaultProvider.DefaultPublicPort = configuration.Interaction.Port;
}
}
/// <inheritdoc/>
public void Perform(NoSettings settings, IBootStageBuilder builder)
{
if (IoTEdgeHelpers.IsRunningInIotEdge())
{
var logger = builder.GetAssociation(WellKnownAssociations.Logger) as ILogger;
ModuleClient client = null;
ModuleClient.CreateFromEnvironmentAsync(TransportType.Mqtt)
.ContinueWith(_ => client = _.Result)
.Wait();
logger.Information("Open IoT Edge ModuleClient and wait");
client.OpenAsync().Wait();
logger.Information("Client is ready");
builder.Bindings.Bind <ModuleClient>().To(client);
}
}
/// <inheritdoc/>
public void Perform(DiscoverySettings settings, IBootStageBuilder builder)
{
var entryAssembly = builder.GetAssociation(WellKnownAssociations.EntryAssembly) as Assembly;
var logger = builder.GetAssociation(WellKnownAssociations.Logger) as ILogger;
var scheduler = builder.GetAssociation(WellKnownAssociations.Scheduler) as IScheduler;
logger.Information(" Discover all assemblies");
var assemblies = Dolittle.Assemblies.Bootstrap.Boot.Start(logger, entryAssembly, settings.AssemblyProvider);
logger.Information(" Set up type system for discovery");
var typeFinder = Dolittle.Types.Bootstrap.Boot.Start(assemblies, scheduler, logger, entryAssembly);
logger.Information(" Type system ready");
builder.Bindings.Bind <IAssemblies>().To(assemblies);
builder.Bindings.Bind <ITypeFinder>().To(typeFinder);
builder.Associate(WellKnownAssociations.Assemblies, assemblies);
builder.Associate(WellKnownAssociations.TypeFinder, typeFinder);
}
/// <inheritdoc/>
public void Perform(NoSettings settings, IBootStageBuilder builder)
{
var typeFinder = builder.GetAssociation(WellKnownAssociations.TypeFinder) as ITypeFinder;
var logger = builder.GetAssociation(WellKnownAssociations.Logger) as ILogger;
var configurationObjectProviders = new ConfigurationObjectProviders(typeFinder, builder.Container, logger);
builder.Bindings.Bind<IConfigurationObjectProviders>().To(configurationObjectProviders);
var configurationObjectTypes = typeFinder.FindMultiple<IConfigurationObject>();
configurationObjectTypes.ForEach((System.Action<System.Type>)(_ =>
{
logger.Trace((string)$"Bind configuration object '{_.GetFriendlyConfigurationName()} - {_.AssemblyQualifiedName}'");
_.ShouldBeImmutable();
builder.Bindings.Bind(_).To((System.Func<object>)(() => {
var instance = configurationObjectProviders.Provide(_);
logger.Trace((string)$"Providing configuration object '{_.GetFriendlyConfigurationName()} - {_.AssemblyQualifiedName}' - {instance.GetHashCode()}");
return instance;
}));
}));
}
/// <inheritdoc/>
public void Perform(NoSettings settings, IBootStageBuilder builder)
{
var typeFinder = builder.GetAssociation(WellKnownAssociations.TypeFinder) as ITypeFinder;
var loggerManager = builder.GetAssociation(WellKnownAssociations.LoggerManager) as ILoggerManager;
var logger = loggerManager.CreateLogger <Configuration>();
var configurationObjectProviders = new ConfigurationObjectProviders(typeFinder, builder.Container, logger);
builder.Bindings.Bind <IConfigurationObjectProviders>().To(configurationObjectProviders);
var configurationObjectTypes = typeFinder.FindMultiple <IConfigurationObject>();
configurationObjectTypes.ForEach(_ =>
{
logger.Trace("Bind configuration object '{configurationObjectName} - {configurationObjectType}'", _.GetFriendlyConfigurationName(), _.AssemblyQualifiedName);
_.ShouldBeImmutable();
builder.Bindings.Bind(_).To(() =>
{
var instance = configurationObjectProviders.Provide(_);
logger.Trace("Providing configuration object '{configurationObjectName} - {configurationTypeName}' - {configurationObjectHash}", _.GetFriendlyConfigurationName(), _.AssemblyQualifiedName, instance.GetHashCode());
return(instance);
});
});
}
/// <inheritdoc/>
public void Perform(LoggingSettings settings, IBootStageBuilder builder)
{
var loggerManager = settings.DisableLogging ? NullLoggerManager.Instance : LoggerManager.Instance;
if (settings.LogMessageWriterCreators != null)
{
loggerManager.AddLogMessageWriterCreators(settings.LogMessageWriterCreators.ToArray());
}
builder.Associate(WellKnownAssociations.LoggerManager, loggerManager);
builder.Bindings.Bind <ILoggerManager>().To(loggerManager);
builder.Bindings.Bind(typeof(ILogger <>)).To(context => loggerManager.CreateLogger(context.Service.GetGenericArguments()[0]));
builder.Bindings.Bind <ILogger>().To(() => loggerManager.CreateLogger <UnknownLogMessageSource>());
var logger = loggerManager.CreateLogger <Logging>();
logger.Debug("<********* BOOTSTAGE : Logging *********>");
var executionContextLogger = loggerManager.CreateLogger <ExecutionContextManager>();
ExecutionContextManager.SetInitialExecutionContext(executionContextLogger);
builder.Bindings.Bind <IExecutionContextManager>().To(new ExecutionContextManager(executionContextLogger));
}
/// <inheritdoc/>
public void Perform(ContainerSettings settings, IBootStageBuilder builder)
{
var bindings = builder.GetAssociation(WellKnownAssociations.Bindings) as IBindingCollection;
AllBindings = new BindingCollection(bindings.ToArray());
}
/// <inheritdoc/>
public void Perform(DiscoverySettings settings, IBootStageBuilder builder)
{
var typeFinder = builder.GetAssociation(WellKnownAssociations.TypeFinder) as ITypeFinder;
_callback(typeFinder);
}
