如何在Go Gazelle项目中使用Bazel平台转换

Question

我有一个(纯粹的) Go项目是用Gazelle建立的。它有一个主要的二进制，它由Gazelle生成的cmd/main/BUILD如下所示：

load("@io_bazel_rules_go//go:def.bzl", "go_binary", "go_library")

go_library(
    name = "main_lib",
    srcs = ["main.go"],
    importpath = "github.com/me/myrepo/....",
    visibility = ["//visibility:private"],
    deps = [
        "//pkg/api",
        "//pkg/archive",
        ...
    ],
)

go_binary(
    name = "main",
    embed = [":main_lib"],
    visibility = ["//visibility:public"],
)

我可以通过在命令行上传递--platforms=@io_bazel_rules_go//go/toolchain:linux_arm64来为我的主机系统或我们的部署目标构建二进制文件。但是现在，我希望能够为这两个平台创建一个包含构建的tar，而不需要使用不同的CLI参数调用Bazel。

正如推荐的这里 (“您可以通过//command_ go_binary _ go_test平台上的Bazel配置转换等效地依赖于一个go_binary或go_test规则”)，我尝试使用转换来设置它。

我的transitions.bzl文件：

# build opts for development machine
def _host_transition_impl(settings, attr):
    _ignore = (settings, attr)
    return {
        "//command_line_option:platforms": "@io_bazel_rules_go//go/toolchain:linux_amd64",
        "//command_line_option:compilation_mode": "fastbuild",
    }

# build opts for deployment target
def _target_transition_impl(settings, attr):
    _ignore = (settings, attr)
    return {
        "//command_line_option:platforms": "@io_bazel_rules_go//go/toolchain:linux_arm64",
        "//command_line_option:compilation_mode": "opt",
    }

host_transition = transition(
    implementation = _host_transition_impl,
    inputs = [],
    outputs = ["//command_line_option:platforms", "//command_line_option:compilation_mode"],
)

target_transition = transition(
    implementation = _target_transition_impl,
    inputs = [],
    outputs = ["//command_line_option:platforms", "//command_line_option:compilation_mode"],
)

def _impl(ctx):
    return []

host_transitioning_rule = rule(
    implementation = _impl,
    cfg = host_transition,
    attrs = {
        "_allowlist_function_transition": attr.label(
            default = "@bazel_tools//tools/allowlists/function_transition_allowlist",
        ),
    },
)

target_transitioning_rule = rule(
    implementation = _impl,
    cfg = target_transition,
    attrs = {
        "_allowlist_function_transition": attr.label(
            default = "@bazel_tools//tools/allowlists/function_transition_allowlist",
        ),
    },
)

但是现在，我不知道如何将过渡附加到Gazelle生成的go_binary规则上。我的根构建文件：

load("@bazel_gazelle//:def.bzl", "gazelle")

load(":transitions.bzl", "host_transitioning_rule", "target_transitioning_rule")

load("@bazel_tools//tools/build_defs/pkg:pkg.bzl", "pkg_tar")

# gazelle:prefix github.com/me/mypath...
gazelle(name = "gazelle")

gazelle(
    name = "gazelle-update-repos",
    args = [
        "-from_file=go.mod",
        "-to_macro=deps.bzl%go_dependencies",
        "-prune",
        "-build_file_proto_mode=disable_global",
    ],
    command = "update-repos",
)

host_transitioning_rule(
    name = "mainHost",
    # TODO: how to attach this to //cmd/main:main
)

target_transitioning_rule(
    name = "mainTarget",
    # TODO: how to attach this to //cmd/main:main
)

pkg_tar(
    name = "release",
    srcs = [
        ":mainHost",
        ":mainTarget",
    ],
    package_dir = "lib",
)

Answer 1

只需将相关的提供者转发到其他规则即可。FilesToRunProvider和DefaultInfo通常是最重要的。您实际上是在将您的转换附加在别名上重新创建向外边缘。就像这样：

def _impl(ctx):
    providers = []
    if DefaultInfo in ctx.attr.dep:
        providers.append(ctx.attr.dep[DefaultInfo])
    if FilesToRunProvider in ctx.attr.dep:
        providers.append(ctx.attr.dep[FilesToRunProvider])
    return providers

host_transitioning_rule = rule(
    implementation = _impl,
    attrs = {
        "_allowlist_function_transition": attr.label(
            default = "@bazel_tools//tools/allowlists/function_transition_allowlist",
        ),
        "dep": attr.label(cfg = host_transition),
    },
)

然后用它就像：

host_transitioning_rule(
    name = "mainHost",
    dep = "//cmd/main:main",
)

您尝试将过渡附加到传入边缘。这会改变规则本身的配置。在这种情况下并没有真正的区别，因为规则只有一个依赖项，但是如果您想将主机配置中的一个依赖项和目标中的一个依赖项组合起来(例如)，那么您需要在单独的attrs上使用传出边缘转换。

您可以迭代所有提供程序(如examples/blob/main/rules/attributes/printer.bzl )，而不是寻找特定的提供程序，并将它们全部转发。不过，对某些供应商来说，这可能有点棘手，所以我会避免这样做。例如，如果您只是在交叉编译时盲目地转发GoLibrary，那么您将试图链接为不同架构编译的库，这是行不通的。