private Image(
ManifestFormat imageFormat,
Instant created,
string architecture,
string os,
ImageLayers layers,
ImmutableArray <HistoryEntry> history,
ImmutableDictionary <string, string> environment,
ImmutableArray <string>?entrypoint,
ImmutableArray <string>?programArguments,
DockerHealthCheck healthCheck,
ImmutableHashSet <Port> exposedPorts,
ImmutableHashSet <AbsoluteUnixPath> volumes,
ImmutableDictionary <string, string> labels,
string workingDirectory,
string user)
{
this.imageFormat = imageFormat;
this.created = created;
this.architecture = architecture;
this.os = os;
this.layers = layers;
this.history = history;
this.environment = environment;
this.entrypoint = entrypoint;
this.programArguments = programArguments;
this.healthCheck = healthCheck;
this.exposedPorts = exposedPorts;
this.volumes = volumes;
this.labels = labels;
this.workingDirectory = workingDirectory;
this.user = user;
}
/**
* Gets the container configuration as a {@link Blob}.
*
* @return the container configuration {@link Blob}
*/
public ContainerConfigurationTemplate GetContainerConfiguration()
{
// ISet up the JSON template.
ContainerConfigurationTemplate template = new ContainerConfigurationTemplate();
// Adds the layer diff IDs.
foreach (ILayer layer in image.GetLayers())
{
template.AddLayerDiffId(layer.GetDiffId());
}
// Adds the history.
foreach (HistoryEntry historyObject in image.GetHistory())
{
template.AddHistoryEntry(historyObject);
}
template.Created = image.GetCreated()?.ToString();
template.Architecture = image.GetArchitecture();
template.Os = image.GetOs();
template.SetContainerEnvironment(EnvironmentMapToList(image.GetEnvironment()));
template.SetContainerEntrypoint(image.GetEntrypoint());
template.SetContainerCmd(image.GetProgramArguments());
template.SetContainerExposedPorts(PortSetToMap(image.GetExposedPorts()));
template.SetContainerVolumes(VolumesSetToMap(image.GetVolumes()));
template.SetContainerLabels(image.GetLabels());
template.SetContainerWorkingDir(image.GetWorkingDirectory());
template.SetContainerUser(image.GetUser());
// Ignore healthcheck if not Docker/command is empty
DockerHealthCheck healthCheck = image.GetHealthCheck();
if (image.GetImageFormat() == ManifestFormat.V22 && healthCheck != null)
{
template.SetContainerHealthCheckTest(healthCheck.GetCommand());
healthCheck
.GetInterval()
.IfPresent(interval => template.SetContainerHealthCheckInterval((long)interval.TotalNanoseconds));
healthCheck
.GetTimeout()
.IfPresent(timeout => template.SetContainerHealthCheckTimeout((long)timeout.TotalNanoseconds));
healthCheck
.GetStartPeriod()
.IfPresent(
startPeriod => template.SetContainerHealthCheckStartPeriod((long)startPeriod.TotalNanoseconds));
template.SetContainerHealthCheckRetries(healthCheck.GetRetries().AsNullable());
}
return(template);
}
//private static DescriptorDigest fakeDigest = DescriptorDigest.fromHash(new string('a', 64));
private void SetUp(ManifestFormat imageFormat)
{
Image.Builder testImageBuilder =
Image.CreateBuilder(imageFormat)
.SetCreated(Instant.FromUnixTimeSeconds(20))
.SetArchitecture("wasm")
.SetOs("js")
.AddEnvironmentVariable("VAR1", "VAL1")
.AddEnvironmentVariable("VAR2", "VAL2")
.SetEntrypoint(new[] { "some", "entrypoint", "command" })
.SetProgramArguments(new[] { "arg1", "arg2" })
.SetHealthCheck(
DockerHealthCheck.FromCommand(ImmutableArray.Create("CMD-SHELL", "/checkhealth"))
.SetInterval(Duration.FromSeconds(3))
.SetTimeout(Duration.FromSeconds(1))
.SetStartPeriod(Duration.FromSeconds(2))
.SetRetries(3)
.Build())
.AddExposedPorts(ImmutableHashSet.Create(Port.Tcp(1000), Port.Tcp(2000), Port.Udp(3000)))
.AddVolumes(
ImmutableHashSet.Create(
AbsoluteUnixPath.Get("/var/job-result-data"),
AbsoluteUnixPath.Get("/var/log/my-app-logs")))
.AddLabels(ImmutableDic.Of("key1", "value1", "key2", "value2"))
.SetWorkingDirectory("/some/workspace")
.SetUser("tomcat");
DescriptorDigest fakeDigest =
DescriptorDigest.FromDigest(
"sha256:8c662931926fa990b41da3c9f42663a537ccd498130030f9149173a0493832ad");
testImageBuilder.AddLayer(
new FakeLayer(fakeDigest));
testImageBuilder.AddHistory(
HistoryEntry.CreateBuilder()
.SetCreationTimestamp(Instant.FromUnixTimeSeconds(0))
.SetAuthor("Bazel")
.SetCreatedBy("bazel build ...")
.SetEmptyLayer(true)
.Build());
testImageBuilder.AddHistory(
HistoryEntry.CreateBuilder()
.SetCreationTimestamp(Instant.FromUnixTimeSeconds(20))
.SetAuthor("Fib")
.SetCreatedBy("fib")
.Build());
imageToJsonTranslator = new ImageToJsonTranslator(testImageBuilder.Build());
}
public void TestBuild()
{
DockerHealthCheck healthCheck =
DockerHealthCheck.FromCommand(ImmutableArray.Create("echo", "hi"))
.SetInterval(Duration.FromNanoseconds(123))
.SetTimeout(Duration.FromNanoseconds(456))
.SetStartPeriod(Duration.FromNanoseconds(789))
.SetRetries(10)
.Build();
Assert.IsTrue(healthCheck.GetInterval().IsPresent());
Assert.AreEqual(Duration.FromNanoseconds(123), healthCheck.GetInterval().Get());
Assert.IsTrue(healthCheck.GetTimeout().IsPresent());
Assert.AreEqual(Duration.FromNanoseconds(456), healthCheck.GetTimeout().Get());
Assert.IsTrue(healthCheck.GetStartPeriod().IsPresent());
Assert.AreEqual(Duration.FromNanoseconds(789), healthCheck.GetStartPeriod().Get());
Assert.IsTrue(healthCheck.GetRetries().IsPresent());
Assert.AreEqual(10, healthCheck.GetRetries().Get());
}
public void TestBuild_invalidCommand()
{
try
{
DockerHealthCheck.FromCommand(ImmutableArray.Create <string>());
Assert.Fail();
}
catch (ArgumentException ex)
{
Assert.AreEqual("command must not be empty", ex.Message);
}
try
{
DockerHealthCheck.FromCommand(new[] { "CMD", null });
Assert.Fail();
}
catch (ArgumentException ex)
{
Assert.AreEqual("command must not contain null elements", ex.Message);
}
}
private static void ConfigureBuilderWithContainerConfiguration(
Image.Builder imageBuilder, ContainerConfigurationTemplate containerConfigurationTemplate)
{
foreach (HistoryEntry i in containerConfigurationTemplate.History)
{
imageBuilder.AddHistory(i);
}
if (containerConfigurationTemplate.Created != null)
{
try
{
imageBuilder.SetCreated(
Instant.FromDateTimeOffset(
DateTimeOffset.Parse(
containerConfigurationTemplate.Created,
CultureInfo.InvariantCulture)));
}
catch (FormatException ex)
{
throw new BadContainerConfigurationFormatException(
"Invalid image creation time: " + containerConfigurationTemplate.Created, ex);
}
}
if (containerConfigurationTemplate.Architecture != null)
{
imageBuilder.SetArchitecture(containerConfigurationTemplate.Architecture);
}
if (containerConfigurationTemplate.Os != null)
{
imageBuilder.SetOs(containerConfigurationTemplate.Os);
}
imageBuilder.SetEntrypoint(containerConfigurationTemplate.GetContainerEntrypoint());
imageBuilder.SetProgramArguments(containerConfigurationTemplate.GetContainerCmd());
IList <string> baseHealthCheckCommand = containerConfigurationTemplate.GetContainerHealthTest();
if (baseHealthCheckCommand != null)
{
DockerHealthCheck.Builder builder = DockerHealthCheck.FromCommand(baseHealthCheckCommand);
if (containerConfigurationTemplate.GetContainerHealthInterval() != null)
{
builder.SetInterval(
Duration.FromNanoseconds(containerConfigurationTemplate.GetContainerHealthInterval().GetValueOrDefault()));
}
if (containerConfigurationTemplate.GetContainerHealthTimeout() != null)
{
builder.SetTimeout(
Duration.FromNanoseconds(containerConfigurationTemplate.GetContainerHealthTimeout().GetValueOrDefault()));
}
if (containerConfigurationTemplate.GetContainerHealthStartPeriod() != null)
{
builder.SetStartPeriod(
Duration.FromNanoseconds(containerConfigurationTemplate.GetContainerHealthStartPeriod().GetValueOrDefault()));
}
if (containerConfigurationTemplate.GetContainerHealthRetries() != null)
{
builder.SetRetries(containerConfigurationTemplate.GetContainerHealthRetries().GetValueOrDefault());
}
imageBuilder.SetHealthCheck(builder.Build());
}
if (containerConfigurationTemplate.GetContainerExposedPorts() != null)
{
imageBuilder.AddExposedPorts(
PortMapToSet(containerConfigurationTemplate.GetContainerExposedPorts()));
}
if (containerConfigurationTemplate.GetContainerVolumes() != null)
{
imageBuilder.AddVolumes(VolumeMapToSet(containerConfigurationTemplate.GetContainerVolumes()));
}
if (containerConfigurationTemplate.GetContainerEnvironment() != null)
{
foreach (string environmentVariable in containerConfigurationTemplate.GetContainerEnvironment())
{
Match matcher = EnvironmentPattern.Match(environmentVariable);
if (!matcher.Success)
{
throw new BadContainerConfigurationFormatException(
"Invalid environment variable definition: " + environmentVariable);
}
imageBuilder.AddEnvironmentVariable(matcher.Groups["name"].Value, matcher.Groups["value"].Value);
}
}
imageBuilder.AddLabels(containerConfigurationTemplate.GetContainerLabels());
imageBuilder.SetWorkingDirectory(containerConfigurationTemplate.GetContainerWorkingDir());
imageBuilder.SetUser(containerConfigurationTemplate.GetContainerUser());
}
/**
* Sets the container's healthcheck configuration.
*
* @param healthCheck the healthcheck configuration
* @return this
*/
public Builder SetHealthCheck(DockerHealthCheck healthCheck)
{
this.healthCheck = healthCheck;
return(this);
}
public void SetUp()
{
testDescriptorDigest =
DescriptorDigest.FromHash(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
Mock.Get(mockBuildConfiguration).Setup(m => m.GetEventHandlers()).Returns(mockEventHandlers);
Mock.Get(mockBuildConfiguration).Setup(m => m.GetContainerConfiguration()).Returns(mockContainerConfiguration);
Mock.Get(mockBuildConfiguration).Setup(m => m.GetToolName()).Returns(() => null);
Mock.Get(mockContainerConfiguration).Setup(m => m.GetCreationTime()).Returns(Instant.FromUnixTimeSeconds(0));
Mock.Get(mockContainerConfiguration).Setup(m => m.GetEnvironmentMap()).Returns(ImmutableDictionary.Create <string, string>());
Mock.Get(mockContainerConfiguration).Setup(m => m.GetProgramArguments()).Returns(ImmutableArray.Create <string>());
Mock.Get(mockContainerConfiguration).Setup(m => m.GetExposedPorts()).Returns(ImmutableHashSet.Create <Port>());
Mock.Get(mockContainerConfiguration).Setup(m => m.GetEntrypoint()).Returns(ImmutableArray.Create <string>());
Mock.Get(mockContainerConfiguration).Setup(m => m.GetUser()).Returns("root");
Mock.Get(mockCachedLayer).Setup(m => m.GetBlobDescriptor()).Returns(new BlobDescriptor(0, testDescriptorDigest));
nonEmptyLayerHistory =
HistoryEntry.CreateBuilder()
.SetCreationTimestamp(Instant.FromUnixTimeSeconds(0))
.SetAuthor("FibBase")
.SetCreatedBy("fib-test")
.Build();
emptyLayerHistory =
HistoryEntry.CreateBuilder()
.SetCreationTimestamp(Instant.FromUnixTimeSeconds(0))
.SetAuthor("FibBase")
.SetCreatedBy("fib-test")
.SetEmptyLayer(true)
.Build();
Image baseImage =
Image.CreateBuilder(ManifestFormat.V22)
.SetArchitecture("wasm")
.SetOs("js")
.AddEnvironment(ImmutableDic.Of("BASE_ENV", "BASE_ENV_VALUE", "BASE_ENV_2", "DEFAULT"))
.AddLabel("base.label", "base.label.value")
.AddLabel("base.label.2", "default")
.SetWorkingDirectory("/base/working/directory")
.SetEntrypoint(ImmutableArray.Create("baseImageEntrypoint"))
.SetProgramArguments(ImmutableArray.Create("catalina.sh", "run"))
.SetHealthCheck(
DockerHealthCheck.FromCommand(ImmutableArray.Create("CMD-SHELL", "echo hi"))
.SetInterval(Duration.FromSeconds(3))
.SetTimeout(Duration.FromSeconds(2))
.SetStartPeriod(Duration.FromSeconds(1))
.SetRetries(20)
.Build())
.AddExposedPorts(ImmutableHashSet.Create(Port.Tcp(1000), Port.Udp(2000)))
.AddVolumes(
ImmutableHashSet.Create(
AbsoluteUnixPath.Get("/base/path1"), AbsoluteUnixPath.Get("/base/path2")))
.AddHistory(nonEmptyLayerHistory)
.AddHistory(emptyLayerHistory)
.AddHistory(emptyLayerHistory)
.Build();
Mock.Get(mockPullAndCacheBaseImageLayerStep).Setup(m => m.GetFuture()).Returns(Futures.ImmediateFutureAsync(mockCachedLayer));
Mock.Get(mockPullAndCacheBaseImageLayersStep).Setup(m => m.GetFuture()).Returns(
Futures.ImmediateFutureAsync <IReadOnlyList <ICachedLayer> >(
ImmutableArray.Create(
mockCachedLayer,
mockCachedLayer,
mockCachedLayer)));
Mock.Get(mockPullBaseImageStep).Setup(m => m.GetFuture()).Returns(
Futures.ImmediateFutureAsync(
new BaseImageWithAuthorization(baseImage, null)));
mockClassesLayer = new CachedLayerWithType(mockCachedLayer, "classes");
mockDependenciesLayer = new CachedLayerWithType(mockCachedLayer, "dependencies");
mockExtraFilesLayer = new CachedLayerWithType(mockCachedLayer, "extra files");
mockResourcesLayer = new CachedLayerWithType(mockCachedLayer, "resources");
}
