Register toolchains for all versions of helm (#246)

This change registers all versions of helm known to `rules_helm` and
adds `--@rules_helm//helm/settings:version` to control which version is
used.

Author: abrisco

MODULE.bazel

@@ -34,7 +34,6 @@ use_repo(
 )
 
 helm = use_extension("@rules_helm//helm:extensions.bzl", "helm")
-helm.toolchain()
 helm.host_tools()
 use_repo(
     helm,

helm/extensions.bzl

@@ -1,6 +1,5 @@
 """Bzlmod extensions"""
 
-load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
 load(
     "//helm/private:repositories.bzl",
     "helm_host_alias_repository",
@@ -33,27 +32,17 @@ def _find_modules(module_ctx):
 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 = {}
+    toolchain_names = []
+    toolchain_labels = {}
+    target_compatible_with = {}
+    exec_compatible_with = {}
+    target_settings = {}
 
+    for version, available in HELM_VERSIONS.items():
         for platform, integrity in available.items():
             if platform.startswith("windows"):
                 compression = "zip"
@@ -67,99 +56,53 @@ def _helm_impl(module_ctx):
             if url_platform == "linux-i386":
                 url_platform = "linux-386"
 
-            toolchain_repo_name = "{}__{}_{}_bin".format(attrs.name, attrs.version, platform.replace("-", "_"))
+            toolchain_repo_name = "helm_toolchains__{}_{}_bin".format(version, platform.replace("-", "_"))
 
-            # Create the hub-specific binary repository
-            maybe(
-                helm_toolchain_repository,
+            helm_toolchain_repository(
                 name = toolchain_repo_name,
                 urls = [
                     template.replace(
                         "{version}",
-                        attrs.version,
+                        version,
                     ).replace(
                         "{platform}",
                         url_platform,
                     ).replace(
                         "{compression}",
                         compression,
                     )
-                    for template in attrs.helm_url_templates
+                    for template in DEFAULT_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]
+            target_settings[toolchain_repo_name] = ["@rules_helm//helm/settings:version_{}".format(version)]
+
+    helm_toolchain_repository_hub(
+        name = "helm_toolchains",
+        toolchain_labels = toolchain_labels,
+        toolchain_names = toolchain_names,
+        exec_compatible_with = exec_compatible_with,
+        target_compatible_with = target_compatible_with,
+        target_settings = target_settings,
+    )
 
-        maybe(
-            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_host_alias_repository,
+        helm_host_alias_repository(
             name = host_tools_attrs.name,
+            toolchain_repo_prefix = "helm_toolchains__{}".format(host_tools_attrs.version),
         )
 
     return module_ctx.extension_metadata(
         reproducible = True,
     )
 
-_toolchain = tag_class(
-    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 = (
-                "A url template used to download helm. The template can contain the following " +
-                "format strings `{platform}` for the helm platform, `{version}` for the helm " +
-                "version, and `{compression}` for the archive type containing the helm binary."
-            ),
-            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 = [],
-        ),
-        "version": attr.string(
-            doc = "The version of helm to download for the toolchain.",
-            default = DEFAULT_HELM_VERSION,
-        ),
-    },
-)
-
 _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.
@@ -179,13 +122,16 @@ use_repo(helm, "helm")
             doc = "The name of the host alias repository.",
             default = "helm",
         ),
+        "version": attr.string(
+            doc = "The version of helm to use for host tools.",
+            default = DEFAULT_HELM_VERSION,
+        ),
     },
 )
 
 helm = module_extension(
     implementation = _helm_impl,
     tag_classes = {
         "host_tools": _host_tools,
-        "toolchain": _toolchain,
     },
 )

helm/private/repositories.bzl

@@ -163,8 +163,8 @@ exports_files(["helm{ext}"])
         ext = ext,
     ))
 
-    repository_ctx.symlink("../{name}_{platform}/helm{ext}".format(
-        name = repository_ctx.attr.name,
+    repository_ctx.symlink("../{prefix}_{platform}_bin/helm{ext}".format(
+        prefix = repository_ctx.attr.toolchain_repo_prefix,
         platform = _platform(repository_ctx),
         ext = ext,
     ), "helm{ext}".format(ext = ext))
@@ -174,13 +174,20 @@ helm_host_alias_repository = repository_rule(
     doc = """Creates a repository with a shorter name meant for the host platform, which contains
     a BUILD.bazel file that exports symlinks to the host platform's binaries
     """,
+    attrs = {
+        "toolchain_repo_prefix": attr.string(
+            doc = "The name prefix for binary repos to symlink to. The host alias constructs the full repo name as {prefix}_{platform}_bin.",
+            mandatory = True,
+        ),
+    },
 )
 
 _BUILD_FILE_FOR_TOOLCHAIN_HUB_TEMPLATE = """
 toolchain(
     name = "{name}",
     exec_compatible_with = {exec_constraint_sets_serialized},
     target_compatible_with = {target_constraint_sets_serialized},
+    target_settings = {target_settings_serialized},
     toolchain = "{toolchain}",
     toolchain_type = "@rules_helm//helm:toolchain_type",
     visibility = ["//visibility:public"],
@@ -191,12 +198,14 @@ def _BUILD_for_toolchain_hub(
         toolchain_names,
         toolchain_labels,
         target_compatible_with,
-        exec_compatible_with):
+        exec_compatible_with,
+        target_settings):
     return "\n".join([_BUILD_FILE_FOR_TOOLCHAIN_HUB_TEMPLATE.format(
         name = toolchain_name,
         exec_constraint_sets_serialized = json.encode(exec_compatible_with.get(toolchain_name, [])),
         target_constraint_sets_serialized = json.encode(target_compatible_with.get(toolchain_name, [])),
         toolchain = toolchain_labels[toolchain_name],
+        target_settings_serialized = repr(target_settings.get(toolchain_name, None)),
     ) for toolchain_name in toolchain_names])
 
 def _helm_toolchain_repository_hub_impl(repository_ctx):
@@ -209,6 +218,7 @@ def _helm_toolchain_repository_hub_impl(repository_ctx):
         toolchain_labels = repository_ctx.attr.toolchain_labels,
         target_compatible_with = repository_ctx.attr.target_compatible_with,
         exec_compatible_with = repository_ctx.attr.exec_compatible_with,
+        target_settings = repository_ctx.attr.target_settings,
     ))
 
 helm_toolchain_repository_hub = repository_rule(
@@ -226,6 +236,10 @@ helm_toolchain_repository_hub = repository_rule(
             doc = "A list of constraints for the target platform for this toolchain, keyed by toolchain name.",
             mandatory = True,
         ),
+        "target_settings": attr.string_list_dict(
+            doc = "A list of target settings for this toolchain, keyed by toolchain name.",
+            mandatory = True,
+        ),
         "toolchain_labels": attr.string_dict(
             doc = "The name of the toolchain implementation target, keyed by toolchain name.",
             mandatory = True,

helm/settings/BUILD.bazel

@@ -2,6 +2,7 @@ load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
 load(
     ":settings.bzl",
     "lint_default_strict",
+    "version",
 )
 
 package(default_visibility = ["//visibility:public"])
@@ -15,3 +16,5 @@ bzl_library(
 )
 
 lint_default_strict()
+
+version()

helm/settings/settings.bzl

@@ -6,7 +6,9 @@ Definitions for all `@rules_helm//helm` settings
 load(
     "@bazel_skylib//rules:common_settings.bzl",
     "bool_flag",
+    "string_flag",
 )
+load("//helm/private:versions.bzl", "DEFAULT_HELM_VERSION", "HELM_VERSIONS")
 
 def lint_default_strict():
     """A flag to control whether or not `helm_lint_*` rules default `-strict` to `True`
@@ -15,3 +17,17 @@ def lint_default_strict():
         name = "lint_default_strict",
         build_setting_default = True,
     )
+
+def version(name = "version"):
+    """The target version of helm"""
+    string_flag(
+        name = name,
+        values = HELM_VERSIONS.keys(),
+        build_setting_default = DEFAULT_HELM_VERSION,
+    )
+
+    for ver in HELM_VERSIONS.keys():
+        native.config_setting(
+            name = "{}_{}".format(name, ver),
+            flag_values = {str(Label("//helm/settings:{}".format(name))): ver},
+        )