netdata/packaging/dag/imageutils.py

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",
        "--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