/** * 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()); }