Exemplo n.º 1
0
        /**
         * Gets a new {@link Containerizer} that containerizes to a Docker daemon.
         *
         * @param dockerDaemonImage the {@link DockerDaemonImage} that defines target Docker daemon
         * @return a new {@link Containerizer}
         */
        public static Containerizer To(DockerDaemonImage dockerDaemonImage)
        {
            dockerDaemonImage = dockerDaemonImage ?? throw new ArgumentNullException(nameof(dockerDaemonImage));
            ImageConfiguration imageConfiguration =
                ImageConfiguration.CreateBuilder(dockerDaemonImage.GetImageReference())
                .SetCredentialRetrievers(new List <CredentialRetriever> {
                () => Maybe.Of(dockerDaemonImage.Credential)
            })
                .Build();

            DockerClient.Builder dockerClientBuilder = DockerClient.CreateBuilder();
            dockerDaemonImage.GetDockerExecutable().IfPresent(dockerClientBuilder.SetDockerExecutable);
            dockerClientBuilder.SetDockerEnvironment(ImmutableDictionary.CreateRange(dockerDaemonImage.GetDockerEnvironment()));

            return(new Containerizer(
                       DescriptionForDockerDaemon, imageConfiguration, StepsRunnerFactory, false));

            StepsRunner StepsRunnerFactory(BuildConfiguration buildConfiguration) =>
            StepsRunner.Begin(buildConfiguration)
            .PullBaseImage(1)
            .PullAndCacheBaseImageLayers(2)
            .BuildAndCacheApplicationLayers(3)
            .BuildImage(4)
            .LoadDocker(dockerClientBuilder.Build(), 5);
        }
Exemplo n.º 2
0
        //public FibContainerBuilder AddImageCredential(Credential credential)
        //{
        //    credential = credential ?? throw new ArgumentNullException(nameof(credential));


        //}


        public FibContainerBuilder(RegistryImage baseImage, BuildConfiguration.Builder buildConfigurationBuilder)
        {
            baseImage = baseImage ?? throw new ArgumentNullException(nameof(baseImage));
            this.buildConfigurationBuilder = buildConfigurationBuilder ??
                                             throw new ArgumentNullException(nameof(buildConfigurationBuilder));

            ImageConfiguration imageConfiguration =
                ImageConfiguration.CreateBuilder(baseImage.GetImageReference())
                .SetCredentialRetrievers(baseImage.GetCredentialRetrievers())
                .Build();

            buildConfigurationBuilder.SetBaseImageConfiguration(imageConfiguration);
        }
Exemplo n.º 3
0
        public void TestBuilder_missingValues()
        {
            // Target image is missing
            try
            {
                BuildConfiguration.CreateBuilder()
                .SetBaseImageConfiguration(
                    ImageConfiguration.CreateBuilder(Mock.Of <IImageReference>()).Build())
                .SetBaseImageLayersCacheDirectory(Paths.Get("ignored"))
                .SetApplicationLayersCacheDirectory(Paths.Get("ignored"))
                .Build();
                Assert.Fail("Build configuration should not be built with missing values");
            }
            catch (InvalidOperationException ex)
            {
                Assert.AreEqual("Required field is not set: target image configuration", ex.Message);
            }

            // Two required fields missing
            try
            {
                BuildConfiguration.CreateBuilder()
                .SetBaseImageLayersCacheDirectory(Paths.Get("ignored"))
                .SetApplicationLayersCacheDirectory(Paths.Get("ignored"))
                .Build();
                Assert.Fail("Build configuration should not be built with missing values");
            }
            catch (InvalidOperationException ex)
            {
                Assert.AreEqual(
                    "Required fields are not set: base image configuration, target image configuration",
                    ex.Message);
            }

            // All required fields missing
            try
            {
                BuildConfiguration.CreateBuilder().Build();
                Assert.Fail("Build configuration should not be built with missing values");
            }
            catch (InvalidOperationException ex)
            {
                Assert.AreEqual(
                    "Required fields are not set: " +
                    "base image configuration, " +
                    "target image configuration, " +
                    "base image layers cache directory, " +
                    "application layers cache directory",
                    ex.Message);
            }
        }
Exemplo n.º 4
0
        /**
         * Gets a new {@link Containerizer} that containerizes to a tarball archive.
         *
         * @param tarImage the {@link TarImage} that defines target output file
         * @return a new {@link Containerizer}
         */
        public static Containerizer To(TarImage tarImage)
        {
            tarImage = tarImage ?? throw new ArgumentNullException(nameof(tarImage));
            ImageConfiguration imageConfiguration =
                ImageConfiguration.CreateBuilder(tarImage.GetImageReference()).Build();

            return(new Containerizer(
                       DescriptionForImageTarFile, imageConfiguration, StepsRunnerFactory, false));

            StepsRunner StepsRunnerFactory(BuildConfiguration buildConfiguration) =>
            StepsRunner.Begin(buildConfiguration)
            .PullBaseImage()
            .PullAndCacheBaseImageLayers()
            .BuildAndCacheApplicationLayers()
            .BuildImage()
            .WriteTarFile(tarImage.GetOutputFile());
        }
Exemplo n.º 5
0
        public void TestBuilder_default()
        {
            // These are required and don't have defaults.
            const string expectedBaseImageServerUrl = "someserver";
            const string expectedBaseImageName      = "baseimage";
            const string expectedBaseImageTag       = "baseimagetag";
            const string expectedTargetServerUrl    = "someotherserver";
            const string expectedTargetImageName    = "targetimage";
            const string expectedTargetTag          = "targettag";

            ImageConfiguration baseImageConfiguration =
                ImageConfiguration.CreateBuilder(
                    ImageReference.Of(
                        expectedBaseImageServerUrl, expectedBaseImageName, expectedBaseImageTag))
                .Build();
            ImageConfiguration targetImageConfiguration =
                ImageConfiguration.CreateBuilder(
                    ImageReference.Of(
                        expectedTargetServerUrl, expectedTargetImageName, expectedTargetTag))
                .Build();

            BuildConfiguration.Builder buildConfigurationBuilder =
                BuildConfiguration.CreateBuilder()
                .SetBaseImageConfiguration(baseImageConfiguration)
                .SetTargetImageConfiguration(targetImageConfiguration)
                .SetBaseImageLayersCacheDirectory(Paths.Get("ignored"))
                .SetApplicationLayersCacheDirectory(Paths.Get("ignored"));
            BuildConfiguration buildConfiguration = buildConfigurationBuilder.Build();

            Assert.AreEqual(ImmutableHashSet.Create("targettag"), buildConfiguration.GetAllTargetImageTags());
            Assert.AreEqual(ManifestFormat.V22, buildConfiguration.GetTargetFormat());
            Assert.IsNotNull(buildConfigurationBuilder.GetApplicationLayersCacheDirectory());
            Assert.AreEqual(
                Paths.Get("ignored"), buildConfigurationBuilder.GetApplicationLayersCacheDirectory());
            Assert.IsNotNull(buildConfigurationBuilder.GetBaseImageLayersCacheDirectory());
            Assert.AreEqual(
                Paths.Get("ignored"), buildConfigurationBuilder.GetBaseImageLayersCacheDirectory());
            Assert.IsNull(buildConfiguration.GetContainerConfiguration());
            Assert.IsFalse(buildConfiguration.GetAllowInsecureRegistries());
            Assert.AreEqual(new List <LayerConfiguration>(), buildConfiguration.GetLayerConfigurations());
            Assert.AreEqual(null, buildConfiguration.GetToolName());
            Assert.AreEqual(null, buildConfiguration.GetToolVersion());
        }
Exemplo n.º 6
0
        /**
         * Gets a new {@link Containerizer} that containerizes to a container registry.
         *
         * @param registryImage the {@link RegistryImage} that defines target container registry and
         *     credentials
         * @return a new {@link Containerizer}
         */
        public static Containerizer To(RegistryImage registryImage)
        {
            registryImage = registryImage ?? throw new ArgumentNullException(nameof(registryImage));
            ImageConfiguration imageConfiguration =
                ImageConfiguration.CreateBuilder(registryImage.GetImageReference())
                .SetCredentialRetrievers(registryImage.GetCredentialRetrievers())
                .Build();

            return(new Containerizer(
                       DescriptionForDockerRegistry, imageConfiguration, StepsRunnerFactory, true));

            StepsRunner StepsRunnerFactory(BuildConfiguration buildConfiguration) =>
            StepsRunner.Begin(buildConfiguration)
            .RetrieveTargetRegistryCredentials()
            .AuthenticatePush()
            .PullBaseImage()
            .PullAndCacheBaseImageLayers()
            .PushBaseImageLayers()
            .BuildAndCacheApplicationLayers()
            .BuildImage()
            .PushContainerConfiguration()
            .PushApplicationLayers()
            .PushImage();
        }
Exemplo n.º 7
0
 public TestableCommand()
 {
     Containerizer = Mock.Of <IContainerizer>();
     Mock.Get(Containerizer).DefaultValueProvider = DefaultValueProvider.Mock;
     Mock.Get(Containerizer).Setup(c => c.WithAdditionalTags(It.IsAny <IEnumerable <string> >())).Returns(Containerizer);
     Mock.Get(Containerizer).Setup(c => c.SetAllowInsecureRegistries(It.IsAny <bool>())).Returns(Containerizer);
     Mock.Get(Containerizer).Setup(c => c.SetOfflineMode(It.IsAny <bool>())).Returns(Containerizer);
     Mock.Get(Containerizer).Setup(c => c.SetApplicationLayersCache(It.IsAny <string>())).Returns(Containerizer);
     Mock.Get(Containerizer).Setup(c => c.SetBaseImageLayersCache(It.IsAny <string>())).Returns(Containerizer);
     Mock.Get(Containerizer).Setup(c => c.GetApplicationLayersCacheDirectory()).Returns(TestContext.CurrentContext.WorkDirectory);
     Mock.Get(Containerizer).Setup(c => c.GetImageConfiguration()).Returns(() => ImageConfiguration.CreateBuilder(ImageReference).Build());
     Mock.Get(Containerizer).Setup(c => c.GetBaseImageLayersCacheDirectory()).Returns(TestContext.CurrentContext.WorkDirectory);
     Mock.Get(Containerizer).Setup(c => c.BuildEventHandlers()).Returns(new EventHandlers(ImmutableArray.Create <Action <IFibEvent> >()));
 }
Exemplo n.º 8
0
        public void TestBuilder()
        {
            const string  expectedBaseImageServerUrl         = "someserver";
            const string  expectedBaseImageName              = "baseimage";
            const string  expectedBaseImageTag               = "baseimagetag";
            const string  expectedTargetServerUrl            = "someotherserver";
            const string  expectedTargetImageName            = "targetimage";
            const string  expectedTargetTag                  = "targettag";
            ISet <string> additionalTargetImageTags          = ImmutableHashSet.Create("tag1", "tag2", "tag3");
            ISet <string> expectedTargetImageTags            = ImmutableHashSet.Create("targettag", "tag1", "tag2", "tag3");
            IList <CredentialRetriever> credentialRetrievers =
                new List <CredentialRetriever> {
                () => Maybe.Of(Credential.From("username", "password"))
            };
            Instant        expectedCreationTime                     = Instant.FromUnixTimeSeconds(10000);
            IList <string> expectedEntrypoint                       = new[] { "some", "entrypoint" };
            IList <string> expectedProgramArguments                 = new[] { "arg1", "arg2" };
            IDictionary <string, string> expectedEnvironment        = ImmutableDic.Of("key", "value");
            ImmutableHashSet <Port>      expectedExposedPorts       = ImmutableHashSet.Create(Port.Tcp(1000), Port.Tcp(2000));
            IDictionary <string, string> expectedLabels             = ImmutableDic.Of("key1", "value1", "key2", "value2");
            const ManifestFormat         expectedTargetFormat       = ManifestFormat.OCI;
            SystemPath expectedApplicationLayersCacheDirectory      = Paths.Get("application/layers");
            SystemPath expectedBaseImageLayersCacheDirectory        = Paths.Get("base/image/layers");
            IList <ILayerConfiguration> expectedLayerConfigurations =
                new List <ILayerConfiguration> {
                LayerConfiguration.CreateBuilder()
                .AddEntry(Paths.Get("sourceFile"), AbsoluteUnixPath.Get("/path/in/container"))
                .Build()
            };
            const string expectedCreatedBy = "createdBy";

            ImageConfiguration baseImageConfiguration =
                ImageConfiguration.CreateBuilder(
                    ImageReference.Of(
                        expectedBaseImageServerUrl, expectedBaseImageName, expectedBaseImageTag))
                .Build();
            ImageConfiguration targetImageConfiguration =
                ImageConfiguration.CreateBuilder(
                    ImageReference.Of(
                        expectedTargetServerUrl, expectedTargetImageName, expectedTargetTag))
                .SetCredentialRetrievers(credentialRetrievers)
                .Build();
            ContainerConfiguration containerConfiguration =
                ContainerConfiguration.CreateBuilder()
                .SetCreationTime(expectedCreationTime)
                .SetEntrypoint(expectedEntrypoint)
                .SetProgramArguments(expectedProgramArguments)
                .SetEnvironment(expectedEnvironment)
                .SetExposedPorts(expectedExposedPorts)
                .SetLabels(expectedLabels)
                .Build();

            BuildConfiguration.Builder buildConfigurationBuilder =
                BuildConfiguration.CreateBuilder()
                .SetBaseImageConfiguration(baseImageConfiguration)
                .SetTargetImageConfiguration(targetImageConfiguration)
                .SetAdditionalTargetImageTags(additionalTargetImageTags)
                .SetContainerConfiguration(containerConfiguration)
                .SetApplicationLayersCacheDirectory(expectedApplicationLayersCacheDirectory)
                .SetBaseImageLayersCacheDirectory(expectedBaseImageLayersCacheDirectory)
                .SetTargetFormat(ImageFormat.OCI)
                .SetAllowInsecureRegistries(true)
                .SetLayerConfigurations(expectedLayerConfigurations)
                .SetToolName(expectedCreatedBy);
            BuildConfiguration buildConfiguration = buildConfigurationBuilder.Build();

            Assert.IsNotNull(buildConfiguration.GetContainerConfiguration());
            Assert.AreEqual(
                expectedCreationTime, buildConfiguration.GetContainerConfiguration().GetCreationTime());
            Assert.AreEqual(
                expectedBaseImageServerUrl,
                buildConfiguration.GetBaseImageConfiguration().GetImageRegistry());
            Assert.AreEqual(
                expectedBaseImageName, buildConfiguration.GetBaseImageConfiguration().GetImageRepository());
            Assert.AreEqual(
                expectedBaseImageTag, buildConfiguration.GetBaseImageConfiguration().GetImageTag());
            Assert.AreEqual(
                expectedTargetServerUrl,
                buildConfiguration.GetTargetImageConfiguration().GetImageRegistry());
            Assert.AreEqual(
                expectedTargetImageName,
                buildConfiguration.GetTargetImageConfiguration().GetImageRepository());
            Assert.AreEqual(
                expectedTargetTag, buildConfiguration.GetTargetImageConfiguration().GetImageTag());
            Assert.AreEqual(expectedTargetImageTags, buildConfiguration.GetAllTargetImageTags());
            Assert.AreEqual(
                Credential.From("username", "password"),
                buildConfiguration
                .GetTargetImageConfiguration()
                .GetCredentialRetrievers()
                [0]
                .Retrieve()
                .OrElseThrow(() => new AssertionException("")));
            Assert.AreEqual(
                expectedProgramArguments,
                buildConfiguration.GetContainerConfiguration().GetProgramArguments());
            Assert.AreEqual(
                expectedEnvironment, buildConfiguration.GetContainerConfiguration().GetEnvironmentMap());
            Assert.AreEqual(
                expectedExposedPorts, buildConfiguration.GetContainerConfiguration().GetExposedPorts());
            Assert.AreEqual(expectedLabels, buildConfiguration.GetContainerConfiguration().GetLabels());
            Assert.AreEqual(expectedTargetFormat, buildConfiguration.GetTargetFormat());
            Assert.AreEqual(
                expectedApplicationLayersCacheDirectory,
                buildConfigurationBuilder.GetApplicationLayersCacheDirectory());
            Assert.AreEqual(
                expectedBaseImageLayersCacheDirectory,
                buildConfigurationBuilder.GetBaseImageLayersCacheDirectory());
            Assert.IsTrue(buildConfiguration.GetAllowInsecureRegistries());
            Assert.AreEqual(expectedLayerConfigurations, buildConfiguration.GetLayerConfigurations());
            Assert.AreEqual(
                expectedEntrypoint, buildConfiguration.GetContainerConfiguration().GetEntrypoint());
            Assert.AreEqual(expectedCreatedBy, buildConfiguration.GetToolName());
        }
Exemplo n.º 9
0
        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);
        }