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