Add Jib integration

core/build.gradle

@@ -62,6 +62,7 @@ configurations.all {
     resolutionStrategy {
         // use lower Jackson version
         force 'com.fasterxml.jackson.core:jackson-databind:2.8.8'
+        force 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.8.8'
     }
 }
 
@@ -75,6 +76,8 @@ dependencies {
         exclude(group: 'org.jetbrains', module: 'annotations')
     }
 
+    provided 'com.google.cloud.tools:jib-core:0.22.0'
+
     shaded 'org.awaitility:awaitility:4.2.0'
 
     api platform('com.github.docker-java:docker-java-bom:3.3.0')

core/src/main/java/org/testcontainers/jib/JibDockerClient.java

@@ -0,0 +1,84 @@
+package org.testcontainers.jib;
+
+import com.github.dockerjava.api.command.InspectImageResponse;
+import com.github.dockerjava.api.command.LoadImageCallback;
+import com.google.cloud.tools.jib.api.DockerClient;
+import com.google.cloud.tools.jib.api.ImageDetails;
+import com.google.cloud.tools.jib.api.ImageReference;
+import com.google.cloud.tools.jib.http.NotifyingOutputStream;
+import com.google.cloud.tools.jib.image.ImageTarball;
+import com.google.common.io.ByteStreams;
+import lombok.Cleanup;
+import org.testcontainers.DockerClientFactory;
+import org.testcontainers.UnstableAPI;
+import org.testcontainers.images.RemoteDockerImage;
+import org.testcontainers.utility.DockerImageName;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PipedInputStream;
+import java.io.PipedOutputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Map;
+import java.util.function.Consumer;
+
+@UnstableAPI
+class JibDockerClient implements DockerClient {
+
+    private static JibDockerClient instance;
+
+    private final com.github.dockerjava.api.DockerClient dockerClient = DockerClientFactory.lazyClient();
+
+    public static JibDockerClient instance() {
+        if (instance == null) {
+            instance = new JibDockerClient();
+        }
+
+        return instance;
+    }
+
+    @Override
+    public boolean supported(Map<String, String> map) {
+        return false;
+    }
+
+    @Override
+    public String load(ImageTarball imageTarball, Consumer<Long> writtenByteCountListener) throws IOException {
+        @Cleanup
+        PipedInputStream in = new PipedInputStream();
+        @Cleanup
+        PipedOutputStream out = new PipedOutputStream(in);
+        LoadImageCallback loadImage = this.dockerClient.loadImageAsyncCmd(in).exec(new LoadImageCallback());
+
+        try (NotifyingOutputStream stdin = new NotifyingOutputStream(out, writtenByteCountListener)) {
+            imageTarball.writeTo(stdin);
+        }
+
+        return loadImage.awaitMessage();
+    }
+
+    @Override
+    public void save(ImageReference imageReference, Path outputPath, Consumer<Long> writtenByteCountListener)
+        throws IOException {
+        try (
+            InputStream inputStream = this.dockerClient.saveImageCmd(imageReference.toString()).exec();
+            InputStream stdout = new BufferedInputStream(inputStream);
+            OutputStream fileStream = new BufferedOutputStream(Files.newOutputStream(outputPath));
+            NotifyingOutputStream notifyingFileStream = new NotifyingOutputStream(fileStream, writtenByteCountListener)
+        ) {
+            ByteStreams.copy(stdout, notifyingFileStream);
+        }
+    }
+
+    @Override
+    public ImageDetails inspect(ImageReference imageReference) {
+        new RemoteDockerImage(DockerImageName.parse(imageReference.toString())).get();
+
+        InspectImageResponse response = this.dockerClient.inspectImageCmd(imageReference.toString()).exec();
+        return new JibImageDetails(response.getSize(), response.getId(), response.getRootFS().getLayers());
+    }
+}

core/src/main/java/org/testcontainers/jib/JibImage.java

@@ -0,0 +1,59 @@
+package org.testcontainers.jib;
+
+import com.google.cloud.tools.jib.api.Containerizer;
+import com.google.cloud.tools.jib.api.DockerClient;
+import com.google.cloud.tools.jib.api.DockerDaemonImage;
+import com.google.cloud.tools.jib.api.Jib;
+import com.google.cloud.tools.jib.api.JibContainer;
+import com.google.cloud.tools.jib.api.JibContainerBuilder;
+import lombok.SneakyThrows;
+import org.testcontainers.DockerClientFactory;
+import org.testcontainers.utility.Base58;
+import org.testcontainers.utility.LazyFuture;
+import org.testcontainers.utility.ResourceReaper;
+
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class JibImage extends LazyFuture<String> {
+
+    private final DockerClient dockerClient = JibDockerClient.instance();
+
+    private static final Map<String, String> DEFAULT_LABELS = Stream
+        .of(
+            DockerClientFactory.DEFAULT_LABELS.entrySet().stream(),
+            ResourceReaper.instance().getLabels().entrySet().stream()
+        )
+        .flatMap(Function.identity())
+        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+    private final String baseImage;
+
+    private final Function<JibContainerBuilder, JibContainerBuilder> jibContainerBuilderFn;
+
+    public JibImage(String baseImage, Function<JibContainerBuilder, JibContainerBuilder> jibContainerBuilderFn) {
+        this.baseImage = baseImage;
+        this.jibContainerBuilderFn = jibContainerBuilderFn;
+    }
+
+    @SneakyThrows
+    @Override
+    protected String resolve() {
+        JibContainerBuilder containerBuilder = Jib.from(this.dockerClient, DockerDaemonImage.named(this.baseImage));
+        Function<JibContainerBuilder, JibContainerBuilder> applyLabelsFn = jibContainerBuilder -> {
+            for (Map.Entry<String, String> entry : DEFAULT_LABELS.entrySet()) {
+                jibContainerBuilder.addLabel(entry.getKey(), entry.getValue());
+            }
+            return jibContainerBuilder;
+        };
+        JibContainer jibContainer =
+            this.jibContainerBuilderFn.andThen(applyLabelsFn)
+                .apply(containerBuilder)
+                .containerize(
+                    Containerizer.to(this.dockerClient, DockerDaemonImage.named(Base58.randomString(8).toLowerCase()))
+                );
+        return jibContainer.getTargetImage().toString();
+    }
+}

core/src/main/java/org/testcontainers/jib/JibImageDetails.java

@@ -0,0 +1,42 @@
+package org.testcontainers.jib;
+
+import com.google.cloud.tools.jib.api.DescriptorDigest;
+import com.google.cloud.tools.jib.api.ImageDetails;
+
+import java.security.DigestException;
+import java.util.ArrayList;
+import java.util.List;
+
+class JibImageDetails implements ImageDetails {
+
+    private long size;
+
+    private String imageId;
+
+    private List<String> layers;
+
+    public JibImageDetails(long size, String imageId, List<String> layers) {
+        this.size = size;
+        this.imageId = imageId;
+        this.layers = layers;
+    }
+
+    @Override
+    public long getSize() {
+        return this.size;
+    }
+
+    @Override
+    public DescriptorDigest getImageId() throws DigestException {
+        return DescriptorDigest.fromDigest(this.imageId);
+    }
+
+    @Override
+    public List<DescriptorDigest> getDiffIds() throws DigestException {
+        List<DescriptorDigest> processedDiffIds = new ArrayList<>(this.layers.size());
+        for (String diffId : this.layers) {
+            processedDiffIds.add(DescriptorDigest.fromDigest(diffId.trim()));
+        }
+        return processedDiffIds;
+    }
+}

core/src/test/java/org/testcontainers/containers/JibTest.java

@@ -0,0 +1,88 @@
+package org.testcontainers.containers;
+
+import com.github.dockerjava.api.command.InspectImageResponse;
+import org.junit.Test;
+import org.testcontainers.DockerClientFactory;
+import org.testcontainers.containers.output.OutputFrame.OutputType;
+import org.testcontainers.containers.startupcheck.OneShotStartupCheckStrategy;
+import org.testcontainers.jib.JibImage;
+
+import java.time.Duration;
+import java.util.Collections;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class JibTest {
+
+    @Test
+    public void buildImage() {
+        try (
+            // jibContainerUsage {
+            GenericContainer<?> busybox = new GenericContainer<>(
+                new JibImage(
+                    "busybox:1.35",
+                    jibContainerBuilder -> {
+                        return jibContainerBuilder.setEntrypoint("echo", "Hello World");
+                    }
+                )
+            )
+                .withStartupCheckStrategy(new OneShotStartupCheckStrategy().withTimeout(Duration.ofSeconds(3)))
+            // }
+        ) {
+            busybox.start();
+            String logs = busybox.getLogs(OutputType.STDOUT);
+            assertThat(logs).contains("Hello World");
+        }
+    }
+
+    @Test
+    public void standardLabelsAreAddedWhenUsingJibSetLabels() {
+        try (
+            GenericContainer<?> busybox = new GenericContainer<>(
+                new JibImage(
+                    "busybox:1.35",
+                    jibContainerBuilder -> {
+                        return jibContainerBuilder
+                            .setEntrypoint("echo", "Hello World")
+                            .setLabels(Collections.singletonMap("foo", "bar"));
+                    }
+                )
+            )
+                .withStartupCheckStrategy(new OneShotStartupCheckStrategy().withTimeout(Duration.ofSeconds(3)))
+        ) {
+            busybox.start();
+            assertImageLabels(busybox);
+        }
+    }
+
+    @Test
+    public void standardLabelsAreAddedWhenUsingJibAddLabel() {
+        try (
+            GenericContainer<?> busybox = new GenericContainer<>(
+                new JibImage(
+                    "busybox:1.35",
+                    jibContainerBuilder -> {
+                        return jibContainerBuilder.setEntrypoint("echo", "Hello World").addLabel("foo", "bar");
+                    }
+                )
+            )
+                .withStartupCheckStrategy(new OneShotStartupCheckStrategy().withTimeout(Duration.ofSeconds(3)))
+        ) {
+            busybox.start();
+            assertImageLabels(busybox);
+        }
+    }
+
+    private static void assertImageLabels(GenericContainer<?> busybox) {
+        String image = busybox.getContainerInfo().getConfig().getImage();
+        InspectImageResponse imageResponse = DockerClientFactory.lazyClient().inspectImageCmd(image).exec();
+        assertThat(imageResponse.getConfig().getLabels())
+            .containsEntry("foo", "bar")
+            .containsKeys(
+                "org.testcontainers",
+                "org.testcontainers.sessionId",
+                "org.testcontainers.lang",
+                "org.testcontainers.version"
+            );
+    }
+}

docs/features/jib.md

@@ -0,0 +1,11 @@
+# Using Jib
+
+[Jib](https://github.com/GoogleContainerTools/jib/tree/master/jib-core) is a library for building Docker images.
+You can use it as an alternative to Testcontainers default `DockerfileBuilder`.
+
+<!--codeinclude-->
+[GenericContainer with JibImage](../../core/src/test/java/org/testcontainers/containers/JibTest.java) inside_block:jibContainerUsage
+<!--/codeinclude-->
+
+!!! hint
+The Testcontainers library JAR will not automatically add a `jib-core` JAR to your project. Minimum version required is `com.google.cloud.tools:jib-core:0.22.0`.

mkdocs.yml

@@ -39,6 +39,7 @@ nav:
           - features/startup_and_waits.md
           - features/container_logs.md
           - features/creating_images.md
+          - features/jib.md
           - features/configuration.md
           - features/image_name_substitution.md
           - features/advanced_options.md