Enable toolchain config generation on Windows (bazelbuild#873)

* WIP

- some basic content validation tests added and passing
- verify output base contains some expected content

Co-authored-by: Sunjay Bhatia <[email protected]>
Co-authored-by: William A Rowe Jr <[email protected]>
Signed-off-by: Sunjay Bhatia <[email protected]>
Signed-off-by: William A Rowe Jr <[email protected]>

* Experiment with bazel CI/buildkit to see if it can pull docker images

Co-authored-by: William A Rowe Jr <[email protected]>

* Refactoring given feedback and to fix tests on Linux

* Attempt to exclude Windows tests in CI

* More refactors to clean up differences in OS families

* Add TODOs for Windows tests

* Change defaults for exec_compatible_with and target_compatible_with

Have os-specific "default" values

* Make buildifier happy with documented arguments

* Move sample cc project generation to common locatino for docker config

* Make buildifier happy

* Bring back checked in sample cc project

Co-authored-by: William A Rowe Jr <[email protected]>

Author: sunjayBhatia

.bazelci/presubmit.yml

@@ -32,6 +32,7 @@ tasks:
     - "--action_env=PATH"
     - "--test_output=errors"
     - "--verbose_failures"
+    - "--test_tag_filters=-windows"
   rbe_exec_properties:
     # Run tests on RBE. These tests run on platforms with various execution
     # properties. the tests verify that the approriate properties are set (or not set).
@@ -46,3 +47,4 @@ tasks:
     - "--extra_execution_platforms=@rbe_default_exec_properties//config:platform,//tests/rules/exec_properties:platform_privileged_on,//tests/rules/exec_properties:platform_network_enabled,//tests/rules/exec_properties:platform_bespoke_network_enabled,//tests/rules/exec_properties:platform_overridden_network_enabled"
     - "--host_platform=@rbe_default_exec_properties//config:platform"
     - "--platforms=@rbe_default_exec_properties//config:platform"
+    - "--test_tag_filters=-windows"

.bazelrc

@@ -18,3 +18,6 @@
 build --host_force_python=PY2
 test --host_force_python=PY2
 run --host_force_python=PY2
+
+# Defaults to auto which means off for Windows, explicitly enable for sh tests
+build --enable_runfiles=yes

WORKSPACE

@@ -268,6 +268,16 @@ rbe_autoconfig(
     use_checked_in_confs = "False",
 )
 
+rbe_autoconfig(
+    name = "rbe_autoconf_generate_windows",
+    bazel_version = "3.1.0",
+    create_testdata = True,
+    digest = "sha256:776f241c2693f3f2187d998dcc98d2b339dcb80c99ef59bccefad0eea6e61284",
+    registry = "gcr.io",
+    repository = "envoy-ci/envoy-build-windows",
+    use_checked_in_confs = "False",
+)
+
 rbe_autoconfig(
     name = "rbe_autoconf_generate_no_java",
     bazel_version = _ubuntu1604_bazel,
@@ -401,6 +411,31 @@ rbe_autoconfig(
     use_checked_in_confs = "False",
 )
 
+load(
+    "//tests/rbe_repo:versions.bzl",
+    gcb_test_toolchain_config_suite_autogen_spec = "TOOLCHAIN_CONFIG_AUTOGEN_SPEC",
+)
+
+rbe_autoconfig(
+    name = "rbe_autoconf_output_base_windows",
+    bazel_version = "3.1.0",
+    create_java_configs = False,
+    create_testdata = True,
+    digest = "sha256:776f241c2693f3f2187d998dcc98d2b339dcb80c99ef59bccefad0eea6e61284",
+    export_configs = True,
+    registry = "gcr.io",
+    repository = "envoy-ci/envoy-build-windows",
+    toolchain_config_spec_name = "test_config_dir",
+    toolchain_config_suite_spec = {
+        "container_registry": "gcr.io",
+        "container_repo": "envoy-ci/envoy-build-windows",
+        "output_base": "rbe-test-output/config/rbe_autoconf_output_base_windows",
+        "repo_name": rbe_default_repo()["repo_name"],
+        "toolchain_config_suite_autogen_spec": gcb_test_toolchain_config_suite_autogen_spec,
+    },
+    use_checked_in_confs = "False",
+)
+
 rbe_autoconfig(
     name = "rbe_autoconf_output_base_no_java",
     bazel_version = _ubuntu1604_bazel,
@@ -537,11 +572,6 @@ rbe_autoconfig(
     },
 )
 
-load(
-    "//tests/rbe_repo:versions.bzl",
-    gcb_test_toolchain_config_suite_autogen_spec = "TOOLCHAIN_CONFIG_AUTOGEN_SPEC",
-)
-
 # This repo should only be used for GCB tests.
 # It relies on location of //tests/rbe_repo:blank_versions_test.bzl
 # and output_base in toolchain_config_suite_spec to match so that 1st build

rules/rbe_repo.bzl

@@ -382,10 +382,11 @@ were built and can be leveraged by all users of a container.
 
 NOTE 6: KNOWN LIMITATIONS
 
-  - This rule can only run in Linux if it needs to generate configs.
+  - This rule can only run on Linux or Windows if it needs to generate configs.
   - This rule uses Bazelisk to run Bazel inside the given container.
     The container, thus, must be able to execute the Bazelisk binary
-    (i.e., container must be capable of running linux-amd releases in
+    (i.e., Linux or Windows based container must be capable of running
+    the respective linux-amd or windows-amd releases from
     https://github.com/bazelbuild/bazelisk/releases)
   - If using export_configs, and you have multiple rbe_autoconfig targets
     pointing to the same toolchain_config_suite_spec, these rules should not
@@ -439,6 +440,7 @@ load(
     "AUTOCONF_ROOT",
     "DOCKER_PATH",
     "copy_to_test_dir",
+    "os_family",
     "print_exec_results",
     "resolve_image_name",
     "resolve_project_root",
@@ -458,15 +460,27 @@ _CONFIG_REPOS = ["local_config_cc"]
 
 _DEFAULT_TOOLCHAIN_CONFIG_SPEC_NAME = "default_toolchain_config_spec_name"
 
-_RBE_UBUNTU_EXEC_COMPAT_WITH = [
-    "@bazel_tools//platforms:x86_64",
-    "@bazel_tools//platforms:linux",
-    "@bazel_tools//tools/cpp:clang",
-]
-_RBE_UBUNTU_TARGET_COMPAT_WITH = [
-    "@bazel_tools//platforms:linux",
-    "@bazel_tools//platforms:x86_64",
-]
+_EXEC_COMPAT_WITH = {
+    "Linux": [
+        "@bazel_tools//platforms:linux",
+        "@bazel_tools//platforms:x86_64",
+        "@bazel_tools//tools/cpp:clang",
+    ],
+    "Windows": [
+        "@bazel_tools//platforms:windows",
+        "@bazel_tools//platforms:x86_64",
+    ],
+}
+_TARGET_COMPAT_WITH = {
+    "Linux": [
+        "@bazel_tools//platforms:linux",
+        "@bazel_tools//platforms:x86_64",
+    ],
+    "Windows": [
+        "@bazel_tools//platforms:windows",
+        "@bazel_tools//platforms:x86_64",
+    ],
+}
 
 def _rbe_autoconfig_impl(ctx):
     """Core implementation of _rbe_autoconfig repository rule."""
@@ -494,6 +508,15 @@ def _rbe_autoconfig_impl(ctx):
     image_name = resolve_image_name(ctx)
     docker_tool_path = None
 
+    # Resolve default constraints if none set
+    target_compatible_with = ctx.attr.target_compatible_with
+    if not target_compatible_with:
+        target_compatible_with = _TARGET_COMPAT_WITH[os_family(ctx)]
+
+    exec_compatible_with = ctx.attr.exec_compatible_with
+    if not exec_compatible_with:
+        exec_compatible_with = _EXEC_COMPAT_WITH[os_family(ctx)]
+
     # Resolve the paths to copy srcs to the container and to
     # export configs.
     mount_project_root, export_project_root, use_default_project = resolve_project_root(ctx)
@@ -565,6 +588,8 @@ def _rbe_autoconfig_impl(ctx):
             create_export_platform(
                 ctx,
                 exec_properties = ctx.attr.exec_properties,
+                exec_compatible_with = exec_compatible_with,
+                target_compatible_with = target_compatible_with,
                 image_name = resolve_rbe_original_image_name(ctx, image_name),
                 name = name,
                 toolchain_config_spec_name = toolchain_config_spec_name,
@@ -593,6 +618,8 @@ def _rbe_autoconfig_impl(ctx):
             create_external_repo_platform(
                 ctx,
                 exec_properties = ctx.attr.exec_properties,
+                exec_compatible_with = exec_compatible_with,
+                target_compatible_with = target_compatible_with,
                 image_name = resolve_rbe_original_image_name(ctx, image_name),
                 name = name,
                 use_legacy_platform_definition = ctx.attr.use_legacy_platform_definition,
@@ -606,6 +633,8 @@ def _rbe_autoconfig_impl(ctx):
         create_alias_platform(
             ctx,
             exec_properties = ctx.attr.exec_properties,
+            exec_compatible_with = exec_compatible_with,
+            target_compatible_with = target_compatible_with,
             image_name = resolve_rbe_original_image_name(ctx, image_name),
             name = name,
             toolchain_config_spec_name = toolchain_config_spec_name,
@@ -748,12 +777,10 @@ _rbe_autoconfig = repository_rule(
                    "generate the toolchain configs."),
         ),
         "exec_compatible_with": attr.string_list(
-            default = _RBE_UBUNTU_EXEC_COMPAT_WITH,
             doc = ("Optional. The list of constraints that will be added to the " +
                    "toolchain in its exec_compatible_with attribute (and to " +
                    "the platform in its constraint_values attr). For " +
-                   "example, [\"@bazel_tools//platforms:linux\"]. Default " +
-                   " is set to values for rbe-ubuntu16-04 container."),
+                   "example, [\"@bazel_tools//platforms:linux\"]."),
         ),
         "exec_properties": attr.string_dict(
             doc = (
@@ -818,11 +845,9 @@ _rbe_autoconfig = repository_rule(
             doc = ("Optional. The tag of the image to pull, e.g. latest."),
         ),
         "target_compatible_with": attr.string_list(
-            default = _RBE_UBUNTU_TARGET_COMPAT_WITH,
             doc = ("The list of constraints that will be added to the " +
                    "toolchain in its target_compatible_with attribute. For " +
-                   "example, [\"@bazel_tools//platforms:linux\"]. Default " +
-                   " is set to values for rbe-ubuntu16-04 container."),
+                   "example, [\"@bazel_tools//platforms:linux\"]."),
         ),
         "use_checked_in_confs": attr.string(
             default = CHECKED_IN_CONFS_TRY,

rules/rbe_repo/BUILD.platform_legacy.tpl

@@ -42,7 +42,7 @@ platform(
         }
         properties {
            name: "OSFamily"
-           value:  "Linux"
+           value:  "%{os_family}"
         }
         """, 
 )

rules/rbe_repo/build_gen.bzl

@@ -18,10 +18,14 @@ load(
     "CC_CONFIG_DIR",
     "JAVA_CONFIG_DIR",
     "PLATFORM_DIR",
+    "os_family",
 )
 load("//rules/exec_properties:exec_properties.bzl", "create_rbe_exec_properties_dict")
 
-_CC_TOOLCHAIN = ":cc-compiler-k8"
+_CC_TOOLCHAIN = {
+    "Linux": ":cc-compiler-k8",
+    "Windows": ":cc-compiler-x64_windows",
+}
 
 # Defining a local version of dicts.add in order not to create a dependency on bazel_skylib.
 def _merge_dicts(*dict_args):
@@ -94,7 +98,7 @@ def create_java_runtime(ctx, java_home):
         False,
     )
 
-def create_export_platform(ctx, exec_properties, image_name, name, toolchain_config_spec_name, use_legacy_platform_definition):
+def create_export_platform(ctx, exec_properties, exec_compatible_with, target_compatible_with, image_name, name, toolchain_config_spec_name, use_legacy_platform_definition):
     """Creates a BUILD file (to be exported to output_base) with the cc_toolchain and platform targets.
 
     Args:
@@ -103,6 +107,12 @@ def create_export_platform(ctx, exec_properties, image_name, name, toolchain_con
           be used when creating the platform. Will be used only when
           use_legacy_platform_definition == False. This dict must not contain
           "container-image".
+      exec_compatible_with: List of constraints to add to the produced
+          toolchain/platform targets (e.g., ["@bazel_tools//platforms:linux"] in the
+          exec_compatible_with/constraint_values attrs, respectively.
+      target_compatible_with: List of constraints to add to the produced
+          toolchain target (e.g., ["@bazel_tools//platforms:linux"]) in the
+          target_compatible_with attr.
       image_name: the name of the image.
       name: name of rbe_autoconfig repo rule.
       toolchain_config_spec_name: name of the toolchain config spec
@@ -113,10 +123,10 @@ def create_export_platform(ctx, exec_properties, image_name, name, toolchain_con
     if toolchain_config_spec_name:
         cc_toolchain_target += "/" + toolchain_config_spec_name
     cc_toolchain_target += "/bazel_" + ctx.attr.bazel_version
-    cc_toolchain_target += "/cc" + _CC_TOOLCHAIN
-    _create_platform(ctx, exec_properties, image_name, name, cc_toolchain_target, use_legacy_platform_definition)
+    cc_toolchain_target += "/cc" + _CC_TOOLCHAIN[os_family(ctx)]
+    _create_platform(ctx, exec_properties, exec_compatible_with, target_compatible_with, image_name, name, cc_toolchain_target, use_legacy_platform_definition)
 
-def create_external_repo_platform(ctx, exec_properties, image_name, name, use_legacy_platform_definition):
+def create_external_repo_platform(ctx, exec_properties, exec_compatible_with, target_compatible_with, image_name, name, use_legacy_platform_definition):
     """Creates a BUILD file (to be used with configs in the external repo) with the cc_toolchain and platform targets.
 
     Args:
@@ -125,15 +135,21 @@ def create_external_repo_platform(ctx, exec_properties, image_name, name, use_le
           be used when creating the platform. Will be used only when
           use_legacy_platform_definition == False. This dict must not contain
           "container-image".
+      exec_compatible_with: List of constraints to add to the produced
+          toolchain/platform targets (e.g., ["@bazel_tools//platforms:linux"] in the
+          exec_compatible_with/constraint_values attrs, respectively.
+      target_compatible_with: List of constraints to add to the produced
+          toolchain target (e.g., ["@bazel_tools//platforms:linux"]) in the
+          target_compatible_with attr.
       image_name: the name of the image.
       name: name of rbe_autoconfig repo rule.
       use_legacy_platform_definition: Whether to create a platform with
           remote_execution_properties (legacy) or with exec_properties.
     """
-    cc_toolchain_target = "@" + ctx.attr.name + "//" + CC_CONFIG_DIR + _CC_TOOLCHAIN
-    _create_platform(ctx, exec_properties, image_name, name, cc_toolchain_target, use_legacy_platform_definition)
+    cc_toolchain_target = "@" + ctx.attr.name + "//" + CC_CONFIG_DIR + _CC_TOOLCHAIN[os_family(ctx)]
+    _create_platform(ctx, exec_properties, exec_compatible_with, target_compatible_with, image_name, name, cc_toolchain_target, use_legacy_platform_definition)
 
-def create_alias_platform(ctx, exec_properties, image_name, name, toolchain_config_spec_name, use_legacy_platform_definition):
+def create_alias_platform(ctx, exec_properties, exec_compatible_with, target_compatible_with, image_name, name, toolchain_config_spec_name, use_legacy_platform_definition):
     """Creates a BUILD file (pointing to checked in config) with the cc_toolchain and platform targets.
 
     Args:
@@ -142,6 +158,12 @@ def create_alias_platform(ctx, exec_properties, image_name, name, toolchain_conf
           be used when creating the platform. Will be used only when
           use_legacy_platform_definition == False. This dict must not contain
           "container-image".
+      exec_compatible_with: List of constraints to add to the produced
+          toolchain/platform targets (e.g., ["@bazel_tools//platforms:linux"] in the
+          exec_compatible_with/constraint_values attrs, respectively.
+      target_compatible_with: List of constraints to add to the produced
+          toolchain target (e.g., ["@bazel_tools//platforms:linux"]) in the
+          target_compatible_with attr.
       image_name: the name of the image.
       name: name of rbe_autoconfig repo rule.
       toolchain_config_spec_name: name of the toolchain config spec.
@@ -153,24 +175,25 @@ def create_alias_platform(ctx, exec_properties, image_name, name, toolchain_conf
         bazel_version = ctx.attr.bazel_version,
         cc_dir = CC_CONFIG_DIR,
         config_output_base = ctx.attr.toolchain_config_suite_spec["output_base"],
-        target = _CC_TOOLCHAIN,
+        target = _CC_TOOLCHAIN[os_family(ctx)],
         toolchain_config_repo = ctx.attr.toolchain_config_suite_spec["repo_name"],
     ))
-    _create_platform(ctx, exec_properties, image_name, name, cc_toolchain_target, use_legacy_platform_definition)
+    _create_platform(ctx, exec_properties, exec_compatible_with, target_compatible_with, image_name, name, cc_toolchain_target, use_legacy_platform_definition)
 
 # Creates a BUILD file with the cc_toolchain and platform targets
-def _create_platform(ctx, exec_properties, image_name, name, cc_toolchain_target, use_legacy_platform_definition):
+def _create_platform(ctx, exec_properties, exec_compatible_with, target_compatible_with, image_name, name, cc_toolchain_target, use_legacy_platform_definition):
     template = ctx.path(Label("@bazel_toolchains//rules/rbe_repo:BUILD.platform_legacy.tpl")) if use_legacy_platform_definition else ctx.path(Label("@bazel_toolchains//rules/rbe_repo:BUILD.platform.tpl"))
     exec_compatible_with = ("\"" +
-                            ("\",\n        \"").join(ctx.attr.exec_compatible_with) +
+                            ("\",\n        \"").join(exec_compatible_with) +
                             "\",")
     target_compatible_with = ("\"" +
-                              ("\",\n        \"").join(ctx.attr.target_compatible_with) +
+                              ("\",\n        \"").join(target_compatible_with) +
                               "\",")
 
+    os = os_family(ctx)
     platform_exec_properties = create_rbe_exec_properties_dict(
         container_image = "docker://%s" % image_name,
-        os_family = "Linux",
+        os_family = os,
     )
     platform_exec_properties = _merge_dicts(platform_exec_properties, exec_properties)
 
@@ -181,6 +204,7 @@ def _create_platform(ctx, exec_properties, image_name, name, cc_toolchain_target
             "%{cc_toolchain}": cc_toolchain_target,
             "%{exec_compatible_with}": exec_compatible_with,
             "%{image_name}": image_name,
+            "%{os_family}": os,
             "%{platform_exec_properties}": "%s" % platform_exec_properties,
             "%{target_compatible_with}": target_compatible_with,
         },