wasm: restore focused loading canaries and pin runtime ordering

bazel/wasm/wasm.bzl

@@ -61,10 +61,21 @@ wasi_rust_binary_rule = rule(
     attrs = _wasm_attrs(wasi_rust_transition),
 )
 
-def envoy_wasm_cc_binary(name, additional_linker_inputs = [], linkopts = [], tags = [], **kwargs):
+wasm_cc_binary_rule = rule(
+    implementation = _wasm_binary_impl,
+    attrs = {
+        "binary": attr.label(mandatory = True),
+        "precompile": attr.bool(default = False),
+        # This is deliberately in target configuration to avoid compiling v8 twice.
+        "_compile_tool": attr.label(default = Label("//test/tools/wee8_compile:wee8_compile_tool"), executable = True, cfg = "target"),
+    },
+)
+
+def envoy_wasm_cc_binary(name, additional_linker_inputs = [], linkopts = [], tags = [], precompile = False, **kwargs):
+    wasm_name = "_wasm_" + name.replace(".", "_")
     api_js = Label("//source/extensions/common/wasm/ext:envoy_proxy_wasm_api_js")
     proxy_wasm_cc_binary(
-        name = name,
+        name = wasm_name,
         additional_linker_inputs = additional_linker_inputs + [
             api_js,
         ],
@@ -75,6 +86,16 @@ def envoy_wasm_cc_binary(name, additional_linker_inputs = [], linkopts = [], tag
         **kwargs
     )
 
+    wasm_kwargs = {
+        "name": name,
+        "binary": ":" + wasm_name,
+        "precompile": precompile,
+        "tags": tags + ["manual"],
+    }
+    if "visibility" in kwargs:
+        wasm_kwargs["visibility"] = kwargs["visibility"]
+    wasm_cc_binary_rule(**wasm_kwargs)
+
 def wasm_rust_binary(name, tags = [], wasi = False, precompile = False, **kwargs):
     wasm_name = "_wasm_" + name.replace(".", "_")
     kwargs.setdefault("visibility", ["//visibility:public"])

test/extensions/access_loggers/wasm/config_test.cc

@@ -72,7 +72,7 @@ class WasmAccessLogConfigTest
 };
 
 INSTANTIATE_TEST_SUITE_P(Runtimes, WasmAccessLogConfigTest,
-                         Envoy::Extensions::Common::Wasm::runtime_and_cpp_values,
+                         Envoy::Extensions::Common::Wasm::single_sandbox_runtime_and_cpp_values,
                          Envoy::Extensions::Common::Wasm::wasmTestParamsToString);
 
 TEST_P(WasmAccessLogConfigTest, CreateWasmFromEmpty) {
@@ -99,6 +99,7 @@ TEST_P(WasmAccessLogConfigTest, CreateWasmFromWASM) {
   envoy::extensions::access_loggers::wasm::v3::WasmAccessLog config;
   config.mutable_config()->mutable_vm_config()->set_runtime(
       absl::StrCat("envoy.wasm.runtime.", std::get<0>(GetParam())));
+  config.mutable_config()->mutable_vm_config()->set_allow_precompiled(true);
   std::string code;
   if (std::get<0>(GetParam()) != "null") {
     code = TestEnvironment::readFileToStringForTest(TestEnvironment::substitute(
@@ -145,6 +146,7 @@ TEST_P(WasmAccessLogConfigTest, YamlLoadFromFileWasmInvalidConfig) {
       TestEnvironment::substitute(absl::StrCat(R"EOF(
   config:
     vm_config:
+      allow_precompiled: true
       runtime: "envoy.wasm.runtime.)EOF",
                                                std::get<0>(GetParam()), R"EOF("
       configuration:
@@ -167,6 +169,7 @@ TEST_P(WasmAccessLogConfigTest, YamlLoadFromFileWasmInvalidConfig) {
       TestEnvironment::substitute(absl::StrCat(R"EOF(
   config:
     vm_config:
+      allow_precompiled: true
       runtime: "envoy.wasm.runtime.)EOF",
                                                std::get<0>(GetParam()), R"EOF("
       configuration:
@@ -197,6 +200,7 @@ TEST_P(WasmAccessLogConfigTest, YamlLoadFromRemoteWasmCreateFilter) {
   const std::string yaml = TestEnvironment::substitute(absl::StrCat(R"EOF(
   config:
     vm_config:
+      allow_precompiled: true
       runtime: "envoy.wasm.runtime.)EOF",
                                                                     std::get<0>(GetParam()), R"EOF("
       code:
@@ -251,6 +255,7 @@ TEST_P(WasmAccessLogConfigTest, FailedToGetThreadLocalPlugin) {
   const std::string yaml = TestEnvironment::substitute(absl::StrCat(R"EOF(
   config:
     vm_config:
+      allow_precompiled: true
       runtime: "envoy.wasm.runtime.)EOF",
                                                                     std::get<0>(GetParam()), R"EOF("
       configuration:

test/extensions/access_loggers/wasm/test_data/BUILD

@@ -3,6 +3,7 @@ load(
     "envoy_cc_test_library",
     "envoy_package",
 )
+load("//bazel:envoy_select.bzl", "envoy_select_wasm_v8_bool")
 load("//bazel/wasm:wasm.bzl", "envoy_wasm_cc_binary")
 
 licenses(["notice"])  # Apache 2
@@ -28,4 +29,5 @@ envoy_cc_test_library(
 envoy_wasm_cc_binary(
     name = "test_cpp.wasm",
     srcs = ["test_cpp.cc"],
+    precompile = envoy_select_wasm_v8_bool(),
 )

test/extensions/bootstrap/wasm/config_test.cc

@@ -22,6 +22,7 @@ class WasmFactoryTest : public testing::TestWithParam<std::tuple<std::string, st
   WasmFactoryTest() {
     config_.mutable_config()->mutable_vm_config()->set_runtime(
         absl::StrCat("envoy.wasm.runtime.", std::get<0>(GetParam())));
+    config_.mutable_config()->mutable_vm_config()->set_allow_precompiled(true);
     if (std::get<0>(GetParam()) != "null") {
       config_.mutable_config()->mutable_vm_config()->mutable_code()->mutable_local()->set_filename(
           TestEnvironment::substitute(
@@ -66,7 +67,7 @@ class WasmFactoryTest : public testing::TestWithParam<std::tuple<std::string, st
 };
 
 INSTANTIATE_TEST_SUITE_P(Runtimes, WasmFactoryTest,
-                         Envoy::Extensions::Common::Wasm::runtime_and_cpp_values,
+                         Envoy::Extensions::Common::Wasm::single_sandbox_runtime_and_cpp_values,
                          Envoy::Extensions::Common::Wasm::wasmTestParamsToString);
 
 TEST_P(WasmFactoryTest, CreateWasmFromWasm) {

test/extensions/bootstrap/wasm/test_data/BUILD

@@ -3,6 +3,7 @@ load(
     "envoy_cc_test_library",
     "envoy_package",
 )
+load("//bazel:envoy_select.bzl", "envoy_select_wasm_v8_bool")
 load("//bazel/wasm:wasm.bzl", "envoy_wasm_cc_binary", "wasm_rust_binary")
 
 licenses(["notice"])  # Apache 2
@@ -13,6 +14,7 @@ wasm_rust_binary(
     name = "logging_rust.wasm",
     srcs = ["logging_rust.rs"],
     wasi = True,
+    precompile = envoy_select_wasm_v8_bool(),
     deps = [
         "@proxy-wasm-rust-sdk//:proxy_wasm",
         "@proxy-wasm-rust-sdk//bazel/cargo/remote:log",
@@ -70,6 +72,7 @@ envoy_cc_test_library(
 envoy_wasm_cc_binary(
     name = "asm2wasm_cpp.wasm",
     srcs = ["asm2wasm_cpp.cc"],
+    precompile = envoy_select_wasm_v8_bool(),
 )
 
 envoy_wasm_cc_binary(
@@ -80,16 +83,19 @@ envoy_wasm_cc_binary(
 envoy_wasm_cc_binary(
     name = "emscripten_cpp.wasm",
     srcs = ["emscripten_cpp.cc"],
+    precompile = envoy_select_wasm_v8_bool(),
 )
 
 envoy_wasm_cc_binary(
     name = "http_cpp.wasm",
     srcs = ["http_cpp.cc"],
+    precompile = envoy_select_wasm_v8_bool(),
 )
 
 envoy_wasm_cc_binary(
     name = "logging_cpp.wasm",
     srcs = ["logging_cpp.cc"],
+    precompile = envoy_select_wasm_v8_bool(),
 )
 
 envoy_wasm_cc_binary(
@@ -103,20 +109,24 @@ envoy_wasm_cc_binary(
 envoy_wasm_cc_binary(
     name = "segv_cpp.wasm",
     srcs = ["segv_cpp.cc"],
+    precompile = envoy_select_wasm_v8_bool(),
 )
 
 envoy_wasm_cc_binary(
     name = "speed_cpp.wasm",
     srcs = ["speed_cpp.cc"],
+    precompile = envoy_select_wasm_v8_bool(),
     protobuf = "full",
 )
 
 envoy_wasm_cc_binary(
     name = "start_cpp.wasm",
     srcs = ["start_cpp.cc"],
+    precompile = envoy_select_wasm_v8_bool(),
 )
 
 envoy_wasm_cc_binary(
     name = "stats_cpp.wasm",
     srcs = ["stats_cpp.cc"],
+    precompile = envoy_select_wasm_v8_bool(),
 )

test/extensions/bootstrap/wasm/wasm_integration_test.cc

@@ -55,6 +55,7 @@ name: envoy.filters.http.wasm
         key_values:
           KEY: VALUE
       runtime: "envoy.wasm.runtime.{}"
+      allow_precompiled: true
       code:
         local:
           filename: {}

test/extensions/bootstrap/wasm/wasm_test.cc

@@ -49,6 +49,7 @@ class WasmTestBase {
     *plugin_config.mutable_vm_config()->mutable_runtime() =
         absl::StrCat("envoy.wasm.runtime.", runtime);
     *plugin_config.mutable_vm_config()->mutable_vm_id() = vm_id_;
+    plugin_config.mutable_vm_config()->set_allow_precompiled(true);
     plugin_config.mutable_vm_config()->mutable_configuration()->set_value(vm_configuration_);
     plugin_config.mutable_configuration()->set_value(plugin_configuration_);
     plugin_ = std::make_shared<Extensions::Common::Wasm::Plugin>(plugin_config, local_info_);
@@ -91,7 +92,7 @@ class WasmTest : public WasmTestBase,
 };
 
 INSTANTIATE_TEST_SUITE_P(Runtimes, WasmTest,
-                         Envoy::Extensions::Common::Wasm::sandbox_runtime_and_cpp_values,
+                         Envoy::Extensions::Common::Wasm::first_sandbox_runtime_and_cpp_values,
                          Envoy::Extensions::Common::Wasm::wasmTestParamsToString);
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WasmTest);
 
@@ -112,7 +113,7 @@ class WasmNullTest : public WasmTestBase,
 };
 
 INSTANTIATE_TEST_SUITE_P(Runtimes, WasmNullTest,
-                         Envoy::Extensions::Common::Wasm::runtime_and_cpp_values);
+                         Envoy::Extensions::Common::Wasm::single_sandbox_runtime_and_cpp_values);
 
 class WasmTestMatrix : public WasmTestBase,
                        public testing::TestWithParam<std::tuple<std::string, std::string>> {
@@ -132,8 +133,9 @@ class WasmTestMatrix : public WasmTestBase,
   std::string code_;
 };
 
-INSTANTIATE_TEST_SUITE_P(RuntimesAndLanguages, WasmTestMatrix,
-                         Envoy::Extensions::Common::Wasm::sandbox_runtime_and_language_values);
+INSTANTIATE_TEST_SUITE_P(
+    RuntimesAndLanguages, WasmTestMatrix,
+    Envoy::Extensions::Common::Wasm::single_sandbox_runtime_and_language_values);
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WasmTestMatrix);
 
 TEST_P(WasmTestMatrix, LoggingWithEnvVars) {

test/extensions/common/wasm/BUILD

@@ -40,6 +40,7 @@ envoy_cc_test(
         "//test/extensions/common/wasm/test_data:bad_signature_cpp.wasm",
         "//test/extensions/common/wasm/test_data:test_context_cpp.wasm",
         "//test/extensions/common/wasm/test_data:test_cpp.wasm",
+        "//test/extensions/common/wasm/test_data:test_cpp_source.wasm",
         "//test/extensions/common/wasm/test_data:test_restriction_cpp.wasm",
     ]),
     rbe_pool = "linux_x64_large",
@@ -65,6 +66,7 @@ envoy_cc_test(
         "//test/test_common:simulated_time_system_lib",
         "//test/test_common:test_runtime_lib",
         "//test/test_common:wasm_lib",
+        "@proxy-wasm-cpp-host//:headers",
     ],
 )
 
@@ -122,6 +124,15 @@ envoy_cc_test(
     ],
 )
 
+envoy_cc_test(
+    name = "wasm_runtime_test",
+    srcs = ["wasm_runtime_test.cc"],
+    tags = ["skip_on_windows"],
+    deps = [
+        ":wasm_runtime",
+    ],
+)
+
 envoy_cc_test(
     name = "context_test",
     srcs = ["context_test.cc"],

test/extensions/common/wasm/test_data/BUILD

@@ -70,11 +70,18 @@ envoy_cc_test_library(
 envoy_wasm_cc_binary(
     name = "test_cpp.wasm",
     srcs = ["test_cpp.cc"],
+    precompile = envoy_select_wasm_v8_bool(),
+)
+
+envoy_wasm_cc_binary(
+    name = "test_cpp_source.wasm",
+    srcs = ["test_cpp.cc"],
 )
 
 envoy_wasm_cc_binary(
     name = "test_context_cpp.wasm",
     srcs = ["test_context_cpp.cc"],
+    precompile = envoy_select_wasm_v8_bool(),
     deps = [
         "//source/extensions/common/wasm/ext:envoy_proxy_wasm_api_lib",
     ],
@@ -83,6 +90,7 @@ envoy_wasm_cc_binary(
 envoy_wasm_cc_binary(
     name = "test_restriction_cpp.wasm",
     srcs = ["test_restriction_cpp.cc"],
+    precompile = envoy_select_wasm_v8_bool(),
 )
 
 envoy_wasm_cc_binary(

test/extensions/common/wasm/wasm_runtime.cc

@@ -31,13 +31,16 @@ std::vector<std::string> languages(bool cpp_only) {
   return languages;
 }
 
-std::vector<std::tuple<std::string, std::string>> wasmTestMatrix(bool include_nullvm,
-                                                                 bool cpp_only) {
+std::vector<std::tuple<std::string, std::string>> wasmTestMatrix(bool include_nullvm, bool cpp_only,
+                                                                 bool single_runtime) {
   std::vector<std::tuple<std::string, std::string>> values;
   for (const auto& runtime : sandboxRuntimes()) {
     for (const auto& language : languages(cpp_only)) {
       values.push_back(std::make_tuple(runtime, language));
     }
+    if (single_runtime) {
+      break;
+    }
   }
   if (include_nullvm) {
     values.push_back(std::make_tuple("null", "cpp"));
@@ -46,9 +49,10 @@ std::vector<std::tuple<std::string, std::string>> wasmTestMatrix(bool include_nu
 }
 
 std::vector<std::tuple<std::string, std::string, bool>>
-wasmDualFilterTestMatrix(bool include_nullvm, bool cpp_only) {
+wasmDualFilterTestMatrix(bool include_nullvm, bool cpp_only, bool single_runtime) {
   std::vector<std::tuple<std::string, std::string, bool>> values;
-  for (const auto& p : Envoy::Extensions::Common::Wasm::wasmTestMatrix(include_nullvm, cpp_only)) {
+  for (const auto& p :
+       Envoy::Extensions::Common::Wasm::wasmTestMatrix(include_nullvm, cpp_only, single_runtime)) {
     values.push_back(std::make_tuple(std::get<0>(p), std::get<1>(p), true));
     values.push_back(std::make_tuple(std::get<0>(p), std::get<1>(p), false));
   }

test/extensions/common/wasm/wasm_runtime.h

@@ -9,25 +9,40 @@ namespace Extensions {
 namespace Common {
 namespace Wasm {
 
+// Sandbox runtimes compiled into this build (e.g. v8, wamr, wasmtime).
+// Ordering is load-bearing: single_sandbox_*, first_sandbox_*, and host_test_* suites
+// exercise only the first sandbox runtime.
+std::vector<std::string> sandboxRuntimes();
+
 // Testable runtime and language combinations.
-std::vector<std::tuple<std::string, std::string>> wasmTestMatrix(bool include_nullvm,
-                                                                 bool cpp_only);
+std::vector<std::tuple<std::string, std::string>> wasmTestMatrix(bool include_nullvm, bool cpp_only,
+                                                                 bool single_runtime = false);
 
 std::vector<std::tuple<std::string, std::string, bool>>
-wasmDualFilterTestMatrix(bool include_nullvm, bool cpp_only);
+wasmDualFilterTestMatrix(bool include_nullvm, bool cpp_only, bool single_runtime = false);
 
 std::vector<std::tuple<std::string, std::string, bool, Http::CodecType>>
 wasmDualFilterWithCodecsTestMatrix(bool include_nullvm, bool cpp_only,
                                    std::vector<Http::CodecType> codecs_type);
 
 inline auto runtime_and_cpp_values = testing::ValuesIn(wasmTestMatrix(true, true));
+inline auto single_sandbox_runtime_and_cpp_values =
+    testing::ValuesIn(wasmTestMatrix(true, true, true));
+inline auto first_sandbox_runtime_and_cpp_values =
+    testing::ValuesIn(wasmTestMatrix(false, true, true));
 inline auto sandbox_runtime_and_cpp_values = testing::ValuesIn(wasmTestMatrix(false, true));
 inline auto dual_filter_sandbox_runtime_and_cpp_values =
     testing::ValuesIn(wasmDualFilterTestMatrix(false, true));
+inline auto dual_filter_single_sandbox_runtime_and_cpp_values =
+    testing::ValuesIn(wasmDualFilterTestMatrix(true, true, true));
 inline auto dual_filter_with_codecs_sandbox_runtime_and_cpp_values =
     testing::ValuesIn(wasmDualFilterWithCodecsTestMatrix(
         false, true, {Envoy::Http::CodecType::HTTP1, Envoy::Http::CodecType::HTTP2}));
 inline auto runtime_and_language_values = testing::ValuesIn(wasmTestMatrix(true, false));
+inline auto host_test_runtime_and_language_values =
+    testing::ValuesIn(wasmTestMatrix(true, false, true));
+inline auto single_sandbox_runtime_and_language_values =
+    testing::ValuesIn(wasmTestMatrix(false, false, true));
 inline auto sandbox_runtime_and_language_values = testing::ValuesIn(wasmTestMatrix(false, false));
 
 std::string