build

#!/usr/bin/env bash
set -eu

readonly IMAGE_NAME="ghcr.io/datadog/dd-trace-java-docker-build"

readonly BASE_VARIANTS=(8 11 17 21)

readonly VARIANTS=(
    7
    zulu8
    zulu11
    oracle8
    ibm8
    semeru8
    semeru11
    semeru17
    ubuntu17
    graalvm17
    graalvm21
)

# Use buildkit to match CI as closely as possible.
export DOCKER_BUILDKIT=1

function compute_metadata() {
    # Get a TAG_PREFIX for every built image. Resulting images will be tagged as
    # ${TAG_PREFIX}${variant}, where ${variant} is base, latest or a JVM name.
    # ${TAG_PREFIX} is empty for the master branch, and it is a sanitized version
    # of the git branch otherwise. Sanitization is a conversion to lowercase, and
    # replacing all slashes with underscores, which is the same sanitization Docker
    # Hub does for their own builds.
    GIT_BRANCH="${GITHUB_REF_NAME:-$(git branch --show-current)}"
    # Fallback to local if there is no branch (e.g. dettached development)
    readonly GIT_BRANCH="${GIT_BRANCH:-local}"
    if [[ ${GIT_BRANCH} = master ]]; then
        TAG_PREFIX=""
    else
        TAG_PREFIX="${GIT_BRANCH}-"
        TAG_PREFIX="${TAG_PREFIX,,}"
        TAG_PREFIX="${TAG_PREFIX//\//_}"
    fi

    # Cache the same RFC 3339 timestamp for re-use in all images built in the same batch.
    BUILD_DATE="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
    GIT_HEAD_REF="$(git show-ref --head --hash ^HEAD)"
}

# docker build wrapper with common arguments
# See https://github.com/opencontainers/image-spec/blob/main/annotations.md for common labels
# See https://docs.github.com/en/packages/learn-github-packages/connecting-a-repository-to-a-package
function docker_build() {
    local target="$1"
    local tag="$2"
    shift
    shift
    docker build \
        --platform linux/amd64 \
        --label org.opencontainers.image.created="$BUILD_DATE" \
        --label org.opencontainers.image.source=https://github.com/DataDog/dd-trace-java-docker-build \
        --label org.opencontainers.image.revision="$GIT_HEAD_REF" \
        --target "$target" \
        --tag "$tag" \
        "$@" \
        .
}

function image_name() {
    local variant="${1}"
    echo -n "${IMAGE_NAME}:${TAG_PREFIX}${variant}"
}

function do_build() {
    compute_metadata
    docker_build base "$(image_name base)"
    docker_build full "$(image_name latest)"
    if [ -n "${GITHUB_OUTPUT+unset}" ]; then
        # Make LATEST_IMAGE_TAG available to later GitHub Actions jobs
        echo "LATEST_IMAGE_TAG=$(image_name latest)" >>"$GITHUB_OUTPUT"
    fi
    for variant in "${BASE_VARIANTS[@]}"; do
        variant_lower="${variant,,}"
        docker tag "$(image_name base)" "$(image_name "${variant_lower}")"
    done
    for variant in "${VARIANTS[@]}"; do
        variant_upper="${variant^^}"
        variant_lower="${variant,,}"
        docker_build variant "$(image_name "$variant_lower")" \
            --build-arg "VARIANT_UPPER=$variant_upper" \
            --build-arg "VARIANT_LOWER=$variant_lower"
    done
}

function list_layers() {
    local image="${1}"
    docker inspect "${image}" | jq -r '.[].RootFS.Layers[]'
}

function do_test() {
    local image_base image_variant
    compute_metadata
    image_base="$(image_name base)"
    mapfile -t base_layers < <(list_layers "${image_base}")
    for variant in "${BASE_VARIANTS[@]}" "${VARIANTS[@]}"; do
        image_variant="$(image_name "${variant}")"
        echo "Checking shared layers for ${image_variant}..."
        mapfile -t other_layers < <(list_layers "${image_variant}")
        declare -A other_map
        for ol in "${other_layers[@]}"; do
            other_map[$ol]=true
        done
        for bl in "${base_layers[@]}"; do
            if [[ ${other_map[$bl]:-} != true ]]; then
                echo "Layer $bl from $image_base not found in $image_variant"
                return 1
            fi
        done
    done

    for variant in base latest "${BASE_VARIANTS[@]}" "${VARIANTS[@]}"; do
        image_variant="$(image_name "${variant}")"
        echo "Running smoke tests for ${image_variant}..."
        docker run \
            --user "$(id -u):$(id -g)" \
            --workdir /work \
            --volume "$(pwd):/work" \
            --rm \
            "${image_variant}" \
            /work/build --inner-test "${variant}"
    done
}

function do_inner_test() {
    local variant="${1}"
    variant_lower="${variant,,}"
    variant_upper="${variant^^}"
    set -x
    "$JAVA_HOME/bin/java" -version
    "$JAVA_8_HOME/bin/java" -version
    "$JAVA_11_HOME/bin/java" -version
    "$JAVA_17_HOME/bin/java" -version
    "$JAVA_21_HOME/bin/java" -version
    if [[ $variant != base && $variant != latest ]]; then
        env_lower="JAVA_${variant_lower}_HOME"
        env_upper="JAVA_${variant_upper}_HOME"
        "${!env_lower}/bin/java" -version
        "${!env_upper}/bin/java" -version
    fi
}

function do_describe() {
    local image
    compute_metadata
    image="$(image_name latest)"
    docker run \
        --user "$(id -u):$(id -g)" \
        --workdir /work \
        --volume "$(pwd):/work" \
        --rm \
        "$image" \
        /work/build --inner-describe
}

function do_inner_describe() {
    echo "# Contents"
    echo
    echo "## Operating System"
    echo
    echo "* $(lsb_release --description --short)"
    echo
    echo "## Tools"
    echo
    echo "* bash $BASH_VERSION"
    echo "* $(git --version)"
    echo "* $(docker --version)"
    echo "* $(docker compose version)"
    echo "* $(yq --version)"
    echo "* datadog-ci $(datadog-ci version)"
    echo
    echo "## JDKs"
    echo
    for variant in "${BASE_VARIANTS[@]}" "${VARIANTS[@]}"; do
        variant_upper="${variant^^}"
        env_upper="JAVA_${variant_upper}_HOME"
        echo "* $env_upper"
        echo '```'
        "${!env_upper}/bin/java" -version 2>&1
        echo '```'
        echo
    done
    echo
}

function do_push() {
    local tag
    compute_metadata
    for tag in base latest "${BASE_VARIANTS[@]}" "${VARIANTS[@]}"; do
        tag="${tag,,}"
        tag="$(image_name "${tag}")"
        docker push "$tag"
    done
}

function do_tag() {
    local tag token version
    TAG_PREFIX=
    echo "Pulling latest images"
    for tag in base latest "${BASE_VARIANTS[@]}" "${VARIANTS[@]}"; do
        tag="${tag,,}"
        tag="$(image_name "${tag}")"
        docker pull "$tag"
    done
    version="$(date +%y.%m)"
    echo "Tagging version $version"
    for tag in base latest "${BASE_VARIANTS[@]}" "${VARIANTS[@]}"; do
        tag="${tag,,}"
        tag="$(image_name "${tag}")"
        new_tag="${tag/:/:v$version-}"
        docker tag "$tag" "$new_tag"
        docker push "$new_tag"
    done
}

if [[ -z ${1:-} ]]; then
    do_build
elif [[ ${1} = "--test" ]]; then
    do_test
elif [[ ${1} = "--inner-test" ]]; then
    shift
    do_inner_test "$@"
elif [[ ${1} = "--describe" ]]; then
    do_describe
elif [[ ${1} = "--inner-describe" ]]; then
    do_inner_describe
elif [[ ${1} = "--push" ]]; then
    do_push
elif [[ ${1} = "--tag" ]]; then
    do_tag
fi