public static IContainer Create(Assembly[] assemblies, IContainerConfiguration configuration)
{
Contract.Requires(assemblies != null);
var builder = new ContainerBuilder();
builder.Configure(configuration);
builder.RegisterAssemblyTypes(assemblies);
return builder.Build();
}
public void ProcessType(IContainerConfiguration container, TypeInfo type)
{
var serviceTypes = from serviceType in type.ImplementedInterfaces
where serviceType.IsConstructedGenericType
select serviceType;
foreach (var serviceType in serviceTypes)
{
ProcessType(container, type, serviceType);
}
}
public static ContainerBuilder Configure(this ContainerBuilder builder, IContainerConfiguration configuration)
{
Contract.Requires(builder != null);
if (configuration != null)
{ // we have a configuration, so do something
if(configuration.ResolveAnything)
builder.RegisterSource(new ResolveAnythingSource());
}
return builder;
}
public HttpClient(IContainerConfiguration containerConfiguration)
{
var registry = containerConfiguration.InitializeContainer();
ObjectFactory.Initialize(
x => x.AddRegistry(registry));
_codec = ObjectFactory.GetInstance<ICodec>();
_log = ObjectFactory.TryGetInstance<ILog>();
Request = new HttpRequest(_codec);
}
public static IContainer Create(IModule[] modules, IContainerConfiguration configuration)
{
Contract.Requires(modules != null);
Contract.Requires(modules.Length > 0);
Contract.Requires(Contract.ForAll(modules, m => m != null));
var builder = new ContainerBuilder();
builder.Configure(configuration);
foreach (var module in modules)
{
builder.RegisterModule(module);
}
return builder.Build();
}
private static void ProcessType(IContainerConfiguration container, TypeInfo concreteType, Type serviceType)
{
var typeDefinition = serviceType.GetGenericTypeDefinition();
if (HandlerTypeDefinitions.Any(h => h == typeDefinition))
{
var serviceScope =
concreteType.GetServiceScope() ??
ServiceScope.Default;
container.
Register(serviceType).
InScope(serviceScope).
UsingConcreteType(concreteType.AsType());
}
}
public void ProcessType(IContainerConfiguration container, TypeInfo type)
{
var settingsAttribute = type.GetCustomAttribute<SettingsAttribute>();
if (settingsAttribute != null)
{
var settingsType = type.AsType();
var settingsScope = settingsAttribute.Scope;
var activatorConfiguration = new SettingsActivatorConfiguration(settingsScope, settingsType);
container.Register(activatorConfiguration);
}
foreach (var serviceType in type.ImplementedInterfaces)
{
ProcessServiceType(container, type, serviceType);
}
}
private static void ProcessServiceType(IContainerConfiguration container, TypeInfo concreteType, Type serviceType)
{
if (serviceType.IsConstructedGenericType)
{
var typeDefinition = serviceType.GetGenericTypeDefinition();
if (typeDefinition == SettingsHandlerTypeDefinition)
{
var serviceScope =
concreteType.GetServiceScope() ??
ServiceScope.Default;
container.
Register(serviceType).
InScope(serviceScope).
UsingConcreteType(concreteType.AsType());
}
}
}
public HttpClient(IContainerConfiguration containerConfiguration)
{
var registry = containerConfiguration.InitializeContainer();
ObjectFactory.Initialize(x => x.AddRegistry(registry));
_encoder = ObjectFactory.GetInstance<IEncoder>();
_decoderFactory = ObjectFactory.GetInstance<IDecoderFactory>();
Request = new HttpRequest(_encoder);
}
public NyxApplicationConfiguration(Application app, IViewResolver viewResolver, IContainerConfiguration containerConfiguration)
: base(viewResolver, containerConfiguration)
{
_app = app;
}
public InternalContainer(IContainerConfiguration configuration, IClassWrapperCreator classWrapperCreator)
: this(new ContainerContext(configuration, classWrapperCreator))
{
}
public static void Register(this IUnityContainer container, IContainerConfiguration configuration)
{
configuration.Register(container);
}
public async Task <Image> CallAsync()
{
BaseImageWithAuthorization baseImageWithAuthorization = await pullBaseImageStep.GetFuture().ConfigureAwait(false);
IReadOnlyList <ICachedLayer> baseImageLayers = await pullAndCacheBaseImageLayersStep.GetFuture().ConfigureAwait(false);
IReadOnlyList <ICachedLayer> applicationLayers = await buildAndCacheApplicationLayersStep.GetFuture().ConfigureAwait(false);
using (var ignored = progressEventDispatcherFactory.Create("building image format", this.Index))
using (new TimerEventDispatcher(buildConfiguration.GetEventHandlers(), DESCRIPTION))
{
// Constructs the image.
Image.Builder imageBuilder = Image.CreateBuilder(buildConfiguration.GetTargetFormat());
Image baseImage = baseImageWithAuthorization.GetBaseImage();
IContainerConfiguration containerConfiguration =
buildConfiguration.GetContainerConfiguration();
// Base image layers
foreach (ICachedLayer pullAndCacheBaseImageLayer in baseImageLayers)
{
imageBuilder.AddLayer(pullAndCacheBaseImageLayer);
}
// Passthrough config and count non-empty history entries
int nonEmptyLayerCount = 0;
foreach (HistoryEntry historyObject in baseImage.GetHistory())
{
imageBuilder.AddHistory(historyObject);
if (!historyObject.HasCorrespondingLayer())
{
nonEmptyLayerCount++;
}
}
imageBuilder
.SetArchitecture(baseImage.GetArchitecture())
.SetOs(baseImage.GetOs())
.AddEnvironment(baseImage.GetEnvironment())
.AddLabels(baseImage.GetLabels())
.SetHealthCheck(baseImage.GetHealthCheck())
.AddExposedPorts(baseImage.GetExposedPorts())
.AddVolumes(baseImage.GetVolumes())
.SetWorkingDirectory(baseImage.GetWorkingDirectory());
// Add history elements for non-empty layers that don't have one yet
Instant layerCreationTime =
containerConfiguration == null
? ContainerConfiguration.DefaultCreationTime
: containerConfiguration.GetCreationTime();
for (int count = 0; count < baseImageLayers.Count - nonEmptyLayerCount; count++)
{
imageBuilder.AddHistory(
HistoryEntry.CreateBuilder()
.SetCreationTimestamp(layerCreationTime)
.SetComment("auto-generated by Fib")
.Build());
}
// Add built layers/configuration
foreach (ICachedLayer applicationLayer in applicationLayers)
{
HistoryEntry.Builder historyBuilder = HistoryEntry.CreateBuilder();
if (buildConfiguration.GetToolName() != null)
{
historyBuilder.SetCreatedBy(buildConfiguration.GetToolName() + ":" + (buildConfiguration.GetToolVersion() ?? "null"));
}
else
{
historyBuilder.SetCreatedBy(ProjectInfo.TOOL_NAME + ":" + ProjectInfo.VERSION);
}
imageBuilder
.AddLayer(applicationLayer)
.AddHistory(
historyBuilder
.SetCreationTimestamp(layerCreationTime)
.SetAuthor("Fib")
.SetComment(applicationLayer.GetLayerType())
.Build());
}
if (containerConfiguration != null)
{
imageBuilder
.AddEnvironment(containerConfiguration.GetEnvironmentMap())
.SetCreated(containerConfiguration.GetCreationTime())
.SetUser(containerConfiguration.GetUser())
.SetEntrypoint(ComputeEntrypoint(baseImage, containerConfiguration))
.SetProgramArguments(ComputeProgramArguments(baseImage, containerConfiguration))
.AddExposedPorts(containerConfiguration.GetExposedPorts())
.AddVolumes(containerConfiguration.GetVolumes())
.AddLabels(containerConfiguration.GetLabels());
if (containerConfiguration.GetWorkingDirectory() != null)
{
imageBuilder.SetWorkingDirectory(containerConfiguration.GetWorkingDirectory().ToString());
}
}
// Gets the container configuration content descriptor.
return(imageBuilder.Build());
}
}
/// <summary>
/// Adds the container.
/// </summary>
/// <param name="containerConfiguration">The container configuration.</param>
/// <returns>The builder.</returns>
public IAutofacBootBuilder WithContainer(IContainerConfiguration containerConfiguration)
{
return(new AutofacBootBuilder(containerConfiguration));
}
