build.zig

const std = @import("std");
const file_lists = @import("generated.zig");

const Build = std.Build;
const ExecutableList = std.ArrayList(struct { name: []const u8, mod: *Build.Module });

pub fn build(b: *Build) !void {
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});
    const linkmode = b.option(
        std.builtin.LinkMode,
        "link_mode",
        "Compile static or dynamic libraries. Defaults to static",
    ) orelse .static;
    const pic = b.option(
        bool,
        "pic",
        "Produce Position Independent Code. Defaults to true when link_mode is dynamic, to the target's default otherwise",
    ) orelse if (linkmode == .dynamic) true else null; // PIC is required when dynamic, and there is no need to disable it when static

    // Generate bindings from grpc C headers
    const include_all = b.addWriteFile("grpc_api.h",
        \\#include <grpc/grpc.h>
        \\#include <grpc/credentials.h>
        \\#include <grpc/byte_buffer_reader.h>
    );
    const grpc_capi = b.addTranslateC(.{
        .root_source_file = try include_all.getDirectory().join(b.allocator, "grpc_api.h"),
        .target = target,
        // Since Zig 0.18, `standardOptimizeOption` may return null, which `addTranslateC` does not accept
        .optimize = if (@typeInfo(@TypeOf(optimize)) == .optional) optimize orelse .Debug else optimize,
    });
    const bindings = grpc_capi.addModule("cgrpc");

    if (b.systemIntegrationOption("grpc", .{})) {
        bindings.linkSystemLibrary("grpc", .{});
        return;
    }

    // Core library, declared before the dependencies are known to be available,
    // so that packages depending on this one can always find it
    const grpc = b.createModule(.{
        .target = target,
        .optimize = optimize,
        .link_libcpp = true,
        .pic = pic,
    });
    const libgrpc = b.addLibrary(.{
        .name = "grpc",
        .root_module = grpc,
        .linkage = linkmode,
        .version = file_lists.core_version,
    });
    b.installArtifact(libgrpc);
    bindings.linkLibrary(libgrpc);
    if (linkmode == .dynamic) {
        // Find libgrpc in the `lib` directory installed next to `bin`, once installed
        bindings.addRPathSpecial(if (target.result.os.tag.isDarwin()) "@executable_path/../lib" else "$ORIGIN/../lib");
    }
    if (linkmode == .dynamic and target.result.ofmt == .elf) {
        // Hidden visibility leaves the symbols c-ares and the C++ runtime explicitly export,
        // so hide them here (version scripts have no equivalent on Mach-O)
        const version_script = b.addWriteFiles().add("libgrpc.map",
            \\{
            \\  local:
            \\    ares_*;
            \\    /* operator new, new[], delete and delete[] */
            \\    _Znw*;
            \\    _Zna*;
            \\    _Zdl*;
            \\    _Zda*;
            \\};
        );
        libgrpc.setVersionScript(version_script);
    }

    // Dependencies, lazy as they are not needed when using the system's libgrpc.
    // They are all requested before returning, so that missing ones are fetched together
    const deps = .{
        .upstream = b.lazyDependency("upstream", .{}),
        .abseil = b.lazyDependency("abseil", .{}),
        .re2 = b.lazyDependency("re2", .{}),
        .boringssl = b.lazyDependency("boringssl", .{}),
        .cares = b.lazyDependency("cares", .{}),
        .gtest = b.lazyDependency("gtest", .{}),
        .zlib = b.lazyDependency("zlib", .{}),
    };
    const upstream = deps.upstream orelse return;
    const abseil = deps.abseil orelse return;
    const re2 = deps.re2 orelse return;
    const boringssl = deps.boringssl orelse return;
    const cares = deps.cares orelse return;
    const gtest = deps.gtest orelse return;
    const zlib = deps.zlib orelse return;

    grpc_capi.addIncludePath(upstream.path("include"));

    const libs_step = b.step("dependencies", "Install libraries libgrpc depends on");

    // C-Ares Library
    const caresmod = b.createModule(.{
        .target = target,
        .optimize = optimize,
        .link_libc = true,
        .pic = pic,
    });
    const libcares = b.addLibrary(.{ .name = "cares", .root_module = caresmod });
    const cares_config = switch (target.result.os.tag) {
        .linux => "config_linux",
        .macos, .ios, .tvos, .watchos => "config_darwin",
        .freebsd => "config_freebsd",
        .openbsd => "config_openbsd",
        else => return error.OsNotSupported,
    };
    caresmod.addCSourceFiles(.{
        .root = cares.path(""),
        .files = &file_lists.libcares_src,
        .flags = &bundled_c_flags,
    });
    caresmod.addCMacro("_GNU_SOURCE", "1");
    caresmod.addCMacro("_HAS_EXCEPTIONS", "0");
    caresmod.addCMacro("NOMINMAX", "1");
    caresmod.addCMacro("HAVE_CONFIG_H", "1");
    caresmod.addIncludePath(upstream.path("third_party/cares"));
    caresmod.addIncludePath(cares.path("include"));
    caresmod.addIncludePath(cares.path("src/lib"));
    caresmod.addIncludePath(cares.path("src/lib/include"));
    caresmod.addIncludePath(upstream.path("third_party/cares").path(b, cares_config));
    libcares.installHeadersDirectory(cares.path("include"), "", .{});
    libcares.installHeader(upstream.path("third_party/cares/ares_build.h"), "ares_build.h");
    libcares.installHeader(upstream.path("third_party/cares").path(b, cares_config).path(b, "ares_config.h"), "ares_config.h");
    libs_step.dependOn(&b.addInstallArtifact(libcares, .{}).step);

    // Abseil
    const abseilmod = b.createModule(.{
        .target = target,
        .optimize = optimize,
        .link_libcpp = true,
        .pic = pic,
    });
    const libabseil = b.addLibrary(.{ .name = "abseil", .root_module = abseilmod });
    abseilmod.addCSourceFiles(.{
        .root = abseil.path(""),
        .files = &file_lists.libgrpc_third_party_abseil_cpp,
        .flags = &bundled_cxx_flags,
    });
    abseilmod.addIncludePath(abseil.path(""));
    libabseil.installHeadersDirectory(abseil.path("absl"), "absl", .{
        .include_extensions = &.{ ".h", ".inc" },
    });
    libs_step.dependOn(&b.addInstallArtifact(libabseil, .{}).step);

    // UTF8-range
    const utf8mod = b.createModule(.{
        .target = target,
        .optimize = optimize,
        .link_libc = true,
        .pic = pic,
    });
    const libutf8 = b.addLibrary(.{ .name = "utf8-range", .root_module = utf8mod });
    utf8mod.addCSourceFiles(.{
        .root = upstream.path("third_party/utf8_range"),
        .files = &file_lists.libgrpc_third_party_utf8_range,
        .flags = &bundled_c_flags,
    });
    libutf8.installHeader(
        upstream.path("third_party/utf8_range/utf8_range.h"),
        "utf8_range.h",
    );
    libs_step.dependOn(&b.addInstallArtifact(libutf8, .{}).step);

    // upb
    const upbmod = b.createModule(.{
        .target = target,
        .optimize = optimize,
        .link_libc = true,
        .pic = pic,
    });
    const libupb = b.addLibrary(.{ .name = "upb", .root_module = upbmod });
    upbmod.addCSourceFiles(.{
        .root = upstream.path("third_party/upb"),
        .files = &file_lists.libgrpc_third_party_upb,
        .flags = &bundled_c_flags,
    });
    // Those are all generated upb files
    upbmod.addCSourceFiles(.{
        .root = upstream.path("src/core"),
        .files = &file_lists.libgrpc_src_core_c,
        .flags = &bundled_c_flags,
    });
    upbmod.addIncludePath(upstream.path("third_party/upb"));
    upbmod.addIncludePath(upstream.path("src/core/ext/upb-gen"));
    upbmod.addIncludePath(upstream.path("src/core/ext/upbdefs-gen"));
    upbmod.linkLibrary(libutf8);
    libs_step.dependOn(&b.addInstallArtifact(libupb, .{}).step);

    // BoringSSL
    const sslmod = b.createModule(.{
        .target = target,
        .optimize = optimize,
        .link_libcpp = true,
        .pic = pic,
    });
    const libssl = b.addLibrary(.{ .name = "ssl", .root_module = sslmod });
    sslmod.addCSourceFiles(.{
        .root = boringssl.path(""),
        .files = &file_lists.libboringssl_src,
        .flags = &(bundled_cxx_flags ++ .{"-fno-exceptions"}),
    });
    sslmod.addCMacro("OPENSSL_NO_ASM", "1");
    sslmod.addCMacro("_GNU_SOURCE", "1");
    sslmod.addCMacro("_HAS_EXCEPTIONS", "0");
    sslmod.addCMacro("NOMINMAX", "1");
    sslmod.addIncludePath(boringssl.path("include"));
    libssl.installHeadersDirectory(boringssl.path("include/openssl"), "openssl", .{});
    libs_step.dependOn(&b.addInstallArtifact(libssl, .{}).step);

    // zlib
    const zmod = b.createModule(.{
        .target = target,
        .optimize = optimize,
        .link_libc = true,
        .pic = pic,
    });
    const libz = b.addLibrary(.{ .name = "z", .root_module = zmod });
    zmod.addCSourceFiles(.{
        .root = zlib.path(""),
        .files = &file_lists.libz_src,
        .flags = &bundled_c_flags,
    });
    zmod.addCMacro("HAVE_UNISTD_H", "1");
    libz.installHeadersDirectory(zlib.path(""), "", .{
        .include_extensions = &.{ "zconf.h", "zlib.h" },
    });
    libs_step.dependOn(&b.addInstallArtifact(libz, .{}).step);

    // Address Sorting
    const addrsort = b.createModule(.{
        .target = target,
        .optimize = optimize,
        .link_libc = true,
        .pic = pic,
    });
    const libaddrsort = b.addLibrary(.{ .name = "addresssorting", .root_module = addrsort });
    addrsort.addCSourceFiles(.{
        .root = upstream.path("third_party/address_sorting"),
        .files = &file_lists.libgrpc_third_party_address_sorting,
        .flags = &bundled_c_flags,
    });
    addrsort.addIncludePath(upstream.path("third_party/address_sorting/include"));
    libaddrsort.installHeadersDirectory(upstream.path("third_party/address_sorting/include/address_sorting"), "address_sorting", .{});
    libs_step.dependOn(&b.addInstallArtifact(libaddrsort, .{}).step);

    // re2
    const re2mod = b.createModule(.{
        .target = target,
        .optimize = optimize,
        .link_libcpp = true,
        .pic = pic,
    });
    const libre2 = b.addLibrary(.{ .name = "re2", .root_module = re2mod });
    re2mod.addCSourceFiles(.{
        .root = re2.path(""),
        .files = &file_lists.libgrpc_third_party_re2,
        .flags = &bundled_cxx_flags,
    });
    re2mod.addIncludePath(re2.path(""));
    libre2.installHeadersDirectory(re2.path("re2"), "re2", .{});
    libs_step.dependOn(&b.addInstallArtifact(libre2, .{}).step);

    // Core library
    grpc.addCSourceFiles(.{
        .root = upstream.path("src/core"),
        .files = &file_lists.libgrpc_src_core_cpp,
        // Inline functions of the bundled libraries would otherwise be exported along with gRPC's
        .flags = &(cxx_flags ++ .{ "-fno-exceptions", "-fvisibility-inlines-hidden" }),
    });
    grpc.addIncludePath(upstream.path("include"));
    grpc.addIncludePath(upstream.path(""));
    grpc.addIncludePath(upstream.path("src/core/ext/upb-gen"));
    grpc.addIncludePath(upstream.path("src/core/ext/upbdefs-gen"));
    grpc.addIncludePath(upstream.path("third_party/xxhash"));
    grpc.addIncludePath(upstream.path("third_party/upb"));
    grpc.linkLibrary(libcares);
    grpc.linkLibrary(libabseil);
    grpc.linkLibrary(libupb);
    grpc.linkLibrary(libssl);
    grpc.linkLibrary(libz);
    grpc.linkLibrary(libaddrsort);
    grpc.linkLibrary(libre2);
    if (target.result.os.tag.isDarwin()) {
        grpc.linkFramework("CoreFoundation", .{});
        grpc.addCMacro("OSATOMIC_USE_INLINED", "1");
    }
    libgrpc.installHeadersDirectory(upstream.path("include/grpc"), "grpc", .{});

    { // Build tests to ensure no symbols are missing
        const example_step = b.step("examples", "Build example programs");
        const test_step = b.step("test", "Run test programs");

        // Googletest library
        const gtestmod = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .link_libcpp = true,
        });
        const libgtest = b.addLibrary(.{ .name = "gtest", .root_module = gtestmod });
        gtestmod.addCSourceFiles(.{
            .root = gtest.path("googletest/src"),
            .files = &gtest_srcs,
            .flags = &cxx_flags,
        });
        gtestmod.addIncludePath(gtest.path("googletest/include"));
        gtestmod.addIncludePath(gtest.path("googletest"));
        libgtest.installHeadersDirectory(gtest.path("googletest/include"), "", .{});

        // test_util:build
        const testbuildmod = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .link_libcpp = true,
        });
        const libtestbuild = b.addLibrary(.{ .name = "test_util_build", .root_module = testbuildmod });
        testbuildmod.addCSourceFile(.{
            .file = upstream.path("test/core/test_util/build.cc"),
            .flags = &cxx_flags,
        });
        libtestbuild.installHeader(upstream.path("test/core/test_util/build.h"), "build.h");

        // const testutilbasemod = b.createModule(.{
        //     .target = target,
        //     .optimize = optimize,
        //     .link_libcpp = true,
        // });
        // const libtestutilbase = b.addLibrary(.{ .name = "grpc_test_util_base", .root_module = testutilbasemod });
        // testutilbasemod.addCSourceFiles(.{
        //     .root = upstream.path("test/core/test_util"),
        //     .files = &grpc_test_util_base.srcs,
        //     .flags = &cxx_flags,
        // });
        // testutilbasemod.addIncludePath(upstream.path(""));
        // testutilbasemod.linkLibrary(libgrpc);
        // libtestutilbase.installHeadersDirectory(upstream.path("test/core/test_util"), "", .{
        //     .include_extensions = &grpc_test_util_base.hdrs,
        // });

        // const testutilmod = b.createModule(.{
        //     .target = target,
        //     .optimize = optimize,
        //     .link_libcpp = true,
        // });
        // const libtestutil = b.addLibrary(.{ .name = "grpc_test_util", .root_module = testutilmod });
        // testutilmod.addCSourceFiles(.{
        //     .root = upstream.path("test/core/test_util"),
        //     .files = &grpc_test_util.srcs,
        //     .flags = &cxx_flags,
        // });
        // testutilmod.addIncludePath(upstream.path(""));
        // testutilmod.addIncludePath(upstream.path("src/core/ext/upb-gen"));
        // testutilmod.addIncludePath(upstream.path("src/core/ext/upbdefs-gen"));
        // testutilmod.linkLibrary(libtestutilbase);
        // libtestutilbase.installHeadersDirectory(upstream.path("test/core/test_util"), "", .{
        //     .include_extensions = &grpc_test_util.hdrs,
        // });

        var tests: ExecutableList = try .initCapacity(b.allocator, 64);
        defer tests.deinit(b.allocator);

        {
            const mod = b.createModule(.{ .target = target, .optimize = optimize, .link_libcpp = true });
            mod.addCSourceFile(.{ .file = upstream.path("test/core/client_idle/idle_filter_state_test.cc"), .flags = &cxx_flags });
            tests.appendAssumeCapacity(.{ .name = "idle_filter_state", .mod = mod });
        }
        {
            const mod = b.createModule(.{ .target = target, .optimize = optimize, .link_libcpp = true });
            mod.addCSourceFile(.{ .file = upstream.path("test/core/config/core_configuration_test.cc"), .flags = &cxx_flags });
            mod.addIncludePath(upstream.path("src/core/ext/upb-gen"));
            mod.addIncludePath(upstream.path("src/core/ext/upbdefs-gen"));
            mod.addIncludePath(upstream.path("third_party/upb"));
            tests.appendAssumeCapacity(.{ .name = "core_configuration", .mod = mod });
        }
        {
            const mod = b.createModule(.{ .target = target, .optimize = optimize, .link_libcpp = true });
            mod.addCSourceFile(.{ .file = upstream.path("test/core/config/load_config_test.cc"), .flags = &cxx_flags });
            tests.appendAssumeCapacity(.{ .name = "load_config", .mod = mod });
        }
        {
            const mod = b.createModule(.{ .target = target, .optimize = optimize, .link_libcpp = true });
            mod.addCSourceFile(.{ .file = upstream.path("test/core/slice/slice_string_helpers_test.cc"), .flags = &cxx_flags });
            tests.appendAssumeCapacity(.{ .name = "slice_string_helpers", .mod = mod });
        }
        {
            const mod = b.createModule(.{ .target = target, .optimize = optimize, .link_libcpp = true });
            mod.addCSourceFile(.{ .file = upstream.path("test/core/slice/slice_test.cc"), .flags = &cxx_flags });
            mod.linkLibrary(libtestbuild);
            tests.appendAssumeCapacity(.{ .name = "slice", .mod = mod });
        }

        for (tests.items) |ite| {
            const exe = b.addExecutable(.{ .name = ite.name, .root_module = ite.mod });
            const install_exe = b.addInstallArtifact(exe, .{});
            const run_exe = b.addRunArtifact(exe);
            ite.mod.addIncludePath(upstream.path(""));
            ite.mod.linkLibrary(libgrpc);
            ite.mod.linkLibrary(libgtest);
            ite.mod.linkLibrary(libabseil);
            if (target.result.os.tag.isDarwin())
                ite.mod.linkFramework("CoreFoundation", .{});
            example_step.dependOn(&install_exe.step);
            test_step.dependOn(&run_exe.step);
        }
    }
}

const common_flags = .{ "-Wall", "-Wextra" };
const c_flags = common_flags ++ .{"-std=c11"};
const cxx_flags = common_flags ++ .{"-std=c++17"};
// The bundled libraries are only used by libgrpc: a dynamic libgrpc should not export them,
// so that they cannot conflict with other versions loaded by the same program
const bundled_c_flags = c_flags ++ .{"-fvisibility=hidden"};
const bundled_cxx_flags = cxx_flags ++ .{"-fvisibility=hidden"};

const gtest_srcs = .{
    "gtest-assertion-result.cc",
    "gtest-death-test.cc",
    "gtest-filepath.cc",
    "gtest-matchers.cc",
    "gtest-port.cc",
    "gtest-printers.cc",
    "gtest-test-part.cc",
    "gtest-typed-test.cc",
    "gtest.cc",
};

// const grpc_test_util_base = struct {
//     pub const srcs = .{
//         "cmdline.cc",
//         "grpc_profiler.cc",
//         "histogram.cc",
//         "mock_endpoint.cc",
//         "parse_hexstring.cc",
//         "resolve_localhost_ip46.cc",
//         "slice_splitter.cc",
//         "tracer_util.cc",
//     };

//     pub const hdrs = .{
//         "cmdline.h",
//         "evaluate_args_test_util.h",
//         "grpc_profiler.h",
//         "histogram.h",
//         "mock_endpoint.h",
//         "parse_hexstring.h",
//         "resolve_localhost_ip46.h",
//         "slice_splitter.h",
//         "tracer_util.h",
//     };
// };

// const grpc_test_util = struct {
//     pub const srcs = .{
//         "port.cc",
//         "port_ci.cc",
//         "port_server_client.cc",
//         "reconnect_server.cc",
//         "test_config.cc",
//         "test_tcp_server.cc",
//         "tls_utils.cc",
//     };

//     pub const hdrs = .{
//         "port.h",
//         "reconnect_server.h",
//         "port_server_client.h",
//         "test_config.h",
//         "test_tcp_server.h",
//         "tls_utils.h",
//     };
// };