Use dagger to build and test the agent. (#16868)

Dag

packaging/dag/README.md

@@ -0,0 +1,23 @@
+- Install Dagger CLI:
+  ```
+  cd /usr/local
+  curl -L https://dl.dagger.io/dagger/install.sh | sudo sh
+  ```
+- Install Python's Dagger SDK:
+  ```
+  pip install dagger-io
+  ```
+
+Now you can run something like this:
+
+```
+dagger run python packaging/dag/main.py build -p linux/x86_64 -d debian12
+```
+
+or
+
+```
+dagger run python packaging/dag/main.py test
+```.
+
+

packaging/dag/build_command.py

@@ -0,0 +1,65 @@
+import click
+import asyncio
+import sys
+import dagger
+import pathlib
+import uuid
+
+from nd import (
+    Distribution,
+    NetdataInstaller,
+    FeatureFlags,
+    Endpoint,
+    AgentContext,
+    SUPPORTED_PLATFORMS,
+    SUPPORTED_DISTRIBUTIONS,
+)
+
+
+def run_async(func):
+    def wrapper(*args, **kwargs):
+        return asyncio.run(func(*args, **kwargs))
+
+    return wrapper
+
+
+@run_async
+async def simple_build(platform, distro):
+    config = dagger.Config(log_output=sys.stdout)
+
+    async with dagger.Connection(config) as client:
+        repo_root = pathlib.Path("/netdata")
+        prefix_path = pathlib.Path("/opt/netdata")
+
+        installer = NetdataInstaller(
+            platform, distro, repo_root, prefix_path, FeatureFlags.DBEngine
+        )
+
+        endpoint = Endpoint("node", 19999)
+        api_key = uuid.uuid4()
+        allow_children = False
+
+        agent_ctx = AgentContext(
+            client, platform, distro, installer, endpoint, api_key, allow_children
+        )
+
+        await agent_ctx.build_container()
+
+
+@click.command()
+@click.option(
+    "--platform",
+    "-p",
+    type=click.Choice(sorted([str(p) for p in SUPPORTED_PLATFORMS])),
+    help="Specify the platform.",
+)
+@click.option(
+    "--distribution",
+    "-d",
+    type=click.Choice(sorted([str(p) for p in SUPPORTED_DISTRIBUTIONS])),
+    help="Specify the distribution.",
+)
+def build(platform, distribution):
+    platform = dagger.Platform(platform)
+    distro = Distribution(distribution)
+    simple_build(platform, distro)

packaging/dag/files/child_stream.conf

@@ -0,0 +1,10 @@
+[stream]
+    enabled = {{ enabled }}
+    destination = {{ destination }}
+    api key = {{ api_key }}
+    timeout seconds = {{ timeout_seconds }}
+    default port = {{ default_port }}
+    send charts matching = {{ send_charts_matching }}
+    buffer size bytes = {{ buffer_size_bytes }}
+    reconnect delay seconds = {{ reconnect_delay_seconds }}
+    initial clock resync iterations = {{ initial_clock_resync_iterations }}

packaging/dag/files/cmake-aarch64.sha256

@@ -0,0 +1 @@
+a83e01ed1cdf44c2e33e0726513b9a35a8c09e3b5a126fd720b3c8a9d5552368  cmake-aarch64.sh

packaging/dag/files/cmake-x86_64.sha256

@@ -0,0 +1 @@
+8c449dabb2b2563ec4e6d5e0fb0ae09e729680efab71527b59015131cea4a042  cmake-x86_64.sh

packaging/dag/files/ol8-epel.repo

@@ -0,0 +1,6 @@
+[ol8_developer_EPEL]
+name=Oracle Linux $releasever EPEL Packages for Development ($basearch)
+baseurl=https://yum$ociregion.$ocidomain/repo/OracleLinux/OL8/developer/EPEL/$basearch/
+gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-oracle
+gpgcheck=1
+enabled=1

packaging/dag/files/ol9-epel.repo

@@ -0,0 +1,6 @@
+[ol9_developer_EPEL]
+name=Oracle Linux $releasever EPEL Packages for Development ($basearch)
+baseurl=https://yum$ociregion.$ocidomain/repo/OracleLinux/OL9/developer/EPEL/$basearch/
+gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-oracle
+gpgcheck=1
+enabled=1

packaging/dag/files/parent_stream.conf

@@ -0,0 +1,7 @@
+[{{ api_key }}]
+    enabled = {{ enabled }}
+    allow from = {{ allow_from }}
+    default history = {{ default_history }}
+    health enabled by default = {{ health_enabled_by_default }}
+    default postpone alarms on connect seconds = {{ default_postpone_alarms_on_connect_seconds }}
+    multiple connections = {{ multiple_connections }}

packaging/dag/imageutils.py

@@ -0,0 +1,1580 @@
+import os
+from pathlib import Path
+
+import dagger
+
+
+_ALPINE_COMMON_PACKAGES = [
+    "alpine-sdk",
+    "autoconf",
+    "automake",
+    "bash",
+    "binutils",
+    "bison",
+    "cmake",
+    "curl",
+    "curl-static",
+    "elfutils-dev",
+    "flex",
+    "gcc",
+    "git",
+    "gnutls-dev",
+    "gzip",
+    "jq",
+    "libelf-static",
+    "libmnl-dev",
+    "libmnl-static",
+    "libtool",
+    "libuv-dev",
+    "libuv-static",
+    "lz4-dev",
+    "lz4-static",
+    "make",
+    "mongo-c-driver-dev",
+    "mongo-c-driver-static",
+    "musl-fts-dev",
+    "ncurses",
+    "ncurses-static",
+    "netcat-openbsd",
+    "ninja",
+    "openssh",
+    "pcre2-dev",
+    "pkgconfig",
+    "protobuf-dev",
+    "snappy-dev",
+    "snappy-static",
+    "util-linux-dev",
+    "wget",
+    "xz",
+    "yaml-dev",
+    "yaml-static",
+    "zlib-dev",
+    "zlib-static",
+    "zstd-dev",
+    "zstd-static",
+]
+
+
+def build_alpine_3_18(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("alpine:3.18")
+
+    pkgs = [pkg for pkg in _ALPINE_COMMON_PACKAGES]
+
+    ctr = ctr.with_exec(["apk", "add", "--no-cache"] + pkgs)
+
+    return ctr
+
+
+def build_alpine_3_19(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("alpine:3.19")
+
+    pkgs = [pkg for pkg in _ALPINE_COMMON_PACKAGES]
+
+    ctr = ctr.with_exec(["apk", "add", "--no-cache"] + pkgs)
+
+    return ctr
+
+
+def static_build_openssl(
+    client: dagger.Client, ctr: dagger.Container
+) -> dagger.Container:
+    tree = (
+        client.git(url="https://github.com/openssl/openssl", keep_git_dir=True)
+        .tag("openssl-3.1.4")
+        .tree()
+    )
+
+    #
+    # TODO: verify 32-bit builds
+    #
+    ctr = (
+        ctr.with_directory("/openssl", tree)
+        .with_workdir("/openssl")
+        .with_env_variable("CFLAGS", "-fno-lto -pipe")
+        .with_env_variable("LDFLAGS", "-static")
+        .with_env_variable("PKG_CONFIG", "pkg-config --static")
+        .with_exec(
+            [
+                "sed",
+                "-i",
+                "s/disable('static', 'pic', 'threads');/disable('static', 'pic');/",
+                "Configure",
+            ]
+        )
+        .with_exec(
+            [
+                "./config",
+                "-static",
+                "threads",
+                "no-tests",
+                "--prefix=/openssl-static",
+                "--openssldir=/opt/netdata/etc/ssl",
+            ]
+        )
+        .with_exec(["make", "V=1", "-j", str(os.cpu_count())])
+        .with_exec(["make", "V=1", "-j", str(os.cpu_count()), "install_sw"])
+        .with_exec(["ln", "-s", "/openssl-static/lib", "/openssl-static/lib64"])
+        .with_exec(["perl", "configdata.pm", "--dump"])
+    )
+
+    return ctr
+
+
+def static_build_bash(client: dagger.Client, ctr: dagger.Container) -> dagger.Container:
+    tree = (
+        client.git(url="https://git.savannah.gnu.org/git/bash.git", keep_git_dir=True)
+        .tag("bash-5.1")
+        .tree()
+    )
+
+    ctr = (
+        ctr.with_directory("/bash", tree)
+        .with_workdir("/bash")
+        .with_env_variable("CFLAGS", "-pipe")
+        .with_env_variable("LDFLAGS", "")
+        .with_env_variable("PKG_CONFIG", "pkg-config --static")
+        .with_env_variable("PKG_CONFIG_PATH", "/openssl-static/lib64/pkgconfig")
+        .with_exec(
+            [
+                "./configure",
+                "--prefix",
+                "/opt/netdata",
+                "--without-bash-malloc",
+                "--enable-static-link",
+                "--enable-net-redirections",
+                "--enable-array-variables",
+                "--disable-progcomp",
+                "--disable-profiling",
+                "--disable-nls",
+                "--disable-dependency-tracking",
+            ]
+        )
+        .with_exec(
+            [
+                "echo",
+                "-e",
+                "all:\nclean:\ninstall:\n",
+                ">",
+                "examples/loadables/Makefile",
+            ]
+        )
+        .with_exec(["make", "clean"])
+        # see: https://gitweb.gentoo.org/repo/gentoo.git/tree/app-shells/bash/files/bash-5.1-parallel_make.patch?id=4c2ebbf4b8bc660beb98cc2d845c73375d6e4f50
+        .with_exec(["make", "V=1", "-j", "2", "install"])
+        .with_exec(["strip", "/opt/netdata/bin/bash"])
+    )
+
+    return ctr
+
+
+def static_build_curl(client: dagger.Client, ctr: dagger.Container) -> dagger.Container:
+    tree = (
+        client.git(url="https://github.com/curl/curl", keep_git_dir=True)
+        .tag("curl-8_4_0")
+        .tree()
+    )
+
+    ctr = (
+        ctr.with_directory("/curl", tree)
+        .with_workdir("/curl")
+        .with_env_variable("CFLAGS", "-I/openssl-static/include -pipe")
+        .with_env_variable("LDFLAGS", "-static -L/openssl-static/lib64")
+        .with_env_variable("PKG_CONFIG", "pkg-config --static")
+        .with_env_variable("PKG_CONFIG_PATH", "/openssl-static/lib64/pkgconfig")
+        .with_exec(["autoreconf", "-ifv"])
+        .with_exec(
+            [
+                "./configure",
+                "--prefix=/curl-static",
+                "--enable-optimize",
+                "--disable-shared",
+                "--enable-static",
+                "--enable-http",
+                "--disable-ldap",
+                "--disable-ldaps",
+                "--enable-proxy",
+                "--disable-dict",
+                "--disable-telnet",
+                "--disable-tftp",
+                "--disable-pop3",
+                "--disable-imap",
+                "--disable-smb",
+                "--disable-smtp",
+                "--disable-gopher",
+                "--enable-ipv6",
+                "--enable-cookies",
+                "--with-ca-fallback",
+                "--with-openssl",
+                "--disable-dependency-tracking",
+            ]
+        )
+        .with_exec(
+            ["sed", "-i", "-e", "s/LDFLAGS =/LDFLAGS = -all-static/", "src/Makefile"]
+        )
+        .with_exec(["make", "clean"])
+        .with_exec(["make", "V=1", "-j", str(os.cpu_count()), "install"])
+        .with_exec(["cp", "/curl-static/bin/curl", "/opt/netdata/bin/curl"])
+        .with_exec(["strip", "/opt/netdata/bin/curl"])
+    )
+
+    return ctr
+
+
+def static_build_ioping(
+    client: dagger.Client, ctr: dagger.Container
+) -> dagger.Container:
+    tree = (
+        client.git(url="https://github.com/koct9i/ioping", keep_git_dir=True)
+        .tag("v1.3")
+        .tree()
+    )
+
+    ctr = (
+        ctr.with_directory("/ioping", tree)
+        .with_workdir("/ioping")
+        .with_env_variable("CFLAGS", "-static -pipe")
+        .with_exec(["mkdir", "-p", "/opt/netdata/usr/libexec/netdata/plugins.d"])
+        .with_exec(["make", "V=1"])
+        .with_exec(
+            [
+                "install",
+                "-o",
+                "root",
+                "-g",
+                "root",
+                "-m",
+                "4750",
+                "ioping",
+                "/opt/netdata/usr/libexec/netdata/plugins.d",
+            ]
+        )
+        .with_exec(["strip", "/opt/netdata/usr/libexec/netdata/plugins.d/ioping"])
+    )
+
+    return ctr
+
+
+def static_build_libnetfilter_acct(
+    client: dagger.Client, ctr: dagger.Container
+) -> dagger.Container:
+    tree = (
+        client.git(url="git://git.netfilter.org/libnetfilter_acct", keep_git_dir=True)
+        .tag("libnetfilter_acct-1.0.3")
+        .tree()
+    )
+
+    ctr = (
+        ctr.with_directory("/libnetfilter_acct", tree)
+        .with_workdir("/libnetfilter_acct")
+        .with_env_variable("CFLAGS", "-static -I/usr/include/libmnl -pipe")
+        .with_env_variable("LDFLAGS", "-static -L/usr/lib -lmnl")
+        .with_env_variable("PKG_CONFIG", "pkg-config --static")
+        .with_env_variable("PKG_CONFIG_PATH", "/usr/lib/pkgconfig")
+        .with_exec(["autoreconf", "-ifv"])
+        .with_exec(
+            [
+                "./configure",
+                "--prefix=/libnetfilter_acct-static",
+                "--exec-prefix=/libnetfilter_acct-static",
+            ]
+        )
+        .with_exec(["make", "clean"])
+        .with_exec(["make", "V=1", "-j", str(os.cpu_count()), "install"])
+    )
+
+    return ctr
+
+
+def static_build_netdata(
+    client: dagger.Client, ctr: dagger.Container
+) -> dagger.Container:
+    CFLAGS = [
+        "-ffunction-sections",
+        "-fdata-sections",
+        "-static",
+        "-O2",
+        "-funroll-loops",
+        "-I/openssl-static/include",
+        "-I/libnetfilter_acct-static/include/libnetfilter_acct",
+        "-I/curl-local/include/curl",
+        "-I/usr/include/libmnl",
+        "-pipe",
+    ]
+
+    LDFLAGS = [
+        "-Wl,--gc-sections",
+        "-static",
+        "-L/openssl-static/lib64",
+        "-L/libnetfilter_acct-static/lib",
+        "-lnetfilter_acct",
+        "-L/usr/lib",
+        "-lmnl",
+        "-L/usr/lib",
+        "-lzstd",
+        "-L/curl-local/lib",
+    ]
+
+    PKG_CONFIG = [
+        "pkg-config",
+        "--static",
+    ]
+
+    PKG_CONFIG_PATH = [
+        "/openssl-static/lib64/pkgconfig",
+        "/libnetfilter_acct-static/lib/pkgconfig",
+        "/usr/lib/pkgconfig",
+        "/curl-local/lib/pkgconfig",
+    ]
+
+    CMAKE_FLAGS = [
+        "-DOPENSSL_ROOT_DIR=/openssl-static",
+        "-DOPENSSL_LIBRARIES=/openssl-static/lib64",
+        "-DCMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE=/openssl-static",
+        "-DLWS_OPENSSL_INCLUDE_DIRS=/openssl-static/include",
+        "-DLWS_OPENSSL_LIBRARIES=/openssl-static/lib64/libssl.a;/openssl-static/lib64/libcrypto.a",
+    ]
+
+    NETDATA_INSTALLER_CMD = [
+        "./netdata-installer.sh",
+        "--install-prefix",
+        "/opt",
+        "--dont-wait",
+        "--dont-start-it",
+        "--disable-exporting-mongodb",
+        "--require-cloud",
+        "--use-system-protobuf",
+        "--dont-scrub-cflags-even-though-it-may-break-things",
+        "--one-time-build",
+        "--enable-lto",
+    ]
+
+    ctr = (
+        ctr.with_workdir("/netdata")
+        .with_env_variable("NETDATA_CMAKE_OPTIONS", "-DCMAKE_BUILD_TYPE=Debug")
+        .with_env_variable("CFLAGS", " ".join(CFLAGS))
+        .with_env_variable("LDFLAGS", " ".join(LDFLAGS))
+        .with_env_variable("PKG_CONFIG", " ".join(PKG_CONFIG))
+        .with_env_variable("PKG_CONFIG_PATH", ":".join(PKG_CONFIG_PATH))
+        .with_env_variable("CMAKE_FLAGS", " ".join(CMAKE_FLAGS))
+        .with_env_variable("EBPF_LIBC", "static")
+        .with_env_variable("IS_NETDATA_STATIC_BINARY", "yes")
+        .with_exec(NETDATA_INSTALLER_CMD)
+    )
+
+    return ctr
+
+
+def static_build(client, repo_path):
+    cmake_build_release_path = os.path.join(repo_path, "cmake-build-release")
+
+    ctr = build_alpine_3_18(client, dagger.Platform("linux/x86_64"))
+    ctr = static_build_openssl(client, ctr)
+    ctr = static_build_bash(client, ctr)
+    ctr = static_build_curl(client, ctr)
+    ctr = static_build_ioping(client, ctr)
+    ctr = static_build_libnetfilter_acct(client, ctr)
+
+    ctr = ctr.with_directory(
+        "/netdata",
+        client.host().directory(repo_path),
+        exclude=[
+            f"{cmake_build_release_path}/*",
+            "fluent-bit/build",
+        ],
+    )
+
+    # TODO: link bin/sbin
+
+    ctr = static_build_netdata(client, ctr)
+
+    build_dir = ctr.directory("/opt/netdata")
+    artifact_dir = os.path.join(Path.home(), "ci/netdata-static")
+    output_task = build_dir.export(artifact_dir)
+    return output_task
+
+
+_CENTOS_COMMON_PACKAGES = [
+    "autoconf",
+    "autoconf-archive",
+    "autogen",
+    "automake",
+    "bison",
+    "bison-devel",
+    "cmake",
+    "cups-devel",
+    "curl",
+    "diffutils",
+    "elfutils-libelf-devel",
+    "findutils",
+    "flex",
+    "flex-devel",
+    "freeipmi-devel",
+    "gcc",
+    "gcc-c++",
+    "git-core",
+    "golang",
+    "json-c-devel",
+    "libyaml-devel",
+    "libatomic",
+    "libcurl-devel",
+    "libmnl-devel",
+    "libnetfilter_acct-devel",
+    "libtool",
+    "libuuid-devel",
+    "libuv-devel",
+    "libzstd-devel",
+    "lm_sensors",
+    "lz4-devel",
+    "make",
+    "ninja-build",
+    "openssl-devel",
+    "openssl-perl",
+    "patch",
+    "pcre2-devel",
+    "pkgconfig",
+    "pkgconfig(libmongoc-1.0)",
+    "procps",
+    "protobuf-c-devel",
+    "protobuf-compiler",
+    "protobuf-devel",
+    "rpm-build",
+    "rpm-devel",
+    "rpmdevtools",
+    "snappy-devel",
+    "systemd-devel",
+    "wget",
+    "zlib-devel",
+]
+
+
+def build_amazon_linux_2(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("amazonlinux:2")
+
+    pkgs = [pkg for pkg in _CENTOS_COMMON_PACKAGES]
+
+    ctr = (
+        ctr.with_exec(["yum", "update", "-y"])
+        .with_exec(["yum", "install", "-y"] + pkgs)
+        .with_exec(["yum", "clean", "all"])
+        .with_exec(["c_rehash"])
+        .with_exec(
+            [
+                "mkdir",
+                "-p",
+                "/root/rpmbuild/BUILD",
+                "/root/rpmbuild/RPMS",
+                "/root/rpmbuild/SOURCES",
+                "/root/rpmbuild/SPECS",
+                "/root/rpmbuild/SRPMS",
+            ]
+        )
+    )
+
+    if platform == "linux/x86_64":
+        machine = "x86_64"
+    elif platform == "linux/arm64":
+        machine = "aarch64"
+    else:
+        raise Exception(
+            "Amaxon Linux 2 supports only linux/amd64 and linux/arm64 platforms."
+        )
+
+
+    checksum_path = Path(__file__).parent / f"files/cmake-{machine}.sha256"
+
+    ctr = (
+        ctr.with_file(
+            f"cmake-{machine}.sha256",
+            client.host().file(checksum_path.as_posix()),
+        )
+        .with_exec(
+            [
+                "curl",
+                "--fail",
+                "-sSL",
+                "--connect-timeout",
+                "20",
+                "--retry",
+                "3",
+                "--output",
+                f"cmake-{machine}.sh",
+                f"https://github.com/Kitware/CMake/releases/download/v3.27.6/cmake-3.27.6-linux-{machine}.sh",
+            ]
+        )
+        .with_exec(["sha256sum", "-c", f"cmake-{machine}.sha256"])
+        .with_exec(["chmod", "u+x", f"./cmake-{machine}.sh"])
+        .with_exec([f"./cmake-{machine}.sh", "--skip-license", "--prefix=/usr/local"])
+    )
+
+    return ctr
+
+
+def build_centos_7(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("centos:7")
+
+    pkgs = [pkg for pkg in _CENTOS_COMMON_PACKAGES] + ["bash"]
+
+    ctr = (
+        ctr.with_exec(["yum", "install", "-y", "epel-release"])
+        .with_exec(["yum", "update", "-y"])
+        .with_exec(["yum", "install", "-y"] + pkgs)
+        .with_exec(["yum", "clean", "all"])
+        .with_exec(["c_rehash"])
+        .with_exec(
+            [
+                "mkdir",
+                "-p",
+                "/root/rpmbuild/BUILD",
+                "/root/rpmbuild/RPMS",
+                "/root/rpmbuild/SOURCES",
+                "/root/rpmbuild/SPECS",
+                "/root/rpmbuild/SRPMS",
+            ]
+        )
+    )
+
+    if platform == "linux/x86_64":
+        machine = "x86_64"
+    elif platform == "linux/arm64":
+        machine = "aarch64"
+    else:
+        raise Exception("CentOS 7 supports only linux/amd64 and linux/arm64 platforms.")
+
+    checksum_path = Path(__file__).parent / f"files/cmake-{machine}.sha256"
+
+    ctr = (
+        ctr.with_file(
+            f"cmake-{machine}.sha256",
+            client.host().file(checksum_path.as_posix()),
+        )
+        .with_exec(
+            [
+                "curl",
+                "--fail",
+                "-sSL",
+                "--connect-timeout",
+                "20",
+                "--retry",
+                "3",
+                "--output",
+                f"cmake-{machine}.sh",
+                f"https://github.com/Kitware/CMake/releases/download/v3.27.6/cmake-3.27.6-linux-{machine}.sh",
+            ]
+        )
+        .with_exec(["sha256sum", "-c", f"cmake-{machine}.sha256"])
+        .with_exec(["chmod", "u+x", f"./cmake-{machine}.sh"])
+        .with_exec([f"./cmake-{machine}.sh", "--skip-license", "--prefix=/usr/local"])
+    )
+
+    return ctr
+
+
+_ROCKY_LINUX_COMMON_PACKAGES = [
+    "autoconf",
+    "autoconf-archive",
+    "automake",
+    "bash",
+    "bison",
+    "cmake",
+    "cups-devel",
+    "curl",
+    "libcurl-devel",
+    "diffutils",
+    "elfutils-libelf-devel",
+    "findutils",
+    "flex",
+    "freeipmi-devel",
+    "gcc",
+    "gcc-c++",
+    "git",
+    "golang",
+    "json-c-devel",
+    "libatomic",
+    "libmnl-devel",
+    "libtool",
+    "libuuid-devel",
+    "libuv-devel",
+    "libyaml-devel",
+    "libzstd-devel",
+    "lm_sensors",
+    "lz4-devel",
+    "make",
+    "ninja-build",
+    "nc",
+    "openssl-devel",
+    "openssl-perl",
+    "patch",
+    "pcre2-devel",
+    "pkgconfig",
+    "pkgconfig(libmongoc-1.0)",
+    "procps",
+    "protobuf-c-devel",
+    "protobuf-compiler",
+    "protobuf-devel",
+    "python3",
+    "python3-pyyaml",
+    "rpm-build",
+    "rpm-devel",
+    "rpmdevtools",
+    "snappy-devel",
+    "systemd-devel",
+    "wget",
+    "zlib-devel",
+]
+
+
+def build_rocky_linux_8(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("rockylinux:8")
+
+    pkgs = [pkg for pkg in _ROCKY_LINUX_COMMON_PACKAGES] + ["autogen"]
+
+    ctr = (
+        ctr.with_exec(["dnf", "distro-sync", "-y", "--nodocs"])
+        .with_exec(
+            [
+                "dnf",
+                "install",
+                "-y",
+                "--nodocs",
+                "dnf-command(config-manager)",
+                "epel-release",
+            ]
+        )
+        .with_exec(["dnf", "config-manager", "--set-enabled", "powertools"])
+        .with_exec(["dnf", "clean", "packages"])
+        .with_exec(
+            [
+                "dnf",
+                "install",
+                "-y",
+                "--nodocs",
+                "--setopt=install_weak_deps=False",
+                "--setopt=diskspacecheck=False",
+            ]
+            + pkgs
+        )
+        .with_exec(["rm", "-rf", "/var/cache/dnf"])
+        .with_exec(["c_rehash"])
+        .with_exec(
+            [
+                "mkdir",
+                "-p",
+                "/root/rpmbuild/BUILD",
+                "/root/rpmbuild/RPMS",
+                "/root/rpmbuild/SOURCES",
+                "/root/rpmbuild/SPECS",
+                "/root/rpmbuild/SRPMS",
+            ]
+        )
+    )
+
+    return ctr
+
+
+def build_rocky_linux_9(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("rockylinux:9")
+
+    pkgs = [pkg for pkg in _ROCKY_LINUX_COMMON_PACKAGES]
+
+    ctr = (
+        ctr.with_exec(["dnf", "distro-sync", "-y", "--nodocs"])
+        .with_exec(
+            [
+                "dnf",
+                "install",
+                "-y",
+                "--nodocs",
+                "dnf-command(config-manager)",
+                "epel-release",
+            ]
+        )
+        .with_exec(["dnf", "config-manager", "--set-enabled", "crb"])
+        .with_exec(["dnf", "clean", "packages"])
+        .with_exec(
+            [
+                "dnf",
+                "install",
+                "-y",
+                "--allowerasing",
+                "--nodocs",
+                "--setopt=install_weak_deps=False",
+                "--setopt=diskspacecheck=False",
+            ]
+            + pkgs
+        )
+        .with_exec(["rm", "-rf", "/var/cache/dnf"])
+        .with_exec(["c_rehash"])
+        .with_exec(
+            [
+                "mkdir",
+                "-p",
+                "/root/rpmbuild/BUILD",
+                "/root/rpmbuild/RPMS",
+                "/root/rpmbuild/SOURCES",
+                "/root/rpmbuild/SPECS",
+                "/root/rpmbuild/SRPMS",
+            ]
+        )
+    )
+
+    return ctr
+
+
+_CENTOS_STREAM_COMMON_PACKAGES = [
+    "autoconf",
+    "autoconf-archive",
+    "automake",
+    "bash",
+    "bison",
+    "cmake",
+    "cups-devel",
+    "curl",
+    "libcurl-devel",
+    "libyaml-devel",
+    "diffutils",
+    "elfutils-libelf-devel",
+    "findutils",
+    "flex",
+    "freeipmi-devel",
+    "gcc",
+    "gcc-c++",
+    "git",
+    "golang",
+    "json-c-devel",
+    "libatomic",
+    "libmnl-devel",
+    "libtool",
+    "libuuid-devel",
+    "libuv-devel",
+    # "libzstd-devel",
+    "lm_sensors",
+    "lz4-devel",
+    "make",
+    "ninja-build",
+    "nc",
+    "openssl-devel",
+    "openssl-perl",
+    "patch",
+    "pcre2-devel",
+    "pkgconfig",
+    "pkgconfig(libmongoc-1.0)",
+    "procps",
+    "protobuf-c-devel",
+    "protobuf-compiler",
+    "protobuf-devel",
+    "python3",
+    "python3-pyyaml",
+    "rpm-build",
+    "rpm-devel",
+    "rpmdevtools",
+    "snappy-devel",
+    "systemd-devel",
+    "wget",
+    "zlib-devel",
+]
+
+
+def build_centos_stream_8(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("quay.io/centos/centos:stream8")
+
+    pkgs = [pkg for pkg in _CENTOS_STREAM_COMMON_PACKAGES] + ["autogen"]
+
+    ctr = (
+        ctr.with_exec(["dnf", "distro-sync", "-y", "--nodocs"])
+        .with_exec(
+            [
+                "dnf",
+                "install",
+                "-y",
+                "--nodocs",
+                "dnf-command(config-manager)",
+                "epel-release",
+            ]
+        )
+        .with_exec(["dnf", "config-manager", "--set-enabled", "powertools"])
+        .with_exec(["dnf", "clean", "packages"])
+        .with_exec(
+            [
+                "dnf",
+                "install",
+                "-y",
+                "--nodocs",
+                "--setopt=install_weak_deps=False",
+                "--setopt=diskspacecheck=False",
+            ]
+            + pkgs
+        )
+        .with_exec(["rm", "-rf", "/var/cache/dnf"])
+        .with_exec(["c_rehash"])
+        .with_exec(
+            [
+                "mkdir",
+                "-p",
+                "/root/rpmbuild/BUILD",
+                "/root/rpmbuild/RPMS",
+                "/root/rpmbuild/SOURCES",
+                "/root/rpmbuild/SPECS",
+                "/root/rpmbuild/SRPMS",
+            ]
+        )
+    )
+
+    return ctr
+
+
+def build_centos_stream_9(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("quay.io/centos/centos:stream9")
+
+    pkgs = [pkg for pkg in _CENTOS_STREAM_COMMON_PACKAGES]
+
+    ctr = (
+        ctr.with_exec(["dnf", "distro-sync", "-y", "--nodocs"])
+        .with_exec(
+            [
+                "dnf",
+                "install",
+                "-y",
+                "--nodocs",
+                "dnf-command(config-manager)",
+                "epel-release",
+            ]
+        )
+        .with_exec(["dnf", "config-manager", "--set-enabled", "crb"])
+        .with_exec(["dnf", "clean", "packages"])
+        .with_exec(
+            [
+                "dnf",
+                "install",
+                "-y",
+                "--allowerasing",
+                "--nodocs",
+                "--setopt=install_weak_deps=False",
+                "--setopt=diskspacecheck=False",
+            ]
+            + pkgs
+        )
+        .with_exec(["rm", "-rf", "/var/cache/dnf"])
+        .with_exec(["c_rehash"])
+        .with_exec(
+            [
+                "mkdir",
+                "-p",
+                "/root/rpmbuild/BUILD",
+                "/root/rpmbuild/RPMS",
+                "/root/rpmbuild/SOURCES",
+                "/root/rpmbuild/SPECS",
+                "/root/rpmbuild/SRPMS",
+            ]
+        )
+    )
+
+    return ctr
+
+
+_ORACLE_LINUX_COMMON_PACKAGES = list(_ROCKY_LINUX_COMMON_PACKAGES)
+
+
+def build_oracle_linux_9(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("oraclelinux:9")
+
+    pkgs = [pkg for pkg in _ORACLE_LINUX_COMMON_PACKAGES]
+
+    repo_path = str(Path(__file__).parent.parent.parent)
+    this_path = os.path.join(repo_path, "packaging/dag")
+
+    ctr = (
+        ctr.with_file(
+            "/etc/yum.repos.d/ol9-epel.repo",
+            client.host().file(f"{this_path}/ol9-epel.repo"),
+        )
+        .with_exec(["dnf", "config-manager", "--set-enabled", "ol9_codeready_builder"])
+        .with_exec(["dnf", "config-manager", "--set-enabled", "ol9_developer_EPEL"])
+        .with_exec(["dnf", "distro-sync", "-y", "--nodocs"])
+        .with_exec(["dnf", "clean", "-y", "packages"])
+        .with_exec(
+            [
+                "dnf",
+                "install",
+                "-y",
+                "--nodocs",
+                "--setopt=install_weak_deps=False",
+                "--setopt=diskspacecheck=False",
+            ]
+            + pkgs
+        )
+        .with_exec(["rm", "-rf", "/var/cache/dnf"])
+        .with_exec(["c_rehash"])
+        .with_exec(
+            [
+                "mkdir",
+                "-p",
+                "/root/rpmbuild/BUILD",
+                "/root/rpmbuild/RPMS",
+                "/root/rpmbuild/SOURCES",
+                "/root/rpmbuild/SPECS",
+                "/root/rpmbuild/SRPMS",
+            ]
+        )
+    )
+
+    return ctr
+
+
+def build_oracle_linux_8(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("oraclelinux:8")
+
+    pkgs = [pkg for pkg in _ORACLE_LINUX_COMMON_PACKAGES] + ["autogen"]
+
+    repo_path = str(Path(__file__).parent.parent.parent)
+    this_path = os.path.join(repo_path, "packaging/dag")
+
+    ctr = (
+        ctr.with_file(
+            "/etc/yum.repos.d/ol8-epel.repo",
+            client.host().file(f"{this_path}/ol8-epel.repo"),
+        )
+        .with_exec(["dnf", "config-manager", "--set-enabled", "ol8_codeready_builder"])
+        .with_exec(["dnf", "distro-sync", "-y", "--nodocs"])
+        .with_exec(["dnf", "clean", "-y", "packages"])
+        .with_exec(
+            [
+                "dnf",
+                "install",
+                "-y",
+                "--nodocs",
+                "--setopt=install_weak_deps=False",
+                "--setopt=diskspacecheck=False",
+            ]
+            + pkgs
+        )
+        .with_exec(["rm", "-rf", "/var/cache/dnf"])
+        .with_exec(["c_rehash"])
+        .with_exec(
+            [
+                "mkdir",
+                "-p",
+                "/root/rpmbuild/BUILD",
+                "/root/rpmbuild/RPMS",
+                "/root/rpmbuild/SOURCES",
+                "/root/rpmbuild/SPECS",
+                "/root/rpmbuild/SRPMS",
+            ]
+        )
+    )
+
+    return ctr
+
+
+_OPENSUSE_COMMON_PACKAGES = [
+    "autoconf",
+    "autoconf-archive",
+    "autogen",
+    "automake",
+    "bison",
+    "cmake",
+    "cups",
+    "cups-devel",
+    "curl",
+    "diffutils",
+    "flex",
+    "freeipmi-devel",
+    "gcc",
+    "gcc-c++",
+    "git-core",
+    "go",
+    "json-glib-devel",
+    "judy-devel",
+    "libatomic1",
+    "libcurl-devel",
+    "libelf-devel",
+    "liblz4-devel",
+    "libjson-c-devel",
+    "libyaml-devel",
+    "libmnl0",
+    "libmnl-devel",
+    "libnetfilter_acct1",
+    "libnetfilter_acct-devel",
+    "libpcre2-8-0",
+    "libopenssl-devel",
+    "libtool",
+    "libuv-devel",
+    "libuuid-devel",
+    "libzstd-devel",
+    "make",
+    "ninja",
+    "patch",
+    "pkg-config",
+    "protobuf-devel",
+    "rpm-build",
+    "rpm-devel",
+    "rpmdevtools",
+    "snappy-devel",
+    "systemd-devel",
+    "tar",
+    "wget",
+    "xen-devel",
+]
+
+
+def build_opensuse_tumbleweed(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("opensuse/tumbleweed:latest")
+
+    pkgs = [pkg for pkg in _OPENSUSE_COMMON_PACKAGES] + ["protobuf-c"]
+
+    ctr = (
+        ctr.with_exec(["zypper", "update", "-y"])
+        .with_exec(
+            [
+                "zypper",
+                "install",
+                "-y",
+                "--allow-downgrade",
+            ]
+            + pkgs
+        )
+        .with_exec(["zypper", "clean"])
+        .with_exec(["rm", "-rf", "/var/cache/zypp/*/*"])
+        .with_exec(["c_rehash"])
+        .with_exec(
+            [
+                "mkdir",
+                "-p",
+                "/usr/src/packages/BUILD",
+                "/usr/src/packages/RPMS",
+                "/usr/src/packages/SOURCES",
+                "/usr/src/packages/SPECS",
+                "/usr/src/packages/SRPMS",
+            ]
+        )
+    )
+
+    return ctr
+
+
+def build_opensuse_15_5(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("opensuse/leap:15.5")
+
+    pkgs = [pkg for pkg in _OPENSUSE_COMMON_PACKAGES] + ["libprotobuf-c-devel"]
+
+    ctr = (
+        ctr.with_exec(["zypper", "update", "-y"])
+        .with_exec(
+            [
+                "zypper",
+                "install",
+                "-y",
+                "--allow-downgrade",
+            ]
+            + pkgs
+        )
+        .with_exec(["zypper", "clean"])
+        .with_exec(["rm", "-rf", "/var/cache/zypp/*/*"])
+        .with_exec(["c_rehash"])
+        .with_exec(
+            [
+                "mkdir",
+                "-p",
+                "/usr/src/packages/BUILD",
+                "/usr/src/packages/RPMS",
+                "/usr/src/packages/SOURCES",
+                "/usr/src/packages/SPECS",
+                "/usr/src/packages/SRPMS",
+            ]
+        )
+    )
+
+    return ctr
+
+
+def build_opensuse_15_4(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    crt = client.container(platform=platform).from_("opensuse/leap:15.4")
+
+    pkgs = [pkg for pkg in _OPENSUSE_COMMON_PACKAGES] + ["libprotobuf-c-devel"]
+
+    crt = (
+        crt.with_exec(["zypper", "update", "-y"])
+        .with_exec(
+            [
+                "zypper",
+                "install",
+                "-y",
+                "--allow-downgrade",
+            ]
+            + pkgs
+        )
+        .with_exec(["zypper", "clean"])
+        .with_exec(["rm", "-rf", "/var/cache/zypp/*/*"])
+        .with_exec(["c_rehash"])
+        .with_exec(
+            [
+                "mkdir",
+                "-p",
+                "/usr/src/packages/BUILD",
+                "/usr/src/packages/RPMS",
+                "/usr/src/packages/SOURCES",
+                "/usr/src/packages/SPECS",
+                "/usr/src/packages/SRPMS",
+            ]
+        )
+    )
+
+    return crt
+
+
+_FEDORA_COMMON_PACKAGES = [
+    "autoconf",
+    "autoconf-archive",
+    "autogen",
+    "automake",
+    "bash",
+    "bison",
+    "cmake",
+    "cups-devel",
+    "curl",
+    "diffutils",
+    "elfutils-libelf-devel",
+    "findutils",
+    "flex",
+    "freeipmi-devel",
+    "gcc",
+    "gcc-c++",
+    "git-core",
+    "golang",
+    "json-c-devel",
+    "libcurl-devel",
+    "libyaml-devel",
+    "Judy-devel",
+    "libatomic",
+    "libmnl-devel",
+    "libnetfilter_acct-devel",
+    "libtool",
+    "libuuid-devel",
+    "libuv-devel",
+    "libzstd-devel",
+    "lz4-devel",
+    "make",
+    "ninja-build",
+    "openssl-devel",
+    "openssl-perl",
+    "patch",
+    "pcre2-devel",
+    "pkgconfig",
+]
+
+
+def build_fedora_37(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("fedora:37")
+
+    pkgs = [pkg for pkg in _FEDORA_COMMON_PACKAGES]
+
+    ctr = (
+        ctr.with_exec(["dnf", "distro-sync", "-y", "--nodocs"])
+        .with_exec(["dnf", "clean", "-y", "packages"])
+        .with_exec(
+            [
+                "dnf",
+                "install",
+                "-y",
+                "--nodocs",
+                "--setopt=install_weak_deps=False",
+                "--setopt=diskspacecheck=False",
+            ]
+            + pkgs
+        )
+        .with_exec(["rm", "-rf", "/var/cache/dnf"])
+        .with_exec(["c_rehash"])
+        .with_exec(
+            [
+                "mkdir",
+                "-p",
+                "/root/rpmbuild/BUILD",
+                "/root/rpmbuild/RPMS",
+                "/root/rpmbuild/SOURCES",
+                "/root/rpmbuild/SPECS",
+                "/root/rpmbuild/SRPMS",
+            ]
+        )
+    )
+
+    return ctr
+
+
+def build_fedora_38(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("fedora:38")
+
+    pkgs = [pkg for pkg in _FEDORA_COMMON_PACKAGES]
+
+    ctr = (
+        ctr.with_exec(["dnf", "distro-sync", "-y", "--nodocs"])
+        .with_exec(["dnf", "clean", "-y", "packages"])
+        .with_exec(
+            [
+                "dnf",
+                "install",
+                "-y",
+                "--nodocs",
+                "--setopt=install_weak_deps=False",
+                "--setopt=diskspacecheck=False",
+            ]
+            + pkgs
+        )
+        .with_exec(["rm", "-rf", "/var/cache/dnf"])
+        .with_exec(["c_rehash"])
+        .with_exec(
+            [
+                "mkdir",
+                "-p",
+                "/root/rpmbuild/BUILD",
+                "/root/rpmbuild/RPMS",
+                "/root/rpmbuild/SOURCES",
+                "/root/rpmbuild/SPECS",
+                "/root/rpmbuild/SRPMS",
+            ]
+        )
+    )
+
+    return ctr
+
+
+def build_fedora_39(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("fedora:39")
+
+    pkgs = [pkg for pkg in _FEDORA_COMMON_PACKAGES]
+
+    ctr = (
+        ctr.with_exec(["dnf", "distro-sync", "-y", "--nodocs"])
+        .with_exec(["dnf", "clean", "-y", "packages"])
+        .with_exec(
+            [
+                "dnf",
+                "install",
+                "-y",
+                "--nodocs",
+                "--setopt=install_weak_deps=False",
+                "--setopt=diskspacecheck=False",
+            ]
+            + pkgs
+        )
+        .with_exec(["rm", "-rf", "/var/cache/dnf"])
+        .with_exec(["c_rehash"])
+        .with_exec(
+            [
+                "mkdir",
+                "-p",
+                "/root/rpmbuild/BUILD",
+                "/root/rpmbuild/RPMS",
+                "/root/rpmbuild/SOURCES",
+                "/root/rpmbuild/SPECS",
+                "/root/rpmbuild/SRPMS",
+            ]
+        )
+    )
+
+    return ctr
+
+
+_DEBIAN_COMMON_PACKAGES = [
+    "autoconf",
+    "autoconf-archive",
+    "autogen",
+    "automake",
+    "bison",
+    "build-essential",
+    "ca-certificates",
+    "cmake",
+    "curl",
+    "dh-autoreconf",
+    "dh-make",
+    "dpkg-dev",
+    "flex",
+    "g++",
+    "gcc",
+    "git-buildpackage",
+    "git-core",
+    "golang",
+    "libatomic1",
+    "libcurl4-openssl-dev",
+    "libcups2-dev",
+    "libdistro-info-perl",
+    "libelf-dev",
+    "libipmimonitoring-dev",
+    "libjson-c-dev",
+    "libyaml-dev",
+    "libjudy-dev",
+    "liblz4-dev",
+    "libmnl-dev",
+    "libmongoc-dev",
+    "libnetfilter-acct-dev",
+    "libpcre2-dev",
+    "libprotobuf-dev",
+    "libprotoc-dev",
+    "libsnappy-dev",
+    "libsystemd-dev",
+    "libssl-dev",
+    "libtool",
+    "libuv1-dev",
+    "libzstd-dev",
+    "make",
+    "ninja-build",
+    "pkg-config",
+    "protobuf-compiler",
+    "systemd",
+    "uuid-dev",
+    "wget",
+    "zlib1g-dev",
+]
+
+
+def build_debian_10(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("debian:buster")
+
+    pkgs = [pkg for pkg in _DEBIAN_COMMON_PACKAGES] + ["dh-systemd", "libxen-dev"]
+
+    ctr = (
+        ctr.with_env_variable("DEBIAN_FRONTEND", "noninteractive")
+        .with_exec(["apt-get", "update"])
+        .with_exec(["apt-get", "upgrade", "-y"])
+        .with_exec(["apt-get", "install", "-y", "--no-install-recommends"] + pkgs)
+        .with_exec(["apt-get", "clean"])
+        .with_exec(["c_rehash"])
+        .with_exec(["rm", "-rf", "/var/lib/apt/lists/*"])
+    )
+
+    return ctr
+
+
+def build_debian_11(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("debian:bullseye")
+
+    pkgs = [pkg for pkg in _DEBIAN_COMMON_PACKAGES] + ["libxen-dev"]
+
+    ctr = (
+        ctr.with_env_variable("DEBIAN_FRONTEND", "noninteractive")
+        .with_exec(["apt-get", "update"])
+        .with_exec(["apt-get", "upgrade", "-y"])
+        .with_exec(["apt-get", "install", "-y", "--no-install-recommends"] + pkgs)
+        .with_exec(["apt-get", "clean"])
+        .with_exec(["c_rehash"])
+        .with_exec(["rm", "-rf", "/var/lib/apt/lists/*"])
+    )
+
+    return ctr
+
+
+def build_debian_12(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("debian:bookworm")
+
+    pkgs = [pkg for pkg in _DEBIAN_COMMON_PACKAGES]
+
+    if platform != dagger.Platform("linux/i386"):
+        pkgs.append("libxen-dev")
+
+    ctr = (
+        ctr.with_env_variable("DEBIAN_FRONTEND", "noninteractive")
+        .with_exec(["apt-get", "update"])
+        .with_exec(["apt-get", "upgrade", "-y"])
+        .with_exec(["apt-get", "install", "-y", "--no-install-recommends"] + pkgs)
+        .with_exec(["apt-get", "clean"])
+        .with_exec(["c_rehash"])
+        .with_exec(["rm", "-rf", "/var/lib/apt/lists/*"])
+    )
+
+    return ctr
+
+
+_UBUNTU_COMMON_PACKAGES = [
+    "autoconf",
+    "autoconf-archive",
+    "autogen",
+    "automake",
+    "bison",
+    "build-essential",
+    "ca-certificates",
+    "cmake",
+    "curl",
+    "dh-autoreconf",
+    "dh-make",
+    "dpkg-dev",
+    "flex",
+    "g++",
+    "gcc",
+    "git-buildpackage",
+    "git-core",
+    "golang",
+    "libatomic1",
+    "libcurl4-openssl-dev",
+    "libcups2-dev",
+    "libdistro-info-perl",
+    "libelf-dev",
+    "libipmimonitoring-dev",
+    "libjson-c-dev",
+    "libyaml-dev",
+    "libjudy-dev",
+    "liblz4-dev",
+    "libmnl-dev",
+    "libmongoc-dev",
+    "libnetfilter-acct-dev",
+    "libpcre2-dev",
+    "libprotobuf-dev",
+    "libprotoc-dev",
+    "libsnappy-dev",
+    "libsystemd-dev",
+    "libssl-dev",
+    "libtool",
+    "libuv1-dev",
+    "libxen-dev",
+    "libzstd-dev",
+    "make",
+    "ninja-build",
+    "pkg-config",
+    "protobuf-compiler",
+    "systemd",
+    "uuid-dev",
+    "wget",
+    "zlib1g-dev",
+]
+
+
+def build_ubuntu_20_04(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("ubuntu:20.04")
+
+    pkgs = [pkg for pkg in _UBUNTU_COMMON_PACKAGES] + ["dh-systemd"]
+
+    ctr = (
+        ctr.with_env_variable("DEBIAN_FRONTEND", "noninteractive")
+        .with_exec(["apt-get", "update"])
+        .with_exec(["apt-get", "upgrade", "-y"])
+        .with_exec(["apt-get", "install", "-y", "--no-install-recommends"] + pkgs)
+        .with_exec(["apt-get", "clean"])
+        .with_exec(["c_rehash"])
+        .with_exec(["rm", "-rf", "/var/lib/apt/lists/*"])
+    )
+
+    #
+    # FIXME: add kitware for cmake on arm-hf
+    #
+
+    return ctr
+
+
+def build_ubuntu_22_04(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("ubuntu:22.04")
+
+    pkgs = [pkg for pkg in _UBUNTU_COMMON_PACKAGES]
+
+    ctr = (
+        ctr.with_env_variable("DEBIAN_FRONTEND", "noninteractive")
+        .with_exec(["apt-get", "update"])
+        .with_exec(["apt-get", "upgrade", "-y"])
+        .with_exec(["apt-get", "install", "-y", "--no-install-recommends"] + pkgs)
+        .with_exec(["apt-get", "clean"])
+        .with_exec(["c_rehash"])
+        .with_exec(["rm", "-rf", "/var/lib/apt/lists/*"])
+    )
+
+    return ctr
+
+
+def build_ubuntu_23_04(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("ubuntu:23.04")
+
+    pkgs = [pkg for pkg in _UBUNTU_COMMON_PACKAGES]
+
+    ctr = (
+        ctr.with_env_variable("DEBIAN_FRONTEND", "noninteractive")
+        .with_exec(["apt-get", "update"])
+        .with_exec(["apt-get", "upgrade", "-y"])
+        .with_exec(["apt-get", "install", "-y", "--no-install-recommends"] + pkgs)
+        .with_exec(["apt-get", "clean"])
+        .with_exec(["c_rehash"])
+        .with_exec(["rm", "-rf", "/var/lib/apt/lists/*"])
+    )
+
+    return ctr
+
+
+def build_ubuntu_23_10(
+    client: dagger.Client, platform: dagger.Platform
+) -> dagger.Container:
+    ctr = client.container(platform=platform).from_("ubuntu:23.10")
+
+    pkgs = [pkg for pkg in _UBUNTU_COMMON_PACKAGES]
+
+    ctr = (
+        ctr.with_env_variable("DEBIAN_FRONTEND", "noninteractive")
+        .with_exec(["apt-get", "update"])
+        .with_exec(["apt-get", "upgrade", "-y"])
+        .with_exec(["apt-get", "install", "-y", "--no-install-recommends"] + pkgs)
+        .with_exec(["apt-get", "clean"])
+        .with_exec(["c_rehash"])
+        .with_exec(["rm", "-rf", "/var/lib/apt/lists/*"])
+    )
+
+    return ctr
+
+
+def install_cargo(ctr: dagger.Container) -> dagger.Container:
+    bin_paths = [
+        "/root/.cargo/bin",
+        "/usr/local/sbin",
+        "/usr/local/bin",
+        "/usr/sbin",
+        "/usr/bin",
+        "/sbin",
+        "/bin",
+    ]
+
+    ctr = (
+        ctr.with_workdir("/")
+        .with_exec(["sh", "-c", "curl https://sh.rustup.rs -sSf | sh -s -- -y"])
+        .with_env_variable("PATH", ":".join(bin_paths))
+        .with_exec(["cargo", "new", "--bin", "hello"])
+        .with_workdir("/hello")
+        .with_exec(["cargo", "run", "-v", "-v"])
+    )
+
+    return ctr

packaging/dag/main.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+
+import click
+
+from test_command import test
+from build_command import build
+
+
+@click.group()
+def cli():
+    pass
+
+
+cli.add_command(test)
+cli.add_command(build)
+
+if __name__ == "__main__":
+    cli()