Stop using bazel'http_* rules

restingbull · restingbull · commit 779dc5bb9755 · 2025-10-14T08:12:59.000-05:00
diff --git a/src/main/starlark/core/repositories/BUILD b/src/main/starlark/core/repositories/BUILD
@@ -23,6 +23,7 @@ release_archive(
         "bzlmod_impl.bzl",
         "compiler.bzl",
         "ksp.bzl",
+        "utils.bzl",
         "versions.bzl",
     ],
     src_map = {
diff --git a/src/main/starlark/core/repositories/initialize.release.bzl b/src/main/starlark/core/repositories/initialize.release.bzl
@@ -14,20 +14,17 @@
 """This file contains the Kotlin compiler repository definitions. It should not be loaded directly by client workspaces.
 """
 
-load(
-    "@bazel_tools//tools/build_defs/repo:http.bzl",
-    "http_archive",
-    "http_file",
-    "http_jar",
-)
-load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
 load(
     "//kotlin/internal:defs.bzl",
     _KSP_COMPILER_PLUGIN_REPO = "KSP_COMPILER_PLUGIN_REPO",
     _KT_COMPILER_REPO = "KT_COMPILER_REPO",
 )
 load(":compiler.bzl", "kotlin_compiler_repository")
 load(":ksp.bzl", "ksp_compiler_plugin_repository")
+load(
+    ":utils.bzl",
+    "http_repository",
+)
 load(":versions.bzl", "version", _versions = "versions")
 
 versions = _versions
@@ -64,107 +61,104 @@ def kotlin_repositories(
         strip_version = ksp_compiler_release.version,
     )
 
-    maybe(
-        http_file,
+    versions.use_repository(
+        http_repository,
         name = "com_github_pinterest_ktlint",
-        sha256 = versions.PINTEREST_KTLINT.sha256,
-        urls = [url.format(version = versions.PINTEREST_KTLINT.version) for url in versions.PINTEREST_KTLINT.url_templates],
+        version = versions.PINTEREST_KTLINT,
+        type = "file",
         executable = True,
     )
 
-    maybe(
-        http_jar,
+    versions.use_repository(
+        http_repository,
         name = "kotlinx_serialization_core_jvm",
-        sha256 = versions.KOTLINX_SERIALIZATION_CORE_JVM.sha256,
-        urls = [url.format(version = versions.KOTLINX_SERIALIZATION_CORE_JVM.version) for url in versions.KOTLINX_SERIALIZATION_CORE_JVM.url_templates],
+        version = versions.KOTLINX_SERIALIZATION_CORE_JVM,
+        type = "jar",
     )
 
-    maybe(
-        http_jar,
+    versions.use_repository(
+        http_repository,
         name = "kotlinx_serialization_json",
-        sha256 = versions.KOTLINX_SERIALIZATION_JSON.sha256,
-        urls = [url.format(version = versions.KOTLINX_SERIALIZATION_JSON.version) for url in versions.KOTLINX_SERIALIZATION_JSON.url_templates],
+        version = versions.KOTLINX_SERIALIZATION_JSON,
+        type = "jar",
     )
 
-    maybe(
-        http_jar,
+    versions.use_repository(
+        http_repository,
         name = "kotlinx_serialization_json_jvm",
-        sha256 = versions.KOTLINX_SERIALIZATION_JSON_JVM.sha256,
-        urls = [url.format(version = versions.KOTLINX_SERIALIZATION_JSON_JVM.version) for url in versions.KOTLINX_SERIALIZATION_JSON_JVM.url_templates],
+        version = versions.KOTLINX_SERIALIZATION_JSON_JVM,
+        type = "jar",
     )
 
-    maybe(
-        http_jar,
+    versions.use_repository(
+        http_repository,
         name = "kotlin_build_tools_impl",
-        sha256 = versions.KOTLIN_BUILD_TOOLS_IMPL.sha256,
-        urls = [url.format(version = versions.KOTLIN_BUILD_TOOLS_IMPL.version) for url in versions.KOTLIN_BUILD_TOOLS_IMPL.url_templates],
+        version = versions.KOTLIN_BUILD_TOOLS_IMPL,
+        type = "jar",
     )
 
     if is_bzlmod:
         return
 
-    maybe(
-        http_archive,
+    versions.use_repository(
+        http_repository,
         name = "py_absl",
-        sha256 = "8a3d0830e4eb4f66c4fa907c06edf6ce1c719ced811a12e26d9d3162f8471758",
-        urls = [
-            "https://github.com/abseil/abseil-py/archive/refs/tags/v2.1.0.tar.gz",
-        ],
-        strip_prefix = "abseil-py-2.1.0",
+        type = "archive",
+        version = versions.PY_ABSL,
     )
 
-    maybe(
-        http_archive,
-        name = "rules_cc",
-        urls = ["https://github.com/bazelbuild/rules_cc/releases/download/0.0.16/rules_cc-0.0.16.tar.gz"],
-        sha256 = "bbf1ae2f83305b7053b11e4467d317a7ba3517a12cef608543c1b1c5bf48a4df",
-        strip_prefix = "rules_cc-0.0.16",
+    versions.use_repository(
+        http_repository,
+        name = "py_absl",
+        type = "archive",
+        version = versions.PY_ABSL,
     )
 
-    maybe(
-        http_archive,
+    versions.use_repository(
+        http_repository,
+        name = "rules_cc",
+        type = "archive",
+        version = versions.RULES_CC,
+    )
+    versions.use_repository(
+        http_repository,
         name = "rules_license",
-        sha256 = versions.RULES_LICENSE.sha256,
-        urls = [url.format(version = versions.RULES_LICENSE.version) for url in versions.RULES_LICENSE.url_templates],
+        type = "archive",
+        version = versions.RULES_LICENSE,
     )
-
-    maybe(
-        http_archive,
+    versions.use_repository(
+        http_repository,
         name = "rules_android",
-        sha256 = versions.RULES_ANDROID.sha256,
-        strip_prefix = versions.RULES_ANDROID.strip_prefix_template.format(version = versions.RULES_ANDROID.version),
-        urls = [url.format(version = versions.RULES_ANDROID.version) for url in versions.RULES_ANDROID.url_templates],
+        type = "archive",
+        version = versions.RULES_ANDROID,
     )
 
-    maybe(
-        http_archive,
+    versions.use_repository(
+        http_repository,
         name = "rules_java",
-        sha256 = versions.RULES_JAVA.sha256,
-        urls = [url.format(version = versions.RULES_JAVA.version) for url in versions.RULES_JAVA.url_templates],
+        type = "archive",
+        version = versions.RULES_JAVA,
     )
 
     # See note in versions.bzl before updating bazel_skylib
-    maybe(
-        http_archive,
+    versions.use_repository(
+        http_repository,
         name = "bazel_skylib",
-        sha256 = versions.BAZEL_SKYLIB.sha256,
-        urls = [url.format(version = versions.BAZEL_SKYLIB.version) for url in versions.BAZEL_SKYLIB.url_templates],
+        type = "archive",
+        version = versions.BAZEL_SKYLIB,
     )
 
-    maybe(
-        http_archive,
+    versions.use_repository(
+        http_repository,
         name = "com_google_protobuf",
-        sha256 = versions.COM_GOOGLE_PROTOBUF.sha256,
-        strip_prefix = versions.COM_GOOGLE_PROTOBUF.strip_prefix_template.format(version = versions.COM_GOOGLE_PROTOBUF.version),
-        urls = [url.format(version = versions.COM_GOOGLE_PROTOBUF.version) for url in versions.COM_GOOGLE_PROTOBUF.url_templates],
+        type = "archive",
+        version = versions.COM_GOOGLE_PROTOBUF,
     )
-
-    maybe(
-        http_archive,
+    versions.use_repository(
+        http_repository,
         name = "rules_proto",
-        sha256 = versions.RULES_PROTO.sha256,
-        strip_prefix = versions.RULES_PROTO.strip_prefix_template.format(version = versions.RULES_PROTO.version),
-        urls = [url.format(version = versions.RULES_PROTO.version) for url in versions.RULES_PROTO.url_templates],
+        type = "archive",
+        version = versions.RULES_PROTO,
     )
 
 def kotlinc_version(release, sha256):
diff --git a/src/main/starlark/core/repositories/utils.bzl b/src/main/starlark/core/repositories/utils.bzl
@@ -0,0 +1,136 @@
+"""Local replacement for @bazel_tools//tools/build_defs/repo
+
+Those tools have been deprecated in favor of language specific implementations. Given the current state of
+the documentation, it's easier to re-implement here.
+"""
+
+def maybe(repo_rule, name, **kwargs):
+    """Utility function for only adding a repository if it's not already present.
+
+    This is to implement safe repositories.bzl macro documented in
+    https://bazel.build/rules/deploying#dependencies.
+
+    Args:
+        repo_rule: repository rule function.
+        name: name of the repository to create.
+        **kwargs: remaining arguments that are passed to the repo_rule function.
+
+    Returns:
+        Nothing, defines the repository when needed as a side-effect.
+    """
+    if not native.existing_rule(name):
+        repo_rule(name = name, **kwargs)
+
+_HTTP_FILE_BUILD = """\
+package(default_visibility = ["//visibility:public"])
+
+filegroup(
+    name = "file",
+    srcs = glob(["{file_name}"]),
+)
+"""
+
+_HTTP_JAR_BUILD = """\
+load("@rules_java//java:java_import.bzl", "java_import")
+%s
+java_import(
+  name = "jar",
+  jars = [":file"],
+)
+""" % _HTTP_FILE_BUILD
+
+_HTTP_ARCHIVE_BUILD = """\
+package(default_visibility = ["//visibility:public"])
+
+filegroup(
+  name = "files",
+  srcs = glob(["**/*", "*"]),
+)
+"""
+
+def _resolve_type(type, r_ctx):
+    if type == "archive":
+        def download_and_extract(*args, **kwargs):
+            return r_ctx.download_and_extract(
+                strip_prefix = r_ctx.attr.strip_prefix,
+                *args,
+                **kwargs
+            )
+
+        return (_HTTP_ARCHIVE_BUILD, r_ctx.attr.path or "", download_and_extract)
+
+    if type == "jar":
+        template = _HTTP_JAR_BUILD
+        path = "%s/%s" % (type, r_ctx.attr.path or "downloaded.jar")
+    else:
+        template = _HTTP_FILE_BUILD
+        path = "%s/%s" % (type, r_ctx.attr.path or "downloaded")
+
+    def download(*args, **kwargs):
+        if r_ctx.attr.executable:
+            kwargs["executable"] = r_ctx.attr.executable
+        return r_ctx.download(*args, **kwargs)
+
+    return (template, path, download)
+
+def _http_repository(r_ctx):
+    (default_template, path, download) = _resolve_type(r_ctx.attr.type, r_ctx)
+    download_info = download(
+        r_ctx.attr.urls,
+        output = path,
+        sha256 = r_ctx.attr.sha256,
+        canonical_id = " ".join(r_ctx.attr.urls) + r_ctx.attr.sha256,
+    )
+
+    def write_if_absent(file, contents):
+        file_path = r_ctx.path(path).dirname.get_child(file)
+        if file_path.exists:
+            return
+        r_ctx.file(file_path, contents)
+
+    write_if_absent("WORKSPACE", "workspace(name = \"{name}\")".format(name = r_ctx.name))
+    write_if_absent("BUILD", default_template.format(file_name = r_ctx.path(path).basename))
+
+    return r_ctx.repo_metadata(
+        reproducible = r_ctx.attr.sha256 != "",
+        attrs_for_reproducibility = {"integrity": download_info.integrity} if r_ctx.attr.sha256 == "" else {},
+    ) if hasattr(r_ctx, "repo_metadata") else {
+        "name": r_ctx.attr.name,
+        "type": r_ctx.attr.type,
+        "urls": r_ctx.attr.urls,
+        "sha256": download_info.sha256,
+    }
+
+http_repository = repository_rule(
+    implementation = _http_repository,
+    attrs = {
+        "type": attr.string(
+            doc = "Type of remote dependency: file, archive, jar",
+            values = ["file", "archive", "jar"],
+            mandatory = True,
+        ),
+        "path": attr.string(
+            doc = "Path in the repository to place the file or uncompress the archive.",
+        ),
+        "executable": attr.bool(
+            doc = "Whether the file will be executable. Only applies to type=file.",
+            default = False,
+        ),
+        "strip_prefix": attr.string(doc = "Prefix to remove. Only applies to type=archive."),
+        "build_file_contents": attr.string(
+            doc = "Build file contents.",
+        ),
+        "sha256": attr.string(
+            doc = """The expected SHA-256 of the file downloaded.
+
+        This must match the SHA-256 of the file downloaded. _It is a security risk
+        to omit the SHA-256 as remote files can change._ At best omitting this
+        field will make your build non-hermetic. It is optional to make development
+        easier but should be set before shipping.""",
+        ),
+        "urls": attr.string_list(
+            doc = "List of urls to download from.",
+            mandatory = True,
+        ),
+    },
+)
diff --git a/src/main/starlark/core/repositories/versions.bzl b/src/main/starlark/core/repositories/versions.bzl
@@ -10,14 +10,14 @@ version = provider(
     },
 )
 
-def _use_repository(name, version, rule, **kwargs):
-    http_archive_arguments = dict(kwargs)
-    http_archive_arguments["sha256"] = version.sha256
-    http_archive_arguments["urls"] = [u.format(version = version.version) for u in version.url_templates]
+def _use_repository(rule, name, version, **kwargs):
+    rule_arguments = dict(kwargs)
+    rule_arguments["sha256"] = version.sha256
+    rule_arguments["urls"] = [u.format(version = version.version) for u in version.url_templates]
     if (hasattr(version, "strip_prefix_template")):
-        http_archive_arguments["strip_prefix"] = version.strip_prefix_template.format(version = version.version)
+        rule_arguments["strip_prefix"] = version.strip_prefix_template.format(version = version.version)
 
-    maybe(rule, name = name, **http_archive_arguments)
+    maybe(rule, name = name, **rule_arguments)
 
 versions = struct(
     # IMPORTANT! rules_kotlin does not use the bazel_skylib unittest in production
@@ -138,5 +138,19 @@ versions = struct(
         ],
         sha256 = "8769e5647557e3700919c32d508f5c5dad53c5d8234cd10846354fbcff14aa24",
     ),
+    PY_ABSL = version(
+        version = "2.1.0",
+        sha256 = "8a3d0830e4eb4f66c4fa907c06edf6ce1c719ced811a12e26d9d3162f8471758",
+        url_templates = [
+            "https://github.com/abseil/abseil-py/archive/refs/tags/v{version}.tar.gz",
+        ],
+        strip_prefix_template = "abseil-py-{version}",
+    ),
+    RULES_CC = version(
+        version = "0.0.16",
+        url_templates = ["https://github.com/bazelbuild/rules_cc/releases/download/{version}/rules_cc-{version}.tar.gz"],
+        sha256 = "bbf1ae2f83305b7053b11e4467d317a7ba3517a12cef608543c1b1c5bf48a4df",
+        strip_prefix_template = "rules_cc-{version}",
+    ),
     use_repository = _use_repository,
 )
diff --git a/src/main/starlark/release_archive/repository.bzl b/src/main/starlark/release_archive/repository.bzl
@@ -1,5 +1,4 @@
-load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
-load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
+load("//src/main/starlark/core/repositories:utils.bzl", "http_repository", "maybe")
 
 versions = struct(
     RULES_KOTLIN = struct(
@@ -189,7 +188,8 @@ def archive_repository(
     source_repository_name = source_repository_name or ("%s_head" % name)
     if remote_source_archive:
         maybe(
-            http_archive,
+            http_repository,
+            type = "archive",
             name = source_repository_name,
             sha256 = remote_source_archive.sha256,
             strip_prefix = remote_source_archive.prefix,
