/**
* Builds the container.
*
* @param containerizer the {@link Containerizer} that configures how to containerize
* @return the built container
* @throws IOException if an I/O exception occurs
* @throws CacheDirectoryCreationException if a directory to be used for the cache could not be
* created
* @throws HttpHostConnectException if fib failed to connect to a registry
* @throws RegistryUnauthorizedException if a registry request is unauthorized and needs
* authentication
* @throws RegistryAuthenticationFailedException if registry authentication failed
* @throws UnknownHostException if the registry does not exist
* @throws InsecureRegistryException if a server could not be verified due to an insecure
* connection
* @throws RegistryException if some other error occurred while interacting with a registry
* @throws ExecutionException if some other exception occurred during execution
* @throws InterruptedException if the execution was interrupted
*/
public async Task <FibContainer> ContainerizeAsync(IContainerizer containerizer)
{
containerizer = containerizer ?? throw new ArgumentNullException(nameof(containerizer));
BuildConfiguration buildConfiguration = ToBuildConfiguration(containerizer);
IEventHandlers eventHandlers = buildConfiguration.GetEventHandlers();
LogSources(eventHandlers);
using (new TimerEventDispatcher(eventHandlers, containerizer.GetDescription()))
{
try
{
IBuildResult result = await containerizer.CreateStepsRunner(buildConfiguration).RunAsync().ConfigureAwait(false);
return(new FibContainer(result.GetImageDigest(), result.GetImageId()));
}
catch (Exception ex)
{
eventHandlers.Dispatch(LogEvent.Error(ex.Message));
// If an ExecutionException occurs, re-throw the cause to be more easily handled by the user
if (ex.InnerException is RegistryException)
{
throw (RegistryException)ex.InnerException;
}
throw;
}
}
}
private IContainerizer CreateMockContainerizer()
{
ImageReference targetImage = ImageReference.Parse("target-image");
IContainerizer mockContainerizer = Mock.Of <IContainerizer>();
IStepsRunner stepsRunner = Mock.Of <IStepsRunner>();
IBuildResult mockBuildResult = Mock.Of <IBuildResult>();
Mock.Get(mockContainerizer).Setup(m => m.GetImageConfiguration()).Returns(ImageConfiguration.CreateBuilder(targetImage).Build());
Mock.Get(mockContainerizer).Setup(m => m.CreateStepsRunner(It.IsAny <BuildConfiguration>())).Returns(stepsRunner);
Mock.Get(stepsRunner).Setup(s => s.RunAsync()).Returns(Task.FromResult(mockBuildResult));
Mock.Get(mockBuildResult).Setup(m => m.GetImageDigest()).Returns(
DescriptorDigest.FromHash(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
Mock.Get(mockBuildResult).Setup(m => m.GetImageId()).Returns(
DescriptorDigest.FromHash(
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"));
Mock.Get(mockContainerizer).Setup(m => m.GetAdditionalTags()).Returns(new HashSet <string>());
Mock.Get(mockContainerizer).Setup(m => m.GetBaseImageLayersCacheDirectory()).Returns(Paths.Get("/"));
Mock.Get(mockContainerizer).Setup(m => m.GetApplicationLayersCacheDirectory()).Returns(Paths.Get("/"));
Mock.Get(mockContainerizer).Setup(m => m.GetAllowInsecureRegistries()).Returns(false);
Mock.Get(mockContainerizer).Setup(m => m.GetToolName()).Returns("mocktool");
Mock.Get(mockContainerizer).Setup(m => m.BuildEventHandlers()).Returns(EventHandlers.NONE);
return(mockContainerizer);
}
public IContainerizer ConfigureContainerizer(IContainerizer containerizer)
{
containerizer = containerizer ?? throw new ArgumentNullException(nameof(containerizer));
containerizer.WithAdditionalTags(TargetTags ?? Enumerable.Empty <string>())
.SetAllowInsecureRegistries(AllowInsecureRegistries)
.SetOfflineMode(OfflineMode)
.SetApplicationLayersCache(ApplicationLayersCacheDirectory)
.SetBaseImageLayersCache(BaseLayersCacheDirectory);
return(containerizer);
}
public async Task TestContainerize_configuredExecutorAsync()
{
FibContainerBuilder fibContainerBuilder =
new FibContainerBuilder(RegistryImage.Named("base/image"), buildConfigurationBuilder)
.SetEntrypoint(new[] { "entry", "point" })
.SetEnvironment(ImmutableDic.Of("name", "value"))
.SetExposedPorts(ImmutableHashSet.Create(Port.Tcp(1234), Port.Udp(5678)))
.SetLabels(ImmutableDic.Of("key", "value"))
.SetProgramArguments(new[] { "program", "arguments" })
.SetCreationTime(DateTimeOffset.FromUnixTimeMilliseconds(1000))
.SetUser("user")
.SetWorkingDirectory(AbsoluteUnixPath.Get("/working/directory"));
IContainerizer mockContainerizer = CreateMockContainerizer();
await fibContainerBuilder.ContainerizeAsync(mockContainerizer).ConfigureAwait(false);
}
/**
* Builds a {@link BuildConfiguration} using this and a {@link Containerizer}.
*
* @param containerizer the {@link Containerizer}
* @param executorService the {@link ExecutorService} to use, overriding the executor in the
* {@link Containerizer}
* @return the {@link BuildConfiguration}
* @throws CacheDirectoryCreationException if a cache directory could not be created
* @throws IOException if an I/O exception occurs
*/
public BuildConfiguration ToBuildConfiguration(
IContainerizer containerizer)
{
containerizer = containerizer ?? throw new ArgumentNullException(nameof(containerizer));
return(buildConfigurationBuilder
.SetTargetImageConfiguration(containerizer.GetImageConfiguration())
.SetAdditionalTargetImageTags(containerizer.GetAdditionalTags())
.SetBaseImageLayersCacheDirectory(SystemPath.From(containerizer.GetBaseImageLayersCacheDirectory()))
.SetApplicationLayersCacheDirectory(SystemPath.From(containerizer.GetApplicationLayersCacheDirectory()))
.SetContainerConfiguration(containerConfigurationBuilder.Build())
.SetLayerConfigurations(layerConfigurations)
.SetAllowInsecureRegistries(containerizer.GetAllowInsecureRegistries())
.SetOffline(containerizer.IsOfflineMode())
.SetToolName(containerizer.GetToolName())
.SetEventHandlers(containerizer.BuildEventHandlers())
.Build());
}
public void TestToBuildConfiguration()
{
RegistryImage targetImage =
RegistryImage.Named(ImageReference.Of("gcr.io", "my-project/my-app", null))
.AddCredential("username", "password");
IContainerizer containerizer =
Containerizer.To(targetImage)
.SetBaseImageLayersCache(Paths.Get("base/image/layers"))
.SetApplicationLayersCache(Paths.Get("application/layers"))
.AddEventHandler(mockFibEventConsumer);
RegistryImage baseImage =
RegistryImage.Named("base/image").AddCredentialRetriever(mockCredentialRetriever);
FibContainerBuilder fibContainerBuilder =
new FibContainerBuilder(baseImage, buildConfigurationBuilder)
.SetLayers(new[] { mockLayerConfiguration1, mockLayerConfiguration2 });
BuildConfiguration buildConfiguration =
fibContainerBuilder.ToBuildConfiguration(
containerizer);
Assert.AreEqual(
buildConfigurationBuilder.Build().GetContainerConfiguration(),
buildConfiguration.GetContainerConfiguration());
Assert.AreEqual(
"base/image", buildConfiguration.GetBaseImageConfiguration().GetImage().ToString());
Assert.AreEqual(
new[] { mockCredentialRetriever },
buildConfiguration.GetBaseImageConfiguration().GetCredentialRetrievers());
Assert.AreEqual(
"gcr.io/my-project/my-app",
buildConfiguration.GetTargetImageConfiguration().GetImage().ToString());
Assert.AreEqual(
1, buildConfiguration.GetTargetImageConfiguration().GetCredentialRetrievers().Length);
Assert.AreEqual(
Credential.From("username", "password"),
buildConfiguration
.GetTargetImageConfiguration()
.GetCredentialRetrievers()
[0]
.Retrieve()
.OrElseThrow(() => new AssertionException("")));
Assert.AreEqual(ImmutableHashSet.Create("latest"), buildConfiguration.GetAllTargetImageTags());
Assert.AreEqual(
new[] { mockLayerConfiguration1, mockLayerConfiguration2 },
buildConfiguration.GetLayerConfigurations());
buildConfiguration.GetEventHandlers().Dispatch(mockFibEvent);
Mock.Get(mockFibEventConsumer).Verify(m => m(mockFibEvent));
Assert.AreEqual("fibdotnet-core", buildConfiguration.GetToolName());
Assert.AreEqual(ManifestFormat.V22, buildConfiguration.GetTargetFormat());
Assert.AreEqual("fibdotnet-core", buildConfiguration.GetToolName());
// Changes fibContainerBuilder.
buildConfiguration =
fibContainerBuilder
.SetFormat(ImageFormat.OCI)
.ToBuildConfiguration(
containerizer
.WithAdditionalTag("tag1")
.WithAdditionalTag("tag2")
.SetToolName("toolName"));
Assert.AreEqual(ManifestFormat.OCI, buildConfiguration.GetTargetFormat());
Assert.AreEqual(
ImmutableHashSet.Create("latest", "tag1", "tag2"), buildConfiguration.GetAllTargetImageTags());
Assert.AreEqual("toolName", buildConfiguration.GetToolName());
}
