MINIFICPP-2861 Add Conan support for docker and clang CI builds

.dockerignore

@@ -39,6 +39,7 @@ logs
 **/cmake-build-*
 docker/*
 !docker/conf
+!docker/settings_user.yml
 target
 *.pyc
 *.swp

.github/workflows/ci.yml

@@ -9,12 +9,13 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.event.pull_request.head.repo.full_name || github.repository }}-${{ github.head_ref || github.ref_name }}
   cancel-in-progress: ${{ github.event_name != 'workflow_dispatch' }}
 env:
-  DOCKER_CMAKE_FLAGS: -DDOCKER_VERIFY_THREAD=3 -DUSE_SHARED_LIBS= -DSTRICT_GSL_CHECKS=AUDIT -DCI_BUILD=ON -DENABLE_AWS=ON -DENABLE_KAFKA=ON -DENABLE_MQTT=ON -DENABLE_AZURE=ON -DENABLE_SQL=ON \
-    -DENABLE_SPLUNK=ON -DENABLE_GCP=ON -DENABLE_OPC=ON -DENABLE_PYTHON_SCRIPTING=ON -DENABLE_LUA_SCRIPTING=ON -DENABLE_KUBERNETES=ON -DENABLE_TEST_PROCESSORS=ON -DENABLE_PROMETHEUS=ON \
-    -DENABLE_ELASTICSEARCH=ON -DENABLE_GRAFANA_LOKI=ON -DENABLE_COUCHBASE=ON -DENABLE_LLAMACPP=ON -DDOCKER_BUILD_ONLY=ON -DMINIFI_PERFORMANCE_TESTS=ON
   CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/.ccache
   CONAN_LOGIN_USERNAME_NIFI_CONAN: ${{ secrets.CONAN_USERNAME }}
   CONAN_PASSWORD_NIFI_CONAN: ${{ secrets.CONAN_ACCESS_TOKEN }}
+  DOCKER_CMAKE_FLAGS: -DDOCKER_VERIFY_THREAD=3 -DUSE_SHARED_LIBS= -DSTRICT_GSL_CHECKS=AUDIT -DCI_BUILD=ON -DENABLE_AWS=ON -DENABLE_KAFKA=ON -DENABLE_MQTT=ON -DENABLE_AZURE=ON -DENABLE_SQL=ON \
+    -DENABLE_SPLUNK=ON -DENABLE_GCP=ON -DENABLE_OPC=ON -DENABLE_PYTHON_SCRIPTING=ON -DENABLE_LUA_SCRIPTING=ON -DENABLE_KUBERNETES=ON -DENABLE_TEST_PROCESSORS=ON -DENABLE_PROMETHEUS=ON \
+    -DENABLE_ELASTICSEARCH=ON -DENABLE_GRAFANA_LOKI=ON -DENABLE_COUCHBASE=ON -DENABLE_LLAMACPP=ON -DDOCKER_BUILD_ONLY=ON -DMINIFI_PERFORMANCE_TESTS=ON -DDOCKER_USE_CONAN=ON \
+    -DDOCKER_NIFI_CONAN_USER=${{ secrets.CONAN_USERNAME }} -DDOCKER_NIFI_CONAN_PASSWORD=${{ secrets.CONAN_ACCESS_TOKEN }}
 jobs:
   macos_xcode:
     name: "macOS 26 aarch64"
@@ -294,6 +295,7 @@ jobs:
         -DMINIFI_USE_REAL_ODBC_TEST_DRIVER=OFF
         -DUSE_SHARED_LIBS=ON
         -DMINIFI_PERFORMANCE_TESTS=ON
+        -DUSE_CONAN=ON
     steps:
       - id: checkout
         uses: actions/checkout@v6
@@ -334,6 +336,11 @@ jobs:
             && pip install -r requirements.txt \
             && python main.py --noninteractive --skip-compiler-install --cmake-options="-DSTRICT_GSL_CHECKS=AUDIT -DCMAKE_EXPORT_COMPILE_COMMANDS=ON" --minifi-options="${UBUNTU_CLANG_MINIFI_OPTIONS}"
         working-directory: bootstrap
+      - name: Upload conan packages
+        if: always() && github.event_name == 'push' && github.ref == 'refs/heads/main'
+        run: |
+          source venv/bin/activate && conan remote login nifi-conan && conan upload "*" -r nifi-conan --confirm
+        working-directory: bootstrap
       - id: cache_save
         uses: actions/cache/save@v5
         if: always()
@@ -443,7 +450,8 @@ jobs:
           mkdir build && cd build && cmake -DUSE_SHARED_LIBS=ON -DCI_BUILD=ON -DCMAKE_BUILD_TYPE=Release -DSTRICT_GSL_CHECKS=AUDIT -DMINIFI_FAIL_ON_WARNINGS=OFF -DENABLE_AWS=ON -DENABLE_AZURE=ON \
               -DENABLE_ENCRYPT_CONFIG=ON -DENABLE_KAFKA=ON -DENABLE_MQTT=ON -DENABLE_OPC=ON -DENABLE_OPS=ON -DENABLE_SQL=ON -DENABLE_SYSTEMD=ON \
               -DENABLE_PYTHON_SCRIPTING=ON -DENABLE_LUA_SCRIPTING=ON -DENABLE_KUBERNETES=ON -DENABLE_GCP=ON -DENABLE_PROCFS=ON -DENABLE_PROMETHEUS=ON \
-              -DENABLE_ELASTICSEARCH=ON -DENABLE_GRAFANA_LOKI=ON -DENABLE_LLAMACPP=ON -DDOCKER_SKIP_TESTS=OFF -DDOCKER_BUILD_ONLY=ON -DDOCKER_CCACHE_DUMP_LOCATION=${{ env.CCACHE_DIR }} .. && make rocky-test
+              -DENABLE_ELASTICSEARCH=ON -DENABLE_GRAFANA_LOKI=ON -DENABLE_LLAMACPP=ON -DDOCKER_SKIP_TESTS=OFF -DDOCKER_BUILD_ONLY=ON -DDOCKER_CCACHE_DUMP_LOCATION=${{ env.CCACHE_DIR }} \
+              -DDOCKER_USE_CONAN=ON -DDOCKER_NIFI_CONAN_USER=${{ env.CONAN_LOGIN_USERNAME_NIFI_CONAN }} -DDOCKER_NIFI_CONAN_PASSWORD=${{ env.CONAN_PASSWORD_NIFI_CONAN }} .. && make rocky-test
       - name: cache save
         uses: actions/cache/save@v5
         if: always()

bootstrap/cli.py

@@ -76,13 +76,18 @@ def run_conan_install(minifi_options: MinifiOptions, package_manager: PackageMan
         return False
 
     compiler_settings = " -s:a compiler.cppstd=23"
+    if "-stdlib=libc++" in os.environ.get("CXXFLAGS", ""):
+        compiler_settings += " -s:a compiler.libcxx=libc++"
     generator_setting = " -c tools.cmake.cmaketoolchain:generator=Ninja" if minifi_options.use_ninja.value == "ON" else ""
     conan_remote_add_cmd = "conan remote add nifi-conan https://apache.jfrog.io/artifactory/api/conan/nifi-conan --force"
     if not package_manager.run_cmd(conan_remote_add_cmd):
         print("Adding the nifi-conan remote failed")
         return False
     build_cmd = f"conan install {minifi_options.source_dir} --output-folder={minifi_options.build_dir} --build=missing {conan_options} " \
                 f"--settings=build_type={minifi_options.build_type.value}{generator_setting}{compiler_settings}"
+    if platform.system() == "Linux":
+        # Conan's prebuilt m4 binary fails autom4te's version probe in some Linux build containers (e.g. RockyLinux 8), so always build m4 from source on Linux.
+        build_cmd += " --build=m4/*"
     res = package_manager.run_cmd(build_cmd)
     print("Conan install was successful" if res else "Conan install was unsuccessful")
     return res
@@ -138,6 +143,11 @@ def do_one_click_configuration(minifi_options: MinifiOptions, package_manager: P
     return True
 
 
+def do_one_click_conan_install(minifi_options: MinifiOptions, package_manager: PackageManager) -> bool:
+    assert run_conan_install(minifi_options, package_manager)
+    return True
+
+
 def main_menu(minifi_options: MinifiOptions, package_manager: PackageManager):
     done = False
     while not done:

bootstrap/main.py

@@ -17,7 +17,7 @@
 import argparse
 import pathlib
 
-from cli import main_menu, do_one_click_build, do_one_click_configuration
+from cli import main_menu, do_one_click_build, do_one_click_configuration, do_one_click_conan_install
 from minifi_option import parse_minifi_options
 from package_manager import get_package_manager
 
@@ -35,6 +35,8 @@
                             help="Initiates the one click build")
         parser.add_argument('--run-configuration', action="store_true", default=False,
                             help="Runs configuration")
+        parser.add_argument('--run-conan-install', action="store_true", default=False,
+                            help="Runs conan install")
         args = parser.parse_args()
         no_confirm = args.noconfirm or args.noninteractive
 
@@ -62,5 +64,8 @@
             do_one_click_build(minifi_options, package_manager)
         elif args.run_configuration:
             do_one_click_configuration(minifi_options, package_manager)
+        elif args.run_conan_install:
+            minifi_options.build_options["USE_CONAN"].value = "ON"
+            do_one_click_conan_install(minifi_options, package_manager)
         else:
             main_menu(minifi_options, package_manager)

bootstrap/minifi_option.py

@@ -31,7 +31,7 @@ def __init__(self, cache_values: Dict[str, CMakeCacheValue]):
         self.build_type = CMakeCacheValue("Specifies the build type on single-configuration generators",
                                           "CMAKE_BUILD_TYPE", "STRING", "Release")
         self.build_type.possible_values = ["Release", "Debug", "RelWithDebInfo", "MinSizeRel"]
-        additional_build_options = ["DOCKER_BUILD_ONLY", "DOCKER_SKIP_TESTS", "DOCKER_CREATE_RPM", "SKIP_TESTS", "PORTABLE"]
+        additional_build_options = ["DOCKER_BUILD_ONLY", "DOCKER_USE_CONAN", "DOCKER_SKIP_TESTS", "DOCKER_CREATE_RPM", "SKIP_TESTS", "PORTABLE"]
         self.use_ninja = CMakeCacheValue("Specifies if CMake should use the Ninja generator or the system default", "USE_NINJA", "BOOL", "ON")
         self.use_conan = CMakeCacheValue("Specifies if CMake should use Conan package manager", "USE_CONAN", "BOOL", "OFF")
         if "USE_NINJA" in cache_values:

bootstrap/package_manager.py

@@ -204,6 +204,25 @@ def install_compiler(self) -> str:
         return ""
 
 
+class ApkPackageManager(PackageManager):
+    def __init__(self, no_confirm):
+        PackageManager.__init__(self, no_confirm)
+
+    def install(self, dependencies: Dict[str, Set[str]]) -> bool:
+        return self._install(dependencies=dependencies,
+                             install_cmd="sudo apk add --no-cache",
+                             replace_dict={"libarchive": {"libarchive-dev"},
+                                           "python": {"python3-dev"}})
+
+    def _get_installed_packages(self) -> Set[str]:
+        result = subprocess.run(['apk', 'info'], text=True, capture_output=True, check=True)
+        return set(result.stdout.splitlines())
+
+    def install_compiler(self) -> str:
+        self.install({"compiler": {"g++"}})
+        return ""
+
+
 def _get_vs_dev_cmd_path(vs_where_location: VsWhereLocation):
     if vs_where_location == VsWhereLocation.CHOCO:
         vs_where_path = "vswhere"
@@ -326,6 +345,8 @@ def get_package_manager(no_confirm: bool) -> PackageManager:
             return DnfPackageManager(no_confirm, False)
         elif "opensuse" in distro_id:
             return ZypperPackageManager(no_confirm)
+        elif "alpine" in distro_id:
+            return ApkPackageManager(no_confirm)
         else:
             sys.exit(f"Unsupported platform {distro_id} exiting")
     elif platform_system == "Windows":

cmake/DockerConfig.cmake

@@ -36,6 +36,9 @@ add_custom_target(
         -c DOCKER_PLATFORMS=${DOCKER_PLATFORMS}
         -c DOCKER_PUSH=${DOCKER_PUSH}
         -c DOCKER_TAGS=${DOCKER_TAGS}
+        -c DOCKER_USE_CONAN=${DOCKER_USE_CONAN}
+        -c DOCKER_NIFI_CONAN_USER=${DOCKER_NIFI_CONAN_USER}
+        -c DOCKER_NIFI_CONAN_PASSWORD=${DOCKER_NIFI_CONAN_PASSWORD}
     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/docker/)
 
 # Create minimal docker image
@@ -80,26 +83,11 @@ add_custom_target(
         -c DOCKER_PLATFORMS=${DOCKER_PLATFORMS}
         -c DOCKER_PUSH=${DOCKER_PUSH}
         -c DOCKER_TAGS=${DOCKER_TAGS}
+        -c DOCKER_USE_CONAN=${DOCKER_USE_CONAN}
+        -c DOCKER_NIFI_CONAN_USER=${DOCKER_NIFI_CONAN_USER}
+        -c DOCKER_NIFI_CONAN_PASSWORD=${DOCKER_NIFI_CONAN_PASSWORD}
     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/docker/)
 
-add_custom_target(
-    centos
-    COMMAND ${CMAKE_SOURCE_DIR}/docker/DockerBuild.sh
-        -u 1000
-        -g 1000
-        -v ${PROJECT_VERSION_STR}
-        -o ${MINIFI_DOCKER_OPTIONS_STR}
-        -l ${CMAKE_BINARY_DIR}
-        -d centos
-        -c BUILD_NUMBER=${BUILD_NUMBER}
-        -c DOCKER_CCACHE_DUMP_LOCATION=${DOCKER_CCACHE_DUMP_LOCATION}
-        -c DOCKER_SKIP_TESTS=${DOCKER_SKIP_TESTS}
-        -c CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
-        -c DOCKER_PLATFORMS=${DOCKER_PLATFORMS}
-        -c DOCKER_PUSH=${DOCKER_PUSH}
-        -c DOCKER_TAGS=${DOCKER_TAGS}
-        -c DOCKER_BASE_IMAGE=${DOCKER_BASE_IMAGE}
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/docker/)
 
 add_custom_target(
     rocky-test
@@ -117,6 +105,9 @@ add_custom_target(
         -c DOCKER_PUSH=${DOCKER_PUSH}
         -c DOCKER_TAGS=${DOCKER_TAGS}
         -c DOCKER_BASE_IMAGE=${DOCKER_BASE_IMAGE}
+        -c DOCKER_USE_CONAN=${DOCKER_USE_CONAN}
+        -c DOCKER_NIFI_CONAN_USER=${DOCKER_NIFI_CONAN_USER}
+        -c DOCKER_NIFI_CONAN_PASSWORD=${DOCKER_NIFI_CONAN_PASSWORD}
     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/docker/)
 
 
@@ -138,6 +129,9 @@ add_custom_target(
         -c DOCKER_PUSH=${DOCKER_PUSH}
         -c DOCKER_TAGS=${DOCKER_TAGS}
         -c DOCKER_BASE_IMAGE=${DOCKER_BASE_IMAGE}
+        -c DOCKER_USE_CONAN=${DOCKER_USE_CONAN}
+        -c DOCKER_NIFI_CONAN_USER=${DOCKER_NIFI_CONAN_USER}
+        -c DOCKER_NIFI_CONAN_PASSWORD=${DOCKER_NIFI_CONAN_PASSWORD}
     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/docker/)
 
 set(ENABLED_TAGS "CORE")

cmake/MiNiFiOptions.cmake

@@ -46,6 +46,9 @@ add_minifi_option(CI_BUILD "Build is used for CI." OFF)
 add_minifi_option(SKIP_TESTS "Skips building all tests." OFF)
 add_minifi_option(MINIFI_PERFORMANCE_TESTS "Build performance tests" OFF)
 add_minifi_option(DOCKER_BUILD_ONLY "Disables all targets except docker build scripts. Ideal for systems without an up-to-date compiler." OFF)
+add_minifi_option(DOCKER_USE_CONAN "Use Conan package manager in docker build." OFF)
+add_minifi_option(DOCKER_NIFI_CONAN_USER "Username for the NiFi Conan repository." "")
+add_minifi_option(DOCKER_NIFI_CONAN_PASSWORD "Password for the NiFi Conan repository." "")
 add_minifi_option(DOCKER_SKIP_TESTS "Skip building tests in docker image targets." ON)
 add_minifi_option(DOCKER_CREATE_RPM "Create an RPM package in the rocky docker build target." ON)
 add_minifi_option(DOCKER_PUSH "Push created images to the specified tags" OFF)
@@ -194,7 +197,11 @@ add_minifi_multi_option(MINIFI_AWS_SDK_CPP_SOURCE "Retrieves AWS SDK for C++ fro
 function(get_minifi_docker_options RET_VALUE)
     set(MINIFI_DOCKER_OPTIONS_STR ${MINIFI_EXTERNAL_DOCKER_OPTIONS_STR})
     foreach(MINIFI_OPTION ${MINIFI_OPTIONS})
-        if (MINIFI_OPTION STREQUAL "SKIP_TESTS" OR MINIFI_OPTION STREQUAL "DOCKER_BUILD_ONLY" OR MINIFI_OPTION STREQUAL "DOCKER_SKIP_TESTS" OR MINIFI_OPTION STREQUAL "DOCKER_PUSH")
+        if (MINIFI_OPTION STREQUAL "SKIP_TESTS" OR MINIFI_OPTION STREQUAL "DOCKER_BUILD_ONLY" OR MINIFI_OPTION STREQUAL "DOCKER_USE_CONAN" OR MINIFI_OPTION STREQUAL "DOCKER_NIFI_CONAN_USER" OR
+            MINIFI_OPTION STREQUAL "DOCKER_NIFI_CONAN_PASSWORD" OR MINIFI_OPTION STREQUAL "DOCKER_SKIP_TESTS" OR MINIFI_OPTION STREQUAL "DOCKER_PUSH")
+            continue()
+        endif()
+        if (MINIFI_OPTION MATCHES "^MINIFI_.*_SOURCE$")
             continue()
         endif()
         set(MINIFI_DOCKER_OPTIONS_STR "${MINIFI_DOCKER_OPTIONS_STR} -D${MINIFI_OPTION}=${${MINIFI_OPTION}}")

cmake/PahoMqttC.cmake

@@ -24,7 +24,7 @@ set(PAHO_ENABLE_TESTING OFF CACHE BOOL "" FORCE)
 set(PAHO_WITH_SSL ON CACHE BOOL "" FORCE)
 set(PAHO_HIGH_PERFORMANCE ON CACHE BOOL "" FORCE)
 
-set(PATCH_FILE_1 "${CMAKE_SOURCE_DIR}/thirdparty/paho-mqtt/cmake-openssl.patch")
+set(PATCH_FILE_1 "${CMAKE_SOURCE_DIR}/thirdparty/paho-mqtt/all/patches/cmake-openssl.patch")
 set(PC ${Bash_EXECUTABLE}  -c "set -x &&\
         (\\\"${Patch_EXECUTABLE}\\\" -p1 -R -s -f --dry-run -i \\\"${PATCH_FILE_1}\\\" || \\\"${Patch_EXECUTABLE}\\\" -p1 -N -i \\\"${PATCH_FILE_1}\\\")")
 

conanfile.py

@@ -76,7 +76,7 @@ def requirements(self):
         if self.options.enable_all or self.options.enable_prometheus:
             self.requires("prometheus-cpp/1.3.0")
         if self.options.enable_all or self.options.enable_mqtt:
-            self.requires("paho-mqtt-c/1.3.16")
+            self.requires("paho-mqtt-c/1.3.16@minifi/develop")
         if self.options.enable_all or self.options.enable_couchbase:
             self.requires("couchbase_cxx_client/1.3.1@minifi/develop")
             self.requires("ms-gsl/4.0.0")
@@ -141,10 +141,15 @@ def configure(self):
             setattr(self.options["aws-sdk-cpp"], "text-to-speech", False)
         if self.options.enable_all or self.options.get_safe("enable_llamacpp"):
             self.options["llama-cpp"].portable = self.options.portable
+        if self.options.enable_all or self.options.get_safe("enable_mqtt"):
+            self.options["paho-mqtt-c"].high_performance = True
 
     def generate(self):
         tc = CMakeToolchain(self)
         tc.variables["MINIFI_DEFAULT_DEPENDENCY_SOURCE"] = "CONAN"
+
+        # Drop hardcoded install dir from Conan's generated toolchain to detect the correct install dir for RPM package installation
+        tc.blocks.remove("output_dirs")
         tc.generate()
 
     def build(self):

docker/DockerBuild.sh

@@ -30,6 +30,9 @@ DISTRO_NAME=
 BUILD_NUMBER=
 DOCKER_CCACHE_DUMP_LOCATION=
 DOCKER_SKIP_TESTS=ON
+DOCKER_USE_CONAN=OFF
+DOCKER_NIFI_CONAN_USER=
+DOCKER_NIFI_CONAN_PASSWORD=
 DOCKER_CREATE_RPM=ON
 CMAKE_BUILD_TYPE=Release
 PLATFORMS=
@@ -44,7 +47,7 @@ function usage {
   echo "-p, --prefix          Additional prefix added to the image tag"
   echo "-u, --uid             User id to be used in the Docker image (default: 1000)"
   echo "-g, --gid             Group id to be used in the Docker image (default: 1000)"
-  echo "-d, --distro-name     Linux distribution build to be used for alternative builds (centos|rockylinux)"
+  echo "-d, --distro-name     Linux distribution build to be used for alternative builds (rockylinux)"
   echo "-l  --dump-location   Path where to the output dump to be put"
   echo "-c  --cmake-param     CMake parameter passed in PARAM=value format"
   echo "-o  --options         Minifi options string"
@@ -108,6 +111,12 @@ while [[ $# -gt 0 ]]; do
         DOCKER_SKIP_TESTS="${ARR[1]}"
       elif [ "${ARR[0]}" == "DOCKER_CREATE_RPM" ]; then
         DOCKER_CREATE_RPM="${ARR[1]}"
+      elif [ "${ARR[0]}" == "DOCKER_USE_CONAN" ]; then
+        DOCKER_USE_CONAN="${ARR[1]}"
+      elif [ "${ARR[0]}" == "DOCKER_NIFI_CONAN_USER" ]; then
+        DOCKER_NIFI_CONAN_USER="${ARR[1]}"
+      elif [ "${ARR[0]}" == "DOCKER_NIFI_CONAN_PASSWORD" ]; then
+        DOCKER_NIFI_CONAN_PASSWORD="${ARR[1]}"
       elif [ "${ARR[0]}" == "CMAKE_BUILD_TYPE" ]; then
         CMAKE_BUILD_TYPE="${ARR[1]}"
       elif [ "${ARR[0]}" == "DOCKER_PLATFORMS" ] && [ -n "${ARR[1]}" ]; then
@@ -202,7 +211,13 @@ BUILD_ARGS+=("--build-arg" "UID=${UID_ARG}"
              "--build-arg" "DISTRO_NAME=${DISTRO_NAME}"
              "--build-arg" "DOCKER_SKIP_TESTS=${DOCKER_SKIP_TESTS}"
              "--build-arg" "DOCKER_CREATE_RPM=${DOCKER_CREATE_RPM}"
+             "--build-arg" "DOCKER_USE_CONAN=${DOCKER_USE_CONAN}"
+             "--build-arg" "DOCKER_NIFI_CONAN_USER=${DOCKER_NIFI_CONAN_USER}"
              "--build-arg" "CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
+if [ -n "${DOCKER_NIFI_CONAN_PASSWORD}" ]; then
+  export DOCKER_NIFI_CONAN_PASSWORD
+  BUILD_ARGS+=("--secret" "id=nifi_conan_password,env=DOCKER_NIFI_CONAN_PASSWORD")
+fi
 if [ -n "${DUMP_LOCATION}" ]; then
   BUILD_ARGS+=("--build-arg" "DOCKER_MAKE_TARGET=package")
 fi
@@ -223,6 +238,7 @@ if [ -n "${DISTRO_NAME}" ]; then
   fi
 else
   if [ -n "${DOCKER_CCACHE_DUMP_LOCATION}" ]; then
+    echo docker buildx build "${BUILD_ARGS[@]}" -f "${DOCKERFILE}" --target build -t minifi_build ..
     docker buildx build "${BUILD_ARGS[@]}" -f "${DOCKERFILE}" --target build -t minifi_build ..
     dump_ccache "minifi_build" "${DOCKER_CCACHE_DUMP_LOCATION}"
   fi