Docker: unified build_docker.sh

docker/build/pre_cyber.x86_64.dockerfile → docker/build/base.x86_64.dockerfile

-ARG BASE_IMAGE=nvidia/cuda:10.2-cudnn7-devel-ubuntu18.04
+ARG BASE_IMAGE
 FROM ${BASE_IMAGE}
 
-ENV TENSORRT_VERSION 7.0.0-1+cuda10.2
+ARG TENSORRT_VERSION
 
 #For only running TensorRT C++ applications:
 #   sudo apt-get install libnvinfer7 libnvonnxparsers7 libnvparsers7 libnvinfer-plugin7
@@ -26,5 +26,5 @@ RUN apt-get -y update \
     && rm -f /etc/apt/sources.list.d/nvidia-ml.list \
     && rm -f /etc/apt/sources.list.d/cuda.list
 
-# NVIDIA apt sources.list removed to speed up build
-# Remove static TensorRT libraries
+# 1) NVIDIA apt sources.list removed to speed up build
+# 2) Static CUDA libraries removal ?

docker/build/build_cyber.sh

-#!/usr/bin/env bash
-
-###############################################################################
-# Copyright 2019 The Apollo Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-###############################################################################
-# Usage:
-#   ./build_cyber.sh [-l] -f <cyber.dockerfile> [-m <build|download>]
-# E.g.,
-#   ./build_cyber.sh -f ./cyber.aarch64.dockerfile -m download
-
-# Fail on first error.
-set -euo pipefail
-
-SUPPORTED_ARCHS=" x86_64 aarch64 "
-REPO=apolloauto/apollo
-UBT_LTS="18.04"
-LOCAL_DEV_TAG="${REPO}:local_cyber_dev"
-
-STAGE="cyber"
-HOST_ARCH="$(uname -m)"
-TARGET_ARCH=
-
-LOCAL_DEV_FLAG="no"
-MODE="download"
-GEOLOC="us"
-CLEAN_MODE="no"
-DOCKERFILE=""
-TAB="    "
-
-function print_usage() {
-    local prog_name=$(basename "$0")
-    echo "Usage:"
-    echo "${TAB}${prog_name} [-l] [-c] -f <cyber_dockerfile> [-m <build|download>] [-g <us|cn>]"
-    echo "${TAB}${prog_name} -h/--help    # Show this message"
-    echo "E.g.,"
-    echo "${TAB}${prog_name} -f cyber.x86_64.dockerfile -m build"
-    echo "${TAB}${prog_name} -l -f cyber.aarch64.dockerfile -m download"
-}
-
-function docker_experimental_check() {
-    local JQ_CMD="$(command -v jq)"
-    if [ -z "${JQ_CMD}" ]; then
-        echo "Oops, command 'jq' not found."
-        echo "For ubuntu, you can install it via:"
-        echo "  sudo apt-get -y update && sudo apt-get -y install jq"
-        exit 1
-    fi
-    local daemon_cfg="/etc/docker/daemon.json"
-    local enabled="$(jq '.experimental' ${daemon_cfg} )"
-    if [ "${enabled}" != "true" ]; then
-        echo "Experimental features should be enabled to run Apollo docker build."
-        echo "Please perform the following two steps to have it enabled:"
-        echo "  1) Add '\"experimental\": true' to '${daemon_cfg}'"
-        echo "     The simplest ${daemon_cfg} looks like:"
-        echo "       {"
-        echo "           \"experimental\": true "
-        echo "       }"
-        echo "  2) Restart docker daemon. E.g., 'sudo systemctl restart docker'"
-        exit 1
-    fi
-}
-
-function determine_target_arch() {
-    local dockerfile="$( basename "$1" )"
-    IFS='.' read -ra __arr <<< "${dockerfile}"
-    if [[ ${#__arr[@]} -ne 3 ]]; then
-        echo "Expected dockerfile with name [prefix_]<target>.<arch>.dockerfile"
-        echo "Got ${dockerfile}. Exiting..."
-        exit 1
-    fi
-    IFS=' '
-
-    local arch="${__arr[1]}"
-    if [[ "${SUPPORTED_ARCHS}" != *" ${arch} "* ]]; then
-        echo "Unsupported architecture: ${arch}. Allowed values:${SUPPORTED_ARCHS}"
-        exit 1
-    fi
-    TARGET_ARCH="${arch}"
-    return 0
-}
-
-function parse_arguments() {
-    if [[ $# -eq 0 ]] || [[ "$1" == "--help" ]]; then
-        print_usage
-        exit 0
-    fi
-    while getopts "hlcf:m:g:" opt; do
-        case $opt in
-            l)
-                LOCAL_DEV_FLAG="yes"
-                ;;
-            f)
-                DOCKERFILE=$OPTARG
-                ;;
-            m)
-                MODE=$OPTARG
-                ;;
-            g)
-                GEOLOC=$OPTARG
-                ;;
-            c)
-                CLEAN_MODE="yes"
-                ;;
-            h)
-                print_usage
-                exit 1
-                ;;
-            *)
-                echo "Unknown option: -$opt"
-                print_usage
-                exit 1
-                ;;
-        esac
-    done
-}
-
-function check_arguments() {
-    if [[ "${MODE}" == "build" ]]; then
-        echo "Build all dependencies from source code"
-    elif [[ "${MODE}" == "download" ]]; then
-        echo "Optimize installation of some dependencies from prebuilt packages"
-    else
-        echo "Installation mode \"$MODE\" not supported"
-        exit 1
-    fi
-    if [[ "${GEOLOC}" == "cn" ]]; then
-        echo "Docker image built for CN users"
-    else
-        GEOLOC="us"
-    fi
-
-    if [[ -z "${DOCKERFILE}" ]]; then
-        echo "Dockfile not specified"
-        exit 1
-    fi
-
-    # Set and check target arch
-    determine_target_arch "${DOCKERFILE}"
-    if [[ "${TARGET_ARCH}" != "${HOST_ARCH}" ]]; then
-        echo "[WARNING] Host arch (${HOST_ARCH}) != Target Arch (${TARGET_ARCH}) " \
-             "for dockerfile \"$DOCKERFILE\""
-        echo "[WARNING] Make sure you have executed the following command:"
-        echo "docker run --rm --privileged multiarch/qemu-user-static --reset -p yes"
-    fi
-}
-
-parse_arguments "$@"
-check_arguments
-docker_experimental_check
-
-CONTEXT="$(dirname "${BASH_SOURCE[0]}")"
-
-TIME=$(date +%Y%m%d_%H%M)
-
-TAG=""
-function determine_tag() {
-    local docker_fn="$(basename ${DOCKERFILE})"
-    local myid="${docker_fn%%.*}"
-    if [[ "${myid}" == "pre_cyber" ]]; then
-        local cuda_ver="10.2"
-        local trt_ver="7"
-        if [[ "${TARGET_ARCH}" == "x86_64" ]]; then
-            local cudnn_ver="7"
-            TAG="${REPO}:cuda${cuda_ver}-cudnn${cudnn_ver}-trt${trt_ver}-devel-${UBT_LTS}-${TARGET_ARCH}"
-        else
-            local cudnn_ver="8"
-            TAG="${REPO}:L4T-cuda${cuda_ver}-cudnn${cudnn_ver}-trt${trt_ver}-devl-${UBT_LTS}-${TIME}"
-        fi
-    else
-        TAG="${REPO}:cyber-${TARGET_ARCH}-${UBT_LTS}-${TIME}"
-    fi
-}
-
-determine_tag
-
-echo "=====.=====.=====.=====  Docker Image Build for Cyber =====.=====.=====.====="
-echo "|  Docker build ${TAG} CLEAN_MODE=${CLEAN_MODE}"
-echo "|  ${TAB}using dockerfile=${DOCKERFILE}"
-echo "|  ${TAB}TARGET_ARCH=${TARGET_ARCH}, HOST_ARCH=${HOST_ARCH}"
-echo "|  ${TAB}INSTALL_MODE=${MODE}, GEOLOC=${GEOLOC}"
-echo "=====.=====.=====.=====.=====.=====.=====.=====.=====.=====.=====.=====.====="
-
-EXTRA_ARGS="--squash"
-
-if [[ "${CLEAN_MODE}" == "yes" ]]; then
-    EXTRA_ARGS="${EXTRA_ARGS} --no-cache"
-fi
-
-docker build ${EXTRA_ARGS} -t "${TAG}" --build-arg INSTALL_MODE="${MODE}" \
-    --build-arg GEOLOC="${GEOLOC}" \
-    --build-arg BUILD_STAGE="${STAGE}" \
-    -f "${DOCKERFILE}" "${CONTEXT}"
-echo "Built new image ${TAG}"
-
-if [[ "$LOCAL_DEV_FLAG" == "yes" ]]; then
-    docker image tag "${TAG}" "${LOCAL_DEV_TAG}"
-    echo "Also tagged as ${LOCAL_DEV_TAG}"
-fi

docker/build/build_dev.sh

-#!/usr/bin/env bash
-
-###############################################################################
-# Copyright 2018 The Apollo Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-###############################################################################
-# Usage:
-#   ./build_dev.sh [-l] -f <dev.dockerfile> [-m <build|download>] [ -g <us|cn> ]
-# Where
-#   -l      Also tag the newly built image as apolloauto/apollo:local_dev
-#   -g      Support US/CN geographical settings
-# E.g.,
-#   ./build_dev.sh -f ./dev.x86_64.dockerfile -g cn
-#
-ARCH=$(uname -m)
-REPO=apolloauto/apollo
-LOCAL_DEV_TAG="${REPO}:local_dev"
-
-LOCAL_DEV_FLAG="no"
-MODE="download"
-GEOLOC="us"
-CLEAN_MODE="no"
-STAGE="dev"
-DOCKERFILE=""
-TAB="    "
-
-function print_usage() {
-    local prog_name=$(basename "$0")
-    echo "Usage:"
-    echo "${TAB}${prog_name} [-l] [-c] -f <dev_dockerfile> [-m <build|download>] [-g <us|cn>]"
-    echo "${TAB}${prog_name} -h/--help    # Show this message"
-    echo "E.g.,"
-    echo "${TAB}${prog_name} -f dev.x86_64.dockerfile -m build"
-    echo "${TAB}${prog_name} -l -f dev.aarch64.dockerfile -m download"
-}
-
-function parse_arguments() {
-    if [[ $# -eq 0 ]] || [[ "$1" == "--help" ]]; then
-        print_usage
-        exit 0
-    fi
-    while getopts "hlcf:m:g:" opt; do
-        case $opt in
-            l)
-                LOCAL_DEV_FLAG="yes"
-                ;;
-            f)
-                DOCKERFILE=$OPTARG
-                ;;
-            m)
-                MODE=$OPTARG
-                ;;
-            g)
-                GEOLOC=$OPTARG
-                ;;
-            c)
-                CLEAN_MODE="yes"
-                ;;
-            h)
-                print_usage
-                exit 1
-                ;;
-            *)
-                echo "Unknown option: -$opt"
-                print_usage
-                exit 1
-                ;;
-        esac
-    done
-}
-
-function check_arguments() {
-    if [[ "${MODE}" == "build" ]]; then
-        echo "Build all dependencies from source code"
-    elif [[ "${MODE}" == "download" ]]; then
-        echo "Optimize installation of some dependencies from prebuilt packages"
-    else
-        echo "Installation mode \"$MODE\" not supported"
-        exit 1
-    fi
-    if [[ "${GEOLOC}" == "cn" ]]; then
-        echo "Docker image built for CN users"
-    else
-        GEOLOC="us"
-    fi
-
-    if [[ -z "${DOCKERFILE}" ]]; then
-        echo "Dockfile not specified"
-        exit 1
-    fi
-    if [[ "$DOCKERFILE" == *${ARCH}* ]]; then
-        echo "Dockerfile to build: ${DOCKERFILE}"
-    else
-        echo "Dockerfile \"$DOCKERFILE\" doesn't match current architecture."
-        exit 1
-    fi
-}
-
-function docker_experimental_check() {
-    local JQ_CMD="$(command -v jq)"
-    if [ -z "${JQ_CMD}" ]; then
-        echo "Oops, command 'jq' not found."
-        echo "For ubuntu, you can install it via:"
-        echo "  sudo apt-get -y update && sudo apt-get -y install jq"
-        exit 1
-    fi
-    local daemon_cfg="/etc/docker/daemon.json"
-    local enabled="$(jq '.experimental' ${daemon_cfg} )"
-    if [ "${enabled}" != "true" ]; then
-        echo "Experimental features should be enabled to run Apollo docker build."
-        echo "Please perform the following two steps to have it enabled:"
-        echo "  1) Add '\"experimental\": true' to '${daemon_cfg}'"
-        echo "     The simplest ${daemon_cfg} looks like:"
-        echo "       {"
-        echo "           \"experimental\": true "
-        echo "       }"
-        echo "  2) Restart docker daemon. E.g., 'sudo systemctl restart docker'"
-        exit 1
-    fi
-}
-
-parse_arguments "$@"
-check_arguments
-docker_experimental_check
-
-CONTEXT="$(dirname "${BASH_SOURCE[0]}")"
-TIME=$(date +%Y%m%d_%H%M)
-TAG="${REPO}:dev-${ARCH}-18.04-${TIME}"
-
-# Fail on first error.
-set -e
-echo "=====.=====.=====.=====  Docker Image Build for Devel =====.=====.=====.====="
-echo "|  Docker build ${TAG} CLEAN_MODE=${CLEAN_MODE}"
-echo "|  ${TAB}using dockerfile=${DOCKERFILE}"
-echo "|  ${TAB}INSTALL_MODE=${MODE}, GEOLOC=${GEOLOC}"
-echo "=====.=====.=====.=====.=====.=====.=====.=====.=====.=====.=====.=====.====="
-
-EXTRA_ARGS=""
-
-if [[ "${CLEAN_MODE}" == "yes" ]]; then
-    EXTRA_ARGS="--no-cache"
-fi
-
-docker build ${EXTRA_ARGS} -t "${TAG}" --build-arg INSTALL_MODE="${MODE}" \
-    --build-arg GEOLOC="${GEOLOC}" \
-    --build-arg BUILD_STAGE="${STAGE}" \
-    -f "${DOCKERFILE}" "${CONTEXT}"
-echo "Built new image ${TAG}"
-
-if [[ "$LOCAL_DEV_FLAG" == "yes" ]]; then
-    docker image tag "${TAG}" "${LOCAL_DEV_TAG}"
-    echo "Also tagged as ${LOCAL_DEV_TAG}"
-fi

docker/build/build_docker.sh

+#! /usr/bin/env bash
+
+APOLLO_REPO="apolloauto/apollo"
+
+SUPPORTED_ARCHS=(
+    x86_64
+    aarch64
+)
+
+HOST_ARCH="$(uname -m)"
+TARGET_ARCH=
+
+SUPPORTED_STAGES=(
+    base
+    cyber
+    dev
+)
+
+SUPPORTED_DIST=(
+    stable
+    testing
+)
+
+DOCKERFILE=
+TARGET_STAGE=
+IMAGE_IN=
+IMAGE_OUT=
+
+GEOLOC="us"
+MODE="download"
+DIST="stable"
+BUILD_CLEAN=0
+DRY_RUN=0
+
+TENSORRT_VERSION=""
+UBUNTU_LTS="18.04"
+
+TIMESTAMP="$(date +%Y%m%d_%H%M)"
+
+TAB="    "
+
+function check_experimental_docker() {
+    local jq_cmd="$(command -v jq)"
+    if [ -z "${jq_cmd}" ]; then
+        echo "Oops, command 'jq' not found."
+        echo "For Ubuntu, you can install it via:"
+        echo "  sudo apt-get -y update && sudo apt-get -y install jq"
+        exit 1
+    fi
+    local daemon_cfg="/etc/docker/daemon.json"
+    local enabled="$(jq '.experimental' ${daemon_cfg} )"
+    if [ "${enabled}" != "true" ]; then
+        echo "Experimental features should be enabled to run Apollo docker build."
+        echo "Please perform the following two steps to have it enabled:"
+        echo "  1) Add '\"experimental\": true' to '${daemon_cfg}'"
+        echo "     The simplest ${daemon_cfg} looks like:"
+        echo "       {"
+        echo "           \"experimental\": true "
+        echo "       }"
+        echo "  2) Restart docker daemon. E.g., 'sudo systemctl restart docker'"
+        exit 1
+    fi
+}
+
+function cpu_arch_support_check() {
+    local arch="$1"
+    for entry in "${SUPPORTED_ARCHS[@]}"; do
+        if [[ "${entry}" == "${arch}" ]]; then
+            return
+        fi
+    done
+    echo "Unsupported CPU architecture: ${arch}. Exiting..."
+    exit 1
+}
+
+function build_stage_check() {
+    local stage="$1"
+    for entry in "${SUPPORTED_STAGES[@]}"; do
+        if [[ "${entry}" == "${stage}" ]]; then
+            return
+        fi
+    done
+    echo "Unsupported build stage: ${stage}. Exiting..."
+    exit 1
+}
+
+function determine_target_arch_and_stage() {
+    local dockerfile="$(basename "$1")"
+    IFS='.' read -ra __arr <<< "${dockerfile}"
+    if [[ ${#__arr[@]} -ne 3 ]]; then
+        echo "Expected dockerfile with name [prefix_]<target>.<arch>.dockerfile"
+        echo "Got ${dockerfile}. Exiting..."
+        exit 1
+    fi
+    IFS=' '
+
+    local arch="${__arr[1]}"
+    cpu_arch_support_check "${arch}"
+    TARGET_ARCH="${arch}"
+    if [[ "${TARGET_ARCH}" != "${HOST_ARCH}" ]]; then
+        echo "[WARNING] HOST_ARCH(${HOST_ARCH}) != TARGET_ARCH(${TARGET_ARCH})"
+        echo "[WARNING] Make sure you have executed the following command:"
+        echo "[WARNING] ${TAB}docker run --rm --privileged multiarch/qemu-user-static --reset -p yes"
+    fi
+
+    local stage="${__arr[0]##*_}"
+    build_stage_check "${stage}"
+    TARGET_STAGE="${stage}"
+}
+
+function determine_images_for_x86_64() {
+    local stage="$1" # Build stage, base/cyber/dev
+    local dist="$2"  # stable or testing
+
+    if [[ "${dist}" == "stable" ]]; then
+        local cuda_ver=10.2
+        local cudnn_ver=7
+        TENSORRT_VERSION="7.0.0-1+cuda${cuda_ver}"
+    else
+        local cuda_ver=11.1
+        local cudnn_ver=8
+        TENSORRT_VERSION="7.2.1-1+cuda${cuda_ver}"
+    fi
+    local trt_ver="${TENSORRT_VERSION%%.*}"
+
+    local base_image="${APOLLO_REPO}:cuda${cuda_ver}-cudnn${cudnn_ver}-trt${trt_ver}-devel-${UBUNTU_LTS}-x86_64"
+    if [[ "${stage}" == "base" ]]; then
+        IMAGE_IN="nvidia/cuda:${cuda_ver}-cudnn${cudnn_ver}-devel-ubuntu${UBUNTU_LTS}"
+        IMAGE_OUT="${base_image}"
+    elif [[ "${stage}" == "cyber" ]]; then
+        IMAGE_IN="${base_image}"
+        if [[ "${dist}" == "stable" ]]; then
+            IMAGE_OUT="${APOLLO_REPO}:cyber-x86_64-${UBUNTU_LTS}-${TIMESTAMP}"
+        else
+            IMAGE_OUT="${APOLLO_REPO}:cyber-x86_64-${UBUNTU_LTS}-testing-${TIMESTAMP}"
+        fi
+    elif [[ "${stage}" == "dev" ]]; then
+        if [[ "${dist}" == "stable" ]]; then
+            IMAGE_IN="${APOLLO_REPO}:cyber-x86_64-${UBUNTU_LTS}-20201029_0047"
+            IMAGE_OUT="${APOLLO_REPO}:dev-x86_64-${UBUNTU_LTS}-${TIMESTAMP}"
+        else
+            IMAGE_IN="${APOLLO_REPO}:cyber-x86_64-${UBUNTU_LTS}-testing-YYYYMMDD_HHmm"
+            IMAGE_OUT="${APOLLO_REPO}:dev-x86_64-${UBUNTU_LTS}-testing-${TIMESTAMP}"
+        fi
+    else
+        echo "Unknown build stage: ${stage}. Exiting..."
+        exit 1
+    fi
+}
+
+function determine_images_for_aarch64() {
+    local stage="$1"
+    local cuda_ver=10.2
+    local cudnn_ver=8
+    local trt_ver=7
+
+    local BASE_FMT ="L4T-cuda${cuda_ver}-cudnn${cuda_ver}-trt${trt_ver}-devel-${UBUNTU_LTS}"
+    local CYBER_FMT="cyber-aarch64-${UBUNTU_LTS}"
+
+    if [[ "${stage}" == "base" ]]; then
+        # Ref: https://developer.nvidia.com/embedded/linux-tegra
+        IMAGE_IN="nvcr.io/nvidia/l4t-base:r32.4.3"
+        IMAGE_OUT="${APOLLO_REPO}:${BASE_FMT}-${TIMESTAMP}"
+    elif [[ "${stage}" == "cyber" ]]; then
+        IMAGE_IN="${APOLLO_REPO}:${BASE_FMT}-20200928_1000"
+        IMAGE_OUT="${APOLLO_REPO}:${CYBER_FMT}-${TIMESTAMP}"
+    elif [[ "${stage}" == "dev" ]]; then
+        IMAGE_IN="${APOLLO_REPO}:${CYBER_FMT}-20200929_0922"
+        IMAGE_OUT="${APOLLO_REPO}:dev-aarch64-${UBUNTU_LTS}-${TIMESTAMP}"
+    else
+        echo "Unknown build stage: ${stage}. Exiting..."
+        exit 1
+    fi
+}
+
+function print_usage() {
+    local prog="$(basename $0)"
+    echo "Usage:"
+    echo "${TAB}${prog} -f <Dockerfile> [Options]"
+    echo "Available options:"
+    echo "${TAB}-c,--clean  Use \"--no-cache=true\" for docker build"
+    echo "${TAB}-m,--mode   \"build\" for build everything from source if possible, \"download\" for using prebuilt ones"
+    echo "${TAB}-g,--geo    Enable geo-specific mirrors to speed up build. Currently \"cn\" and \"us\" are supported."
+    echo "${TAB}-d,--dist   Whether to build stable(\"stable\") or experimental(\"testing\") Docker images"
+    echo "${TAB}--dry       Dry run (for testing purpose)"
+    echo "${TAB}-h,--help   Show this message and exit"
+    echo "E.g.,"
+    echo "${TAB}${prog} -f cyber.x86_64.dockerfile -m build -g cn"
+    echo "${TAB}${prog} -f dev.aarch64.dockerfile -m download -b testing"
+}
+
+function check_opt_arg() {
+    local opt="$1"
+    local arg="$2"
+    if [[ -z "${arg}" || "${arg}" =~ ^-.* ]]; then
+        echo "Argument missing for option ${opt}. Exiting..."
+        exit 1
+    fi
+}
+
+function parse_arguments() {
+    if [[ $# -eq 0 ]] || [[ "$1" == "--help" ]]; then
+        print_usage
+        exit 0
+    fi
+    while [[ $# -gt 0 ]]; do
+        local opt="$1"
+        shift
+        case $opt in
+            -f|--dockerfile)
+                check_opt_arg "${opt}" "$1"
+                DOCKERFILE="$1"
+                shift
+                ;;
+            -m|--mode)
+                check_opt_arg "${opt}" "$1"
+                MODE="$1"
+                shift
+                ;;
+            -g|--geo)
+                check_opt_arg "${opt}" "$1"
+                GEOLOC="$1"
+                shift
+                ;;
+            -c|--clean)
+                BUILD_CLEAN=1
+                ;;
+            -d|--dist)
+                check_opt_arg "${opt}" "$1"
+                DIST="$1"
+                shift
+                ;;
+            --dry)
+                DRY_RUN=1
+                ;;
+            -h|--help)
+                print_usage
+                exit 0
+                ;;
+            *)
+                echo "Unknown option: ${opt}"
+                print_usage
+                exit 1
+                ;;
+        esac
+    done
+}
+
+function check_arguments() {
+    if [[ "${MODE}" == "build" ]]; then
+        echo "Build all packages from source if possible"
+    elif [[ "${MODE}" != "download" ]]; then
+        echo "Unknown build mode: ${MODE}, defaults to [download]"
+        # Use prebuilt packages for dependencies if possible
+        MODE="download"
+    fi
+
+    if [[ "${GEOLOC}" == "cn" ]]; then
+        echo "Docker image built for CN users"
+    elif [[ "${GEOLOC}" != "us" ]]; then
+        echo "Unknown geo: ${GEOLOC}, defaults to [us]"
+        GEOLOC="us"
+    fi
+
+    if [[ "${DIST}" == "testing" ]]; then
+        echo "Build experimental Docker images."
+    elif [[ "${DIST}" != "stable" ]]; then
+        echo "Build stable Docker images"
+        DIST="stable"
+    fi
+
+    if [[ -z "${DOCKERFILE}" ]]; then
+        echo "Dockfile not specified, Exiting..."
+        exit 1
+    fi
+    determine_target_arch_and_stage "${DOCKERFILE}"
+}
+
+function docker_build_preview() {
+    echo "=====.=====.===== Docker Build Preview for ${TARGET_STAGE} =====.=====.====="
+    echo "|  Generated image: ${IMAGE_OUT}"
+    echo "|  FROM image: ${IMAGE_IN}"
+    echo "|  Dockerfile: ${DOCKERFILE}"
+    echo "|  TARGET_ARCH=${TARGET_ARCH}, HOST_ARCH=${HOST_ARCH}"
+    echo "|  INSTALL_MODE=${MODE}, GEOLOC=${GEOLOC}, APOLLO_DIST=${DIST}"
+    echo "=====.=====.=====.=====.=====.=====.=====.=====.=====.=====.=====.=====.====="
+}
+
+function docker_build_run() {
+    local extra_args="--squash"
+    if [[ "${BUILD_CLEAN}" -gt 0 ]]; then
+        extra_args="${extra_args} --no-cache=true"
+    fi
+    local context="$(dirname "${BASH_SOURCE[0]}")"
+
+    set -x
+    docker build ${extra_args} -t "${IMAGE_OUT}" \
+        --build-arg INSTALL_MODE="${MODE}" \
+        --build-arg GEOLOC="${GEOLOC}"     \
+        --build-arg APOLLO_DIST="${DIST}"  \
+        --build-arg BASE_IMAGE="${IMAGE_IN}" \
+        --build-arg TENSORRT_VERSION="${TENSORRT_VERSION}" \
+        -f "${DOCKERFILE}" \
+        "${context}"
+    set +x
+}
+
+function main() {
+    parse_arguments "$@"
+    check_arguments
+    check_experimental_docker
+    if [[ "${TARGET_ARCH}" == "x86_64" ]]; then
+        determine_images_for_x86_64 "${TARGET_STAGE}" "${DIST}"
+    elif [[ "${TARGET_ARCH}" == "aarch64" ]]; then
+        determine_images_for_aarch64 "${TARGET_STAGE}" "${DIST}"
+    fi
+    docker_build_preview
+    if [[ "${DRY_RUN}" -eq 0 ]]; then
+        docker_build_run
+    fi
+}
+
+main "$@"
+