GoogleContainerTools/jib

This system is a Java containerization toolkit that builds OCI and Docker images from Java applications without requiring a Docker daemon. It provides a core library for constructing and pushing images, alongside plugins for Maven and Gradle, and a command-line interface for direct usage. The system supports various Java frameworks and build configurations, enabling reproducible, multi-platform container builds with integrated credential management and build progress tracking.

77 changes.

This period focused on a comprehensive refactoring of the Jib core library, introducing a new public API for image building and a modular builder step system. The team established robust abstractions for HTTP clients, caching, and registry interactions, while simultaneously enhancing build progress reporting and console logging. The work also expanded the project's ecosystem with new framework examples and automated release processes.

48 changes.

This period focused on introducing a plugin extension API to enable third-party customizations for Maven and Gradle builds. Simultaneously, the Jib CLI was restructured to support new buildfile configurations and improved JAR/WAR processing modes. The work was heavily supported by extensive test coverage and automation scripts for releases.

9 changes.

This period focused on expanding the Jib CLI with support for WAR file containerization and improved version reporting. Concurrently, the core library introduced global registry mirror configuration and resolved critical Docker CLI interaction issues on Windows.

Introduces a new Dropwizard example project that demonstrates containerizing a Java application with Jib. The change adds the full source code for the example, including the main application class, configuration, resources, and health checks. It also includes a Maven wrapper (mvn, mvnw.cmd, and related wrapper scripts) to ensure consistent build environments, and a README with instructions for running the application and building the container image.

examples/dropwizard · high confidence

A new example project for building and containerizing an Eclipse Vert.x application with Jib has been added. The example includes a Java verticle that serves HTTP endpoints, a Logback configuration, and a Gradle wrapper configured for Gradle 5.1, allowing users to build a Docker image using ./gradlew jibDockerBuild.

examples/vertx · high confidence

The Jib CLI now supports building containers from JAR files using two distinct processing modes: 'exploded' and 'packaged'. For standard JARs, the 'exploded' mode extracts the archive and layers its contents (classes, resources, dependencies) into the container, while the 'packaged' mode layers the JAR as a single unit. For Spring Boot applications, the tool distinguishes between 'exploded' (unzipping and layering contents like \BOOT-INF/lib\ and \classes\) and 'packaged' (treating the fat JAR as a single layer). This change introduces new classes (\JarFiles\, \JarLayers\, \ProcessingMode\, and various \\*Processor\ implementations) to handle these different JAR structures and layering strategies.

jib-cli/src/main/java/com/google/cloud/tools/jib/cli/jar · high confidence

A new example project demonstrates how to build and run a Java application with the Stackdriver Debugger Java Agent on Google Cloud Platform. The example includes a SparkJava-based application that dynamically listens on the PORT environment variable for Cloud Run compatibility, along with Gradle wrapper scripts and configuration to enforce Gradle 5.1 or higher.

examples/java-agent · high confidence

Added a new Java-based Hello World example in the examples/helloworld directory. The example includes a Gradle wrapper (gradlew, gradlew.bat, and gradle-wrapper.properties) to manage the build environment, along with the Java source code (HelloWorld.java) and a resource file (world) that the application reads to print 'Hello world'.

examples/helloworld · high confidence

New build scripts for the Kokoro continuous integration system have been added, enabling automated builds and integration tests on Linux, macOS, and Windows. The scripts configure Docker environments, manage container cleanup, and execute Gradle tasks (build, integrationTest) for the Jib project, including specific setup for GCP Ubuntu and macOS external clusters.

kokoro · high confidence

Added a new Ktor example that demonstrates how to build a Docker image with Jib. The example includes a Gradle wrapper configured for Gradle 5.1, a Kotlin application with configurable environment variables (KTOR\_APP\_ID, KTOR\_METRICS\_ENABLED, KTOR\_ROUTE\_TRACING), and supporting configuration files (application.conf, logback.xml).

examples/ktor · high confidence

A new Micronaut example has been added to demonstrate building a Docker image for a Groovy/Java application using Jib. The example includes a Spring-style controller returning 'Hello World', a Gradle wrapper configured for Gradle 5.1, and a Spock-based integration test that verifies the endpoint. This provides users with a ready-to-run template for containerizing Micronaut apps.

examples/micronaut · high confidence

The Spring Boot example now includes a README explaining how to build a Docker image with Jib and deploy to Kubernetes. To ensure consistent builds, the example now ships with Gradle and Maven wrapper scripts (gradlew, mvnw) and configuration files (gradle-wrapper.properties, maven-wrapper.properties) that enforce a minimum Gradle version of 5.1 and use Maven wrapper 0.4.0.

examples/spring-boot · high confidence

A new multi-module example is added to demonstrate building multiple containers for a project using both Maven and Gradle. The example includes a shared library module, a name-service, and a hello-service, with build scripts and wrapper files for both build systems, along with Kubernetes deployment manifests.

examples/multi-module · high confidence

A new shell script, update\_gcs\_latest.sh, has been added to the jib-cli/scripts directory. This script accepts a release version as an argument, validates its format, and uploads a JSON file containing the latest version to a Google Cloud Storage bucket (gs://jib-versions/jib-cli). It also configures public read access for the uploaded file and verifies the update was successful.

jib-cli/scripts · high confidence

A new shell script, release\_build.sh, has been added to the jib-maven-plugin/kokoro directory. This script configures the build environment by setting error handling and logging options, and then executes the Gradle 'prepareRelease' task for the jib-maven-plugin, automating the initial step of the release process.

jib-maven-plugin/kokoro · high confidence

A new multi-module example was added to the repository. This includes a Maven wrapper configuration (downloading Maven 3.5.4) and a Spring Boot application in the hello-service module, featuring an Application class and a HelloController that calls a name-service.

examples/multi-module/.mvn, examples/multi-module/hello-service · high confidence

A new shell script, release\_build.sh, has been added to the jib-core/kokoro directory. This script automates the release build process by invoking the Gradle wrapper to execute the :jib-core:prepareRelease task, ensuring the build fails on any error and displays commands for visibility.

jib-core/kokoro · high confidence

Two new shell scripts are added to the jib-gradle-plugin repository to automate the release process. The 'release.sh' script handles publishing the Gradle plugin to Maven Central using Gradle's plugin publishing mechanism. The 'update\_gcs\_latest.sh' script updates the latest version string in Google Cloud Storage, ensuring the public URL reflects the most recent release. These scripts streamline the release workflow for maintainers.

jib-gradle-plugin/scripts · high confidence

A new CredentialRetrieverFactory class has been added to the jib-core frontend package. This factory provides a centralized way to create CredentialRetriever instances for various authentication methods, including Docker credential helpers and Google Application Default Credentials. This change introduces a structured approach to credential retrieval, allowing for better management and logging of credential sources during the build process.

jib-core/src/main/java/com/google/cloud/tools/jib/frontend · high confidence

The repository introduces a formal Code of Conduct, a Security policy, and a Java Style Guide to define community expectations and technical standards. Additionally, the CONTRIBUTING.md file is updated to provide a structured workflow for contributors, including guidelines for building the project with Gradle, running integration tests, and debugging the Maven and Gradle plugins.

(repo-wide) · high confidence

The codebase now includes a new \Blob\ interface and supporting classes (\BlobDescriptor\, \Blobs\, \FileBlob\, \InputStreamBlob\, \JsonBlob\, \StringBlob\, \WritableContentsBlob\) in the \com.google.cloud.tools.jib.blob\ package. This introduces a unified way to represent and write binary data (BLOBs) to output streams, with support for different sources like files, input streams, JSON templates, and strings, each with specific retryability characteristics.

jib-core/src/main/java/com/google/cloud/tools/jib/blob · high confidence

The Jib Gradle plugin now supports a plugin extension API that allows third-party code to modify the container build plan. Developers can implement the new JibGradlePluginExtension interface to define custom configurations and apply transformations to the build plan via the extendContainerBuildPlan method, enabling extensibility for Gradle-based projects.

jib-gradle-plugin-extension-api · high confidence

Added new classes, JsonTemplate and JsonTemplateMapper, to provide a standardized way to serialize and deserialize JSON objects and lists using Jackson. JsonTemplate serves as a base interface for JSON templates, while JsonTemplateMapper offers static methods to read JSON from files, streams, strings, and byte arrays, as well as to serialize objects to UTF-8 strings or byte arrays.

jib-core/src/main/java/com/google/cloud/tools/jib/json · high confidence

Adds the Jib Maven plugin extension API, allowing third-party developers to create custom configurations and modify the container build plan via the new JibMavenPluginExtension interface and MavenData helper.

jib-maven-plugin-extension-api/src · high confidence

A new ProjectInfo class has been added to the jib-core module, providing centralized constants for the project's GitHub repository URL and the new issue link. This change consolidates project metadata that was previously scattered or hardcoded, making it easier to update links in a single location.

jib-core/src/main/java/com/google/cloud/tools/jib · high confidence

The Jib CLI now supports a new YAML-based buildfile format that allows users to define container build configurations declaratively. This change adds a suite of Java classes (such as BuildFileSpec, LayersSpec, and PlatformSpec) that parse a YAML file into a structured representation, which is then converted into a JibContainerBuilder. Users can now specify base images, layers, file properties, and platform details in a single configuration file, replacing the need for command-line arguments for many build options.

jib-cli/src/main/java/com/google/cloud/tools/jib/cli/buildfile · high confidence

The build plan API is expanded to support multi-architecture container images by adding platform configuration (architecture and OS) to the build plan, allowing users to specify desired platforms for image building. Additionally, the API now supports setting file ownership and modification times for layer entries, and introduces new classes for managing file permissions, ports, and image formats (Docker/OCI).

jib-build-plan/src/main · high confidence

A new plugin extension API is introduced, providing the foundational types for building Jib plugin extensions. This includes the \JibPluginExtension\ base interface for extension implementations, an \ExtensionLogger\ interface for logging, a \NullExtension\ placeholder, and a \JibPluginExtensionException\ for error handling. These changes establish the common contract and utilities required for Maven and Gradle plugins to support extensibility.

jib-plugins-extension-common/src/main/java/com/google/cloud/tools/jib/plugins/extension · high confidence

The Jib CLI has been restructured into a new main entry point, introducing dedicated commands for building containers (build), processing JARs (jar), and processing WARs (war). This change adds new classes to handle common CLI options, container building and serialization, credential management, and artifact processing, enabling users to containerize Java applications via a more organized command-line interface.

jib-cli/src/main/java/com/google/cloud/tools/jib/cli · high confidence

The build process now utilizes a set of new step classes in the \jib-core\ builder steps package, including \AuthenticatePushStep\, \BuildAndCacheApplicationLayerStep\, \BuildImageStep\, \BuildManifestListOrSingleManifestStep\, \CheckManifestStep\, \LoadDockerStep\, \LocalBaseImageSteps\, \ObtainBaseImageLayerStep\, \PlatformChecker\, \PreparedLayer\, and \PullBaseImageStep\. These changes implement the core logic for authenticating pushes, building and caching application layers, constructing the final image model, generating manifests (including multi-platform manifest lists), checking for existing manifests, loading images to Docker, handling local base images, pulling base image layers, verifying platform compatibility, and managing layer preparation.

jib-core/src/main/java/com/google/cloud/tools/jib/builder/steps · high confidence

The logging subsystem in jib-plugins-common has been refactored to support rich, ANSI-enabled console output with a dynamic footer. A new ConsoleLogger interface and ConsoleLoggerBuilder allow construction of either a plain-text logger or an ANSI logger that renders a progress bar and task list in bold text at the bottom of the console. The ANSI logger handles cursor positioning to update the footer without clearing the screen, and truncates footer lines to 50 characters to prevent display issues. This change introduces SingleThreadedExecutor to ensure sequential logging and provides a foundation for improved build output visibility.

jib-plugins-common/src/main/java/com/google/cloud/tools/jib/plugins/common/logging · high confidence

Adds new core classes in the jib-core image package to support reproducible image building. This includes the Layer interface and its implementations (DigestOnlyLayer, ReferenceLayer, ReferenceNoDiffIdLayer) to represent image layers, along with a ReproducibleLayerBuilder that normalizes file metadata (timestamps, ownership, permissions) to ensure build reproducibility. The Image class is introduced as an immutable builder for image configuration, and ImageTarball handles serializing images to tarballs. These changes provide the foundation for controlling file timestamps and permissions in the final image layers.

jib-core/src/main/java/com/google/cloud/tools/jib/image · high confidence

A new multi-module example project has been added to the examples directory, providing a concrete reference for Gradle-based multi-module builds. The example is configured to use Gradle 5.1 via a newly added \gradle-wrapper.properties\ file, ensuring consistent build environment setup for users exploring this pattern.

examples/multi-module/gradle · high confidence

Added new classes in the \jib-core\ image JSON package to handle image manifest and container configuration serialization and deserialization. This includes \BuildableManifestTemplate\ for building manifest JSON, \ContainerConfigurationTemplate\ for container settings, \HistoryEntry\ for image history, and \ImageMetadataTemplate\ to bundle manifests with their configurations. The \ImageToJsonTranslator\ and \JsonToImageTranslator\ classes now use these templates to convert between internal \Image\ objects and JSON structures, supporting both Docker V2.2 and OCI image formats. Additionally, \ManifestListTemplate\ and \ManifestListGenerator\ were added to support multi-platform image building by generating manifest lists that reference multiple platform-specific manifests.

jib-core/src/main/java/com/google/cloud/tools/jib/image/json · high confidence

The Jib Gradle plugin now includes a new set of internal Gradle tasks to support Skaffold integration. These include \_jibSkaffoldInit to output image and project name, \_jibSkaffoldFilesV2 to list changing source dependencies, \_jibSkaffoldSyncMap to map local files to container locations, and \_skaffoldFailIfJibOutOfDate to verify version compatibility. These tasks enable Skaffold to detect and manage Jib-based builds and file synchronization.

jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/skaffold · high confidence

Added new classes in the jib-core filesystem package to improve file system operations: DirectoryWalker for recursive directory traversal, FileOperations for copying files and directories, LockFile for file locking, TempDirectoryProvider for managing temporary directories, and XdgDirectories for resolving OS-specific cache and config directories (Linux, Windows, macOS). These utilities support internal Jib operations such as caching, Docker context generation, and temporary file management.

jib-core/src/main/java/com/google/cloud/tools/jib/filesystem · high confidence

Added three new classes to the jib-core module to support content hashing: a WritableContents functional interface for lazy content writing, a CountingDigestOutputStream to track bytes while computing SHA-256 digests, and a Digests utility class providing static methods to compute digests from JSON templates or input streams.

jib-core/src/main/java/com/google/cloud/tools/jib/hash · high confidence

The Jib Maven plugin now includes a set of internal Maven goals (\_skaffold-init, \_skaffold-fail-if-jib-out-of-date, \_skaffold-files-v2, \_skaffold-package-goals, and \_skaffold-sync-map) that expose Jib configuration and file information in a format compatible with Google's Skaffold tool. These goals allow Skaffold to detect Jib-based projects, validate plugin versions, and retrieve file mappings for hot-reload and sync operations.

jib-maven-plugin/src/main/java/com/google/cloud/tools/jib/maven/skaffold · high confidence

The jib-core module now exposes a comprehensive public API for constructing and building container images. This includes the main entry point Jib and its builder JibContainerBuilder, which allow users to specify base images from registries, Docker daemons, or tarballs. The update introduces the Containerizer class to configure build and push targets (RegistryImage, DockerDaemonImage, TarImage) and provides the JibContainer result object containing image digests, IDs, and tags. Supporting classes such as ImageReference, Credential, and various exception types are also part of this new public-facing interface.

jib-core/src/main/java/com/google/cloud/tools/jib/api · high confidence

Jib now reads authentication credentials from the standard Docker configuration file (\~/.docker/config.json) and supports Docker credential helpers. This enables users to leverage existing Docker login sessions and configured credential stores for registry authentication, with support for Windows executable extensions (.cmd, .exe) for credential helpers.

jib-core/src/main/java/com/google/cloud/tools/jib/registry/credentials · high confidence

Users can now use the Jib CLI to build container images from WAR files. A new \WarFiles\ utility creates a \JibContainerBuilder\ from a WAR, handling the extraction and layering of dependencies, classes, and resources. The default entrypoint is configured for Jetty 12+ compatibility, ensuring the container starts correctly with the appropriate deployment module.

jib-cli/src/main/java/com/google/cloud/tools/jib/cli/war · high confidence

Users can now configure registry mirrors globally via the Jib configuration file. The system reads a new 'registryMirrors' section in the global config, allowing users to specify which registries should be mirrored and to which endpoints. This change introduces new classes (GlobalConfig, GlobalConfigTemplate, RegistryMirrorsTemplate) to parse and validate this configuration, enabling more flexible registry access setups.

jib-plugins-common/src/main/java/com/google/cloud/tools/jib/plugins/common/globalconfig · high confidence

A new Java class, DockerManifestEntryTemplate, has been introduced to handle the JSON structure of a loadable Docker manifest entry. This template maps the 'Config', 'RepoTags', and 'Layers' fields from the Docker manifest, enabling the system to correctly parse and process image metadata during the Docker load operation.

jib-core/src/main/java/com/google/cloud/tools/jib/docker/json · high confidence

Kokoro release build scripts have been added for the Jib build plan, the Maven plugin extension API, and the common plugin extension utilities. These scripts automate the release process for these three artifacts, streamlining the path to Maven Central.

jib-build-plan/kokoro, jib-maven-plugin-extension-api/kokoro, jib-plugins-extension-common · medium confidence

A new \JibSystemProperties\ class has been introduced to centralize the names and validation logic for Jib's system properties. This change consolidates configuration for features such as HTTP timeouts, cross-repository blob mounts, serialization, and skipping existing images, ensuring consistent validation and access to these settings across the codebase.

jib-core/src/main/java/com/google/cloud/tools/jib/global · medium confidence

A new configuration file, commons-logging.properties, has been added to the resources directory. This file configures the Apache Commons Logging framework to use NoOpLog, effectively disabling all logging output from that library.

jib-core/src/main/resources · high confidence

The project now enforces Apache 2.0 copyright headers on all Java files and configures checkstyle suppressions to exclude specific style rules (such as Javadoc, indentation, and line length) that conflict with the Google Java Format or are temporarily relaxed for certain modules like jib-core and test sources. This ensures consistent licensing headers and manages checkstyle violations without breaking the build.

config · high confidence

The builder now uses a new ProgressEventDispatcher and TimerEventDispatcher to emit structured progress and timing events. This replaces manual allocation management and the previous logger-based approach, providing more accurate and crash-resistant progress updates during build steps.

jib-core/src/main/java/com/google/cloud/tools/jib/builder · medium confidence

The internal event dispatching logic has been refactored to improve encapsulation and thread safety. The previous \EventEmitter\ has been replaced by an \EventDispatcher\ pattern, where \EventHandlers\ now explicitly manage a registry of \Handler\ instances. This change ensures that event handlers are non-optional and that the public API no longer exposes the internal \EventHandlers\ class, making the event system more robust and easier to extend.

jib-core/src/main/java/com/google/cloud/tools/jib/event · high confidence

The cache implementation has been refactored to support storing image metadata (manifest lists, manifests, and container configurations) alongside layer data. This change enables the cache to track and retrieve manifest and container configuration data, and supports caching compressed local base image layers. The new structure includes dedicated classes for cache storage, reading, and writing, along with a retry mechanism for file operations to handle transient errors like antivirus interference on Windows.

jib-core/src/main/java/com/google/cloud/tools/jib/cache · high confidence

The Jib CLI tool now correctly reports its version number when queried. A new \VersionInfo\ class has been added to the CLI's Java templates, implementing the picocli \IVersionProvider\ interface. This ensures that the \${version}\ placeholder is properly resolved at build time, allowing users to verify the installed CLI version accurately.

jib-cli/src/java-templates · high confidence

The Jib Maven plugin has been refactored to use a new core API, introducing dedicated Mojo classes (BuildImageMojo, BuildDockerMojo, BuildTarMojo) that delegate to a shared PluginConfigurationProcessor. This change consolidates configuration processing, improves error handling with more descriptive messages, and adds the 'dockerBuild' goal for building container images directly to the Docker daemon. The plugin now also supports configuring Docker client executable paths and environment variables, and handles Maven settings for proxy and server credentials more robustly.

jib-maven-plugin/src/main/java/com/google/cloud/tools/jib/maven · medium confidence

The HTTP client layer in jib-core has been refactored into a new framework that automatically handles insecure connections. The new \FailoverHttpClient\ automatically attempts secure HTTPS, then falls back to insecure HTTPS (disabling certificate validation), and finally to plain HTTP if needed. This improves compatibility with registries that may not support strict TLS, while still allowing users to configure timeouts and retry behavior.

jib-core/src/main/java/com/google/cloud/tools/jib/http · high confidence

The Jib core library introduces two new event types to improve build visibility. ProgressEvent now tracks build progress using allocation units, allowing users to monitor the status of decentralized allocation trees. Additionally, TimerEvent provides detailed timing information for various parts of Jib's execution, including start, lap, and finished states with elapsed duration tracking. These changes enhance the event system by providing more granular insights into build progress and performance metrics.

jib-core/src/main/java/com/google/cloud/tools/jib/event/events · medium confidence

The progress reporting mechanism has been replaced with a new \Allocation\-based system that supports decentralized, asynchronous progress tracking. This introduces a tree structure where progress units are allocated to sub-tasks, allowing for more accurate and granular progress updates. The \ProgressEventHandler\ now uses an \AllocationCompletionTracker\ to manage completion states and provides an \Update\ object containing the overall progress and a list of unfinished leaf tasks. This change improves how build progress is reported to users, ensuring that partial completions are correctly aggregated and displayed.

jib-core/src/main/java/com/google/cloud/tools/jib/event/progress · high confidence

The Jib Gradle plugin's configuration model has been refactored to use Gradle's lazy evaluation features. New parameter classes (such as AuthParameters, BaseImageParameters, ContainerParameters, and the build tasks) now utilize Gradle's Property and Provider types. This change enables lazy evaluation for configuration properties, allowing for more efficient and flexible build script execution within the Gradle plugin.

jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle · high confidence

The plugin configuration validation logic has been refactored into a new \ConfigurationPropertyValidator\ class, which now handles parsing of comma-separated properties and image references. Additionally, credential retrieval has been consolidated into a new \DefaultCredentialRetrievers\ class that manages the order of credential sources, including Docker config files, environment variables, and well-known credential helpers. Several new exception classes have been introduced to provide more specific error messages for invalid configurations, such as \InvalidAppRootException\, \InvalidContainerVolumeException\, and \InvalidWorkingDirectoryException\. The \HelpfulSuggestions\ class has been updated to provide more targeted error messages for common configuration issues.

jib-plugins-common/src/main/java/com/google/cloud/tools/jib/plugins/common · high confidence

The monolithic build configuration has been split into distinct, immutable configuration classes: BuildContext, ContainerConfiguration, ImageConfiguration, and DockerHealthCheck. This refactoring separates the build execution context (cache directories, event handlers, HTTP client) from the declarative container and image settings (ports, volumes, environment, healthchecks). Users will interact with these new, more granular configuration objects when constructing the build process, improving modularity and clarity of the API.

jib-core/src/main/java/com/google/cloud/tools/jib/configuration · high confidence

The registry client code has been restructured into a new set of classes (e.g., \AbstractManifestPuller\, \BlobPusher\, \RegistryAuthenticator\) that implement a \RegistryEndpointProvider\ interface. This refactoring introduces support for pulling and pushing OCI image index manifests and Docker v2.2 manifest lists, while also improving authentication handling by parsing the \WWW-Authenticate\ header to support bearer token flows. Users benefit from more robust handling of various registry error codes and improved compatibility with modern container registries.

jib-core/src/main/java/com/google/cloud/tools/jib/registry · high confidence

The Docker config parser now supports extracting credentials from the 'auths' section using 'username', 'password', or 'identityToken' fields, in addition to the existing 'auth' (base64-encoded) method. This allows users to authenticate with registries that require explicit username/password or identity tokens in their Docker configuration files.

jib-core/src/main/java/com/google/cloud/tools/jib/registry/credentials/json · high confidence

The tarball handling logic in jib-core has been refactored into two new classes: TarExtractor, which handles extracting tar archives with support for symlinks and reproducible timestamps, and TarStreamBuilder, which constructs tar archives using the Apache Commons Compress library with support for long file names and POSIX file modes. This change introduces new public APIs for tar extraction and creation, improving code organization and enabling more robust tar file handling.

jib-core/src/main/java/com/google/cloud/tools/jib/tar · medium confidence

The Gradle wrapper configuration has been updated to use Gradle version 6.9.2. This change ensures that the project uses a specific, consistent version of the Gradle build tool, which may include bug fixes, performance improvements, and new features compared to previous versions.

gradle · high confidence

The integration test resources for the war\_servlet25 project have been updated to use the Jakarta Servlet API (jakarta.servlet) instead of the older javax.servlet, and the test project structure has been renamed to prevent overlaps with other plugin tests. This includes new Java source files, resource files, and web application descriptors that reflect the Jakarta namespace and Servlet 2.5 configuration.

_jib-gradle-plugin/src/integration-test/resources/gradle/projects/war\servlet25 · high confidence

The Jib core now prevents the application from hanging indefinitely when interacting with the Docker CLI. A 10-minute timeout has been added to Docker output reads to avoid deadlocks, particularly on Windows. Additionally, the Docker client resolution logic has been made thread-safe to prevent race conditions during client initialization.

jib-core/src/main/java/com/google/cloud/tools/jib/docker · high confidence

Added Mockito MockMaker configuration for tests; Added Mockito inline mock maker configuration; Added MultithreadedExecutor test utility; Added emptyFile test resource for Docker client executable tests; Added integration test resources for extra directory configuration; Added integration tests for Docker credential helper; Added integration tests for Jib CLI jar and war commands; Added integration tests for Maven plugin build goals; Added integration tests for container building and multi-platform support; Added integration tests for registry client operations; Added multi-module Maven test fixtures for complex and simple services; Added multi-service test fixtures for Jib Gradle plugin; Added test coverage for filesystem utilities; Added test coverage for the Jib cache module; Added test fixture for Java platform dependency handling; Added test fixtures for Jib CLI buildfile parsing and layer configuration; Added test fixtures for Skaffold configuration; Added test fixtures for a Servlet 2.5 WAR project; Added test helper classes for Jib API; Added test helpers for HTTP requests and container builder configuration; Added test resource files for JIB build plan; Added test resources for Docker config, OCI manifests, and metadata; Added test resources for Jib CLI WAR exploded mode; Added test resources for Maven plugin configuration scenarios; Added test resources for Servlet 2.5 with Tomcat 10; Added test resources for core functionality; Added test resources for exploded WAR structure; Added test resources for extra directories and file timestamp configuration; Added test resources for image extraction and caching; Added test resources for integration testing; Added test resources for lazy evaluation; Added test resources for multi-module Spring Boot project; Added test resources for multi-service Gradle project; Added test resources for standard jar explode mode; Added test resources for webapp integration tests; Added test service provider for DockerClient; Added test utilities for integration testing; Added tests for CLI logging behavior; Added tests for CredentialRetrieverFactory; Added tests for Docker client and manifest parsing; Added tests for Docker config credential retrieval; Added tests for JAR file processing in the CLI; Added tests for Jib CLI buildfile spec parsing and layer handling; Added tests for Jib CLI components; Added tests for JsonTemplateMapper; Added tests for Skaffold Gradle plugin tasks; Added tests for Skaffold integration Mojos; Added tests for build plan API classes; Added tests for global Jib configuration; Added tests for progress tracking components; Added tests for the Gradle plugin configuration and tasks; Added tests for the new HTTP client framework; Added tests for the new logging subsystem; Added unit tests for CountingDigestOutputStream; Added unit tests for JSON template serialization and deserialization; Added unit tests for Jib plugins-common components; Added unit tests for JibSystemProperties; Added unit tests for LogEvent and ProgressEvent; Added unit tests for Maven plugin configuration and settings handling; Added unit tests for TarExtractor and TarStreamBuilder; Added unit tests for WAR file processing and container builder integration; Added unit tests for builder step classes; Added unit tests for image building and tarball generation; Added unit tests for progress and timer event dispatchers; Added unit tests for registry client components; Added unit tests for the Blob class; Added unit tests for the EventHandlers component; Added unit tests for the Jib core API classes; Mock Docker environment for integration tests; New integration tests for Gradle plugin build scenarios; Updated integration test resources for the jib-gradle-plugin; Updated test resources for Jib core and plugins.

The build configuration has been updated with new dependency versions, including Jackson BOM 2.21.1, Guava 32.1.2-jre, and Mockito 4.11.0. Additionally, example projects for Dropwizard, Ktor, Micronaut, and Spring Boot have been added to demonstrate Jib integration with various Java frameworks.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 66 → 69 (+2.8)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 84 → 90 (+5.4)
• Architecture 100 → 88 (-11.7)
• Maturity 60 → 60 (+0.0)
• Readiness 71 → 83 (+12.6)
• Security 65 → 69 (+4.1)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (jib-core/src/main/java/com/google/cloud/tools/jib/docker/CliDockerClient.java)
• Duplicated block (10 lines × 3) (jib-cli/src/main/java/com/google/cloud/tools/jib/cli/Build.java)
• Duplicated block (10 lines × 3) (jib-cli/src/main/java/com/google/cloud/tools/jib/cli/Build.java)
• Duplicated block (10 lines × 4) (jib-build-plan/src/main/java/com/google/cloud/tools/jib/api/buildplan/ContainerBuildPlan.java)
• Duplicated block (11 lines × 2) (jib-cli/src/main/java/com/google/cloud/tools/jib/cli/jar/JarLayers.java)
• Duplicated block (11 lines × 2) (jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/GradleProjectProperties.java)
• Duplicated block (11 lines × 3) (jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/BuildDockerTask.java)
• Duplicated block (12 lines × 2) (jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/BuildImageTask.java)
• Duplicated block (12 lines × 2) (jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/TaskCommon.java)
• Duplicated block (13 lines × 2) (jib-core/src/main/java/com/google/cloud/tools/jib/cache/CacheStorageReader.java)
• Duplicated block (13 lines × 2) (jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/BuildImageTask.java)
• Duplicated block (14 lines × 3) (jib-maven-plugin/src/main/java/com/google/cloud/tools/jib/maven/BuildDockerMojo.java)
• Duplicated block (17 lines × 3) (jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/BuildDockerTask.java)
• Duplicated block (17 lines × 3) (jib-maven-plugin/src/main/java/com/google/cloud/tools/jib/maven/BuildDockerMojo.java)
• Duplicated block (6 lines × 2) (jib-cli/src/main/java/com/google/cloud/tools/jib/cli/jar/SpringBootPackagedProcessor.java)
• Duplicated block (6 lines × 2) (jib-maven-plugin/src/main/java/com/google/cloud/tools/jib/maven/MavenProjectProperties.java)
• Duplicated block (7 lines × 2) (jib-cli/src/main/java/com/google/cloud/tools/jib/cli/Jar.java)
• Duplicated block (7 lines × 2) (jib-core/src/main/java/com/google/cloud/tools/jib/api/JibContainerBuilder.java)
• …and 38 more

• ClassTooLong: JibPluginConfiguration (jib-maven-plugin/src/main/java/com/google/cloud/tools/jib/maven/JibPluginConfiguration.java)
• ClassTooLong: MavenProjectProperties (jib-maven-plugin/src/main/java/com/google/cloud/tools/jib/maven/MavenProjectProperties.java)
• ClassTooLong: PluginConfigurationProcessor (jib-plugins-common/src/main/java/com/google/cloud/tools/jib/plugins/common/PluginConfigurationProcessor.java)
• ClassTooLong: StepsRunner (jib-core/src/main/java/com/google/cloud/tools/jib/builder/steps/StepsRunner.java)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no installation or build instructions (README.md)
• Duplicated block (109 lines × 2) (jib-core/src/main/java/com/google/cloud/tools/jib/image/json/OciManifestTemplate.java)
• Duplicated block (12 lines × 2) (jib-cli/src/main/java/com/google/cloud/tools/jib/cli/jar/JarLayers.java)
• Duplicated block (13 lines × 3) (jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/BuildDockerTask.java)
• Duplicated block (14 lines × 2) (jib-cli/src/integration-test/resources/warTest/src/main/java/example/HelloWorld.java)
• Duplicated block (15 lines × 2) (jib-core/src/main/java/com/google/cloud/tools/jib/tar/TarExtractor.java)
• Duplicated block (15 lines × 2) (jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/TaskCommon.java)
• Duplicated block (17 lines × 3) (jib-cli/src/main/java/com/google/cloud/tools/jib/cli/Build.java)
• Duplicated block (17 lines × 3) (jib-maven-plugin/src/main/java/com/google/cloud/tools/jib/maven/BuildDockerMojo.java)
• Duplicated block (18 lines × 3) (jib-cli/src/main/java/com/google/cloud/tools/jib/cli/Build.java)
• Duplicated block (19 lines × 2) (jib-core/src/main/java/com/google/cloud/tools/jib/cache/CacheStorageReader.java)
• Duplicated block (19 lines × 2) (jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/GradleProjectProperties.java)
• Duplicated block (5 lines × 2) (jib-maven-plugin/src/main/java/com/google/cloud/tools/jib/maven/MavenProjectProperties.java)
• Duplicated block (6 lines × 2) (jib-plugins-common/src/main/java/com/google/cloud/tools/jib/plugins/common/SkaffoldInitOutput.java)
• Duplicated block (7 lines × 2) (jib-cli/src/main/java/com/google/cloud/tools/jib/cli/jar/SpringBootPackagedProcessor.java)
• …and 201 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

GoogleContainerTools/jib was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.