build.zig

const std = @import("std");

// Although this function looks imperative, note that its job is to
// declaratively construct a build graph that will be executed by an external
// runner.
pub fn build(b: *std.Build) void {
    b.reference_trace = 64;

    // Standard target options allows the person running `zig build` to choose
    // what target to build for. Here we do not override the defaults, which
    // means any target is allowed, and the default is native. Other options
    // for restricting supported target set are available.
    const target = b.standardTargetOptions(.{});

    // Standard optimization options allow the person running `zig build` to select
    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not
    // set a preferred release mode, allowing the user to decide how to optimize.
    const optimize = b.standardOptimizeOption(.{});

    const clap = b.dependency("clap", .{
        .optimize = optimize,
        .target = target,
    });

    const runtime = b.addExecutable(.{
        .name = "runtime",
        .root_source_file = b.path("src/main.zig"),
        .target = target,
        .optimize = optimize,
        .link_libc = true,
    });

    runtime.addIncludePath(b.path("crun"));
    runtime.addIncludePath(b.path("crun/src"));
    runtime.addIncludePath(b.path("crun/libocispec/src"));
    runtime.addObjectFile(b.path("crun/.libs/libcrun.a"));

    const skip_crun_build = b.option(bool, "skip_crun_build", "Skip crun build") orelse false;

    if (!skip_crun_build) {
        const crun_autogen = b.addSystemCommand(&[_][]const u8{
            "./autogen.sh",
        });
        crun_autogen.setCwd(b.path("crun"));

        const crun_configure = b.addSystemCommand(&[_][]const u8{
            "./configure",
            "--enable-embedded-yajl",
            "--disable-systemd",
            "--disable-caps",
            "--disable-seccomp",
        });
        crun_configure.setCwd(b.path("crun"));
        crun_configure.step.dependOn(&crun_autogen.step);

        const crun_make = b.addSystemCommand(&[_][]const u8{
            "make",
            "-j",
        });
        crun_make.setCwd(b.path("crun"));
        crun_make.step.dependOn(&crun_configure.step);
        runtime.step.dependOn(&crun_make.step);
    }

    const go_cpu_arch = switch (target.query.cpu_arch orelse target.result.cpu.arch) {
        .x86_64 => "amd64",
        .aarch64 => "arm64",
        else => @panic("unimplemented"),
    };
    const umoci = b.addSystemCommand(&[_][]const u8{
        "go",
        "build",
        "-tags",
        "",
        "-ldflags",
        "-s -extldflags '-static'",
        "-o",
    });
    umoci.setCwd(b.path("umoci"));
    const umoci_output = umoci.addOutputFileArg("umoci");
    umoci.addArg("github.com/opencontainers/umoci/cmd/umoci");
    umoci.setEnvironmentVariable(
        "CGO_ENABLED",
        "0",
    );

    umoci.setEnvironmentVariable("GOARCH", go_cpu_arch);

    const skopeo = b.addSystemCommand(&[_][]const u8{
        "go",
        "build",
        "-gcflags",
        "",
        "-tags",
        "containers_image_openpgp",
        "-o",
    });
    skopeo.setCwd(b.path("skopeo"));
    const skopeo_output = skopeo.addOutputFileArg("skopeo");
    skopeo.addArg("./cmd/skopeo");

    skopeo.setEnvironmentVariable(
        "CGO_ENABLED",
        "0",
    );
    skopeo.setEnvironmentVariable("GOARCH", go_cpu_arch);
    skopeo.setEnvironmentVariable("DISABLE_DOCS", "1");

    const dockerc = b.addExecutable(.{
        .name = "dockerc",
        .root_source_file = b.path("src/dockerc.zig"),
        .target = target,
        .optimize = optimize,
        .link_libc = true,
    });

    dockerc.root_module.addAnonymousImport(
        "runtime",
        .{ .root_source_file = runtime.getEmittedBin() },
    );

    dockerc.root_module.addAnonymousImport(
        "umoci",
        .{ .root_source_file = umoci_output },
    );
    dockerc.root_module.addAnonymousImport(
        "skopeo",
        .{ .root_source_file = skopeo_output },
    );

    dockerc.root_module.addImport("clap", clap.module("clap"));

    b.installArtifact(dockerc);

    // This declares intent for the executable to be installed into the
    // standard location when the user invokes the "install" step (the default
    // step when running `zig build`).
    // b.installArtifact(exe);

    // This *creates* a Run step in the build graph, to be executed when another
    // step is evaluated that depends on it. The next line below will establish
    // such a dependency.
    // const run_cmd = b.addRunArtifact(exe);

    // By making the run step depend on the install step, it will be run from the
    // installation directory rather than directly from within the cache directory.
    // This is not necessary, however, if the application depends on other installed
    // files, this ensures they will be present and in the expected location.
    // run_cmd.step.dependOn(b.getInstallStep());

    // This allows the user to pass arguments to the application in the build
    // command itself, like this: `zig build run -- arg1 arg2 etc`
    // if (b.args) |args| {
    //     run_cmd.addArgs(args);
    // }

    // This creates a build step. It will be visible in the `zig build --help` menu,
    // and can be selected like this: `zig build run`
    // This will evaluate the `run` step rather than the default, which is "install".
    // const run_step = b.step("run", "Run the app");
    // run_step.dependOn(&run_cmd.step);
}