Added a hub repository for helm toolchains (#220)

This cleans up MODULE.bazel files.

Author: abrisco

MODULE.bazel

@@ -32,22 +32,16 @@ use_repo(
 )
 
 helm = use_extension("@rules_helm//helm:extensions.bzl", "helm")
+helm.toolchain()
+helm.host_tools()
 use_repo(
     helm,
     "helm",
-    "helm_darwin_amd64_toolchain",
-    "helm_darwin_arm64_toolchain",
-    "helm_linux_amd64_toolchain",
-    "helm_linux_arm64_toolchain",
-    "helm_windows_amd64_toolchain",
+    "helm_toolchains",
 )
 
 register_toolchains(
-    "@helm_darwin_amd64_toolchain//:toolchain",
-    "@helm_darwin_arm64_toolchain//:toolchain",
-    "@helm_linux_amd64_toolchain//:toolchain",
-    "@helm_linux_arm64_toolchain//:toolchain",
-    "@helm_windows_amd64_toolchain//:toolchain",
+    "@helm_toolchains//:all",
 )
 
 helm_test = use_extension("@rules_helm//tests:test_extensions.bzl", "helm_test", dev_dependency = True)

helm/extensions.bzl

@@ -1,11 +1,11 @@
 """Bzlmod extensions"""
 
-load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
 load(
     "//helm/private:repositories.bzl",
     "helm_host_alias_repository",
     "helm_toolchain_repository",
+    "helm_toolchain_repository_hub",
 )
 load(
     "//helm/private:versions.bzl",
@@ -15,87 +15,127 @@ load(
     "HELM_VERSIONS",
 )
 
-_HELM_TAR_BUILD_CONTENT = """\
-package(default_visibility = ["//visibility:public"])
-exports_files(glob(["**"]))
-"""
-
-def _helm_impl(ctx):
-    toolchain_config = {
-        "helm_url_templates": DEFAULT_HELM_URL_TEMPLATES,
-        "plugins": [],
-        "version": DEFAULT_HELM_VERSION,
-    }
-    for module in ctx.modules:
-        if not module.is_root:
-            # TODO support toolchain generation from non-root modules. This requires encoding all options into the repo name and adding deduplication.
-            print("Ignoring call to helm module extension in non-root module.")  # buildifier: disable=print
-            continue
-        if len(module.tags.toolchain) > 1:
-            # TODO support generating multiple toolchains. This requires encoding all options into the repo name and adding deduplication.
-            fail("Only a single call to helm.toolchain() is taken into account. Please remove the other ones.")
-        for toolchain_option in module.tags.toolchain:
-            toolchain_config["version"] = toolchain_option.version
-            toolchain_config["helm_url_templates"] = toolchain_option.helm_url_templates
-            toolchain_config["plugins"] = toolchain_option.plugins
-
-    _register_toolchains(**toolchain_config)
-
-def _register_toolchains(version, helm_url_templates, plugins):
-    if not version in HELM_VERSIONS:
-        fail("{} is not a supported version ({})".format(version, HELM_VERSIONS.keys()))
-
-    helm_version_info = HELM_VERSIONS[version]
-
-    for platform, integrity in helm_version_info.items():
-        if platform.startswith("windows"):
-            compression = "zip"
-        else:
-            compression = "tar.gz"
-
-        # The URLs for linux-i386 artifacts are actually published under
-        # a different name. The check below accounts for this.
-        # https://github.com/abrisco/rules_helm/issues/76
-        url_platform = platform
-        if url_platform == "linux-i386":
-            url_platform = "linux-386"
-
-        name = "helm_{}".format(platform.replace("-", "_"))
+def _find_modules(module_ctx):
+    root = None
+    rules_module = None
+    for mod in module_ctx.modules:
+        if mod.is_root:
+            root = mod
+        if mod.name == "rules_helm":
+            rules_module = mod
+    if root == None:
+        root = rules_module
+    if rules_module == None:
+        fail("Unable to find rules_helm module")
+
+    return root, rules_module
+
+def _helm_impl(module_ctx):
+    root_mod, rules_mod = _find_modules(module_ctx)
+
+    toolchains = root_mod.tags.toolchain
+    if not toolchains:
+        toolchains = rules_mod.tags.toolchain
+
+    host_tools = root_mod.tags.host_tools
+    if not host_tools:
+        host_tools = rules_mod.tags.host_tools
+
+    for attrs in toolchains:
+        if attrs.version not in HELM_VERSIONS:
+            fail("Helm toolchain hub `{}` was given unsupported version `{}`. Try: {}".format(
+                attrs.name,
+                attrs.version,
+                HELM_VERSIONS.keys(),
+            ))
+        available = HELM_VERSIONS[attrs.version]
+        toolchain_names = []
+        toolchain_labels = {}
+        target_compatible_with = {}
+        exec_compatible_with = {}
+
+        for platform, integrity in available.items():
+            if platform.startswith("windows"):
+                compression = "zip"
+            else:
+                compression = "tar.gz"
+
+            # The URLs for linux-i386 artifacts are actually published under
+            # a different name. The check below accounts for this.
+            # https://github.com/abrisco/rules_helm/issues/76
+            url_platform = platform
+            if url_platform == "linux-i386":
+                url_platform = "linux-386"
+
+            toolchain_repo_name = "{}__{}_{}_bin".format(attrs.name, attrs.version, platform.replace("-", "_"))
+
+            # Create the hub-specific binary repository
+            maybe(
+                helm_toolchain_repository,
+                name = toolchain_repo_name,
+                urls = [
+                    template.replace(
+                        "{version}",
+                        attrs.version,
+                    ).replace(
+                        "{platform}",
+                        url_platform,
+                    ).replace(
+                        "{compression}",
+                        compression,
+                    )
+                    for template in attrs.helm_url_templates
+                ],
+                integrity = integrity,
+                strip_prefix = url_platform,
+                plugins = attrs.plugins,
+                platform = platform,
+            )
+
+            toolchain_names.append(toolchain_repo_name)
+            toolchain_labels[toolchain_repo_name] = "@{}".format(toolchain_repo_name)
+            target_compatible_with[toolchain_repo_name] = []
+            exec_compatible_with[toolchain_repo_name] = CONSTRAINTS[platform]
+
         maybe(
-            http_archive,
-            name = name,
-            urls = [
-                template.replace(
-                    "{version}",
-                    version,
-                ).replace(
-                    "{platform}",
-                    url_platform,
-                ).replace(
-                    "{compression}",
-                    compression,
-                )
-                for template in helm_url_templates
-            ],
-            build_file_content = _HELM_TAR_BUILD_CONTENT,
-            integrity = integrity,
-            strip_prefix = url_platform,
+            helm_toolchain_repository_hub,
+            name = attrs.name,
+            toolchain_labels = toolchain_labels,
+            toolchain_names = toolchain_names,
+            exec_compatible_with = exec_compatible_with,
+            target_compatible_with = target_compatible_with,
         )
+
+    # Process host_tools tags
+    for host_tools_attrs in host_tools:
         maybe(
-            helm_toolchain_repository,
-            name = name + "_toolchain",
-            platform = platform,
-            plugins = plugins,
-            exec_compatible_with = CONSTRAINTS[platform],
+            helm_host_alias_repository,
+            name = host_tools_attrs.name,
         )
 
-    maybe(
-        helm_host_alias_repository,
-        name = "helm",
+    return module_ctx.extension_metadata(
+        reproducible = True,
     )
 
 _toolchain = tag_class(
-    doc = "Configure a helm toolchain.",
+    doc = """\
+An extension for defining a `helm_toolchain` from a download archive.
+
+An example of defining and registering toolchains:
+
+```python
+helm = use_extension("@rules_helm//helm:extensions.bzl", "helm")
+helm.toolchain(
+    name = "helm_toolchains",
+    version = "3.14.4",
+)
+use_repo(helm, "helm_toolchains")
+
+register_toolchains(
+    "@helm_toolchains//:all",
+)
+```
+""",
     attrs = {
         "helm_url_templates": attr.string_list(
             doc = (
@@ -105,6 +145,10 @@ _toolchain = tag_class(
             ),
             default = DEFAULT_HELM_URL_TEMPLATES,
         ),
+        "name": attr.string(
+            doc = "The name of the toolchain hub repository.",
+            default = "helm_toolchains",
+        ),
         "plugins": attr.string_list(
             doc = "A list of plugins to add to the generated toolchain.",
             default = [],
@@ -116,9 +160,32 @@ _toolchain = tag_class(
     },
 )
 
+_host_tools = tag_class(
+    doc = """\
+An extension for creating a host alias repository that provides a shorter name for the host platform's helm binary.
+
+An example of defining and using host tools:
+
+```python
+helm = use_extension("@rules_helm//helm:extensions.bzl", "helm")
+helm.host_tools(name = "helm")
+use_repo(helm, "helm")
+
+# Then you can use @helm//:helm in your BUILD files
+```
+""",
+    attrs = {
+        "name": attr.string(
+            doc = "The name of the host alias repository.",
+            default = "helm",
+        ),
+    },
+)
+
 helm = module_extension(
     implementation = _helm_impl,
     tag_classes = {
+        "host_tools": _host_tools,
         "toolchain": _toolchain,
     },
 )