Add tests for secondary canary test

Signed-off-by: Ingwon Song <[email protected]>

Author: ingwonsong

WORKSPACE

@@ -7,3 +7,11 @@ proxy_wasm_cpp_host_repositories()
 load("@proxy_wasm_cpp_host//bazel:dependencies.bzl", "proxy_wasm_cpp_host_dependencies")
 
 proxy_wasm_cpp_host_dependencies()
+
+load("@proxy_wasm_cpp_sdk//bazel/dep:deps.bzl", "wasm_dependencies")
+
+wasm_dependencies()
+
+load("@proxy_wasm_cpp_sdk//bazel/dep:deps_extra.bzl", "wasm_dependencies_extra")
+
+wasm_dependencies_extra()

include/proxy-wasm/context.h

@@ -315,7 +315,11 @@ class ContextBase : public RootInterface,
   }
 
   // Properties
-  WasmResult getProperty(std::string_view /* path */, std::string * /* result */) override {
+  WasmResult getProperty(std::string_view path, std::string *result) override {
+    if (path == "plugin_root_id") {
+      *result = root_id_;
+      return WasmResult::Ok;
+    }
     return unimplemented();
   }
   WasmResult setProperty(std::string_view /* key */,

src/wasm.cc

@@ -478,7 +478,6 @@ std::shared_ptr<WasmHandleBase> createWasm(const std::string &vm_key, const std:
                                            const WasmHandleCloneFactory &clone_factory,
                                            bool allow_precompiled) {
   std::shared_ptr<WasmHandleBase> wasm_handle;
-  bool is_new_wasm = false;
   {
     std::lock_guard<std::mutex> guard(base_wasms_mutex);
     if (base_wasms == nullptr) {
@@ -492,25 +491,25 @@ std::shared_ptr<WasmHandleBase> createWasm(const std::string &vm_key, const std:
       }
     }
     if (!wasm_handle) {
+      // If no cached base_wasm, creates a new base_wasm, loads the code and initializes it.
       wasm_handle = factory(vm_key);
       if (!wasm_handle) {
         return nullptr;
       }
-      is_new_wasm = true;
+      if (!wasm_handle->wasm()->load(code, allow_precompiled)) {
+        wasm_handle->wasm()->fail(FailState::UnableToInitializeCode, "Failed to load Wasm code");
+        return nullptr;
+      }
+      if (!wasm_handle->wasm()->initialize()) {
+        wasm_handle->wasm()->fail(FailState::UnableToInitializeCode,
+                                  "Failed to initialize Wasm code");
+        return nullptr;
+      }
       (*base_wasms)[vm_key] = wasm_handle;
     }
   }
-  if (is_new_wasm) {
-    if (!wasm_handle->wasm()->load(code, allow_precompiled)) {
-      wasm_handle->wasm()->fail(FailState::UnableToInitializeCode, "Failed to load Wasm code");
-      return nullptr;
-    }
-    if (!wasm_handle->wasm()->initialize()) {
-      wasm_handle->wasm()->fail(FailState::UnableToInitializeCode,
-                                "Failed to initialize Wasm code");
-      return nullptr;
-    }
-  }
+
+  // Either creating new one or reusing the existing one, apply canary for each plugin.
   if (!canary(wasm_handle, plugin, clone_factory)) {
     return nullptr;
   }

test/BUILD

@@ -91,6 +91,7 @@ cc_test(
     srcs = ["wasm_test.cc"],
     data = [
         "//test/test_data:abi_export.wasm",
+        "//test/test_data:configure_check.wasm",
     ],
     linkstatic = 1,
     deps = [

test/test_data/BUILD

@@ -1,4 +1,5 @@
 load("@proxy_wasm_cpp_host//bazel:wasm.bzl", "wasm_rust_binary")
+load("@proxy_wasm_cpp_sdk//bazel/wasm:wasm.bzl", "wasm_cc_binary")
 
 licenses(["notice"])  # Apache 2
 
@@ -59,3 +60,11 @@ wasm_rust_binary(
     srcs = ["random.rs"],
     wasi = True,
 )
+
+wasm_cc_binary(
+    name = "configure_check.wasm",
+    srcs = ["configure_check.cc"],
+    deps = [
+        "@proxy_wasm_cpp_sdk//:proxy_wasm_intrinsics",
+    ],
+)

test/test_data/configure_check.cc

@@ -0,0 +1,53 @@
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <string>
+#include <string_view>
+#include <unordered_map>
+
+#include "proxy_wasm_intrinsics.h"
+
+class TestRootContext1 : public RootContext {
+public:
+  explicit TestRootContext1(uint32_t id, std::string_view root_id) : RootContext(id, root_id) {}
+  bool onConfigure(size_t s) override {
+    // LOG_TRACE("onConfigure in TestRootContext1");
+    return true;
+  }
+};
+
+class TestContext1 : public Context {
+public:
+  explicit TestContext1(uint32_t id, RootContext *root) : Context(id, root) {}
+};
+
+class TestRootContext2 : public RootContext {
+public:
+  explicit TestRootContext2(uint32_t id, std::string_view root_id) : RootContext(id, root_id) {}
+  bool onConfigure(size_t s) override {
+    // LOG_TRACE("onConfigure in TestRootContext2");
+    return true;
+  }
+};
+
+class TestContext2 : public Context {
+public:
+  explicit TestContext2(uint32_t id, RootContext *root) : Context(id, root) {}
+};
+
+static RegisterContextFactory register_TestContext1(CONTEXT_FACTORY(TestContext1),
+                                                    ROOT_FACTORY(TestRootContext1), "root_id_1");
+
+static RegisterContextFactory register_TestContext2(CONTEXT_FACTORY(TestContext2),
+                                                    ROOT_FACTORY(TestRootContext2), "root_id_2");

test/wasm_test.cc

@@ -113,4 +113,77 @@ TEST_P(TestVm, GetOrCreateThreadLocalWasmFailCallbacks) {
   ASSERT_NE(thread_local_plugin3->wasm(), thread_local_plugin2->wasm());
 }
 
+// Tests the canary is always applied when making a call `createWasm`
+TEST_P(TestVm, AlwaysApplyCanaryForDifferentRootID) {
+  // Use different root_id, but the others are the same
+  const auto *const root_id_1 = "root_id_1";
+  const auto *const root_id_2 = "root_id_2";
+  const auto *const plugin_name = "plugin_name";
+  const auto *const vm_id = "vm_id";
+  const auto *const vm_config = "vm_config";
+  const auto *const plugin_config = "plugin_config";
+  const auto *const vm_key = "vm_key";
+  const auto *const plugin_key = "plugin_key";
+  const auto fail_open = false;
+
+  // Define callbacks.
+  WasmHandleFactory wasm_handle_factory =
+      [this, vm_id, vm_config](std::string_view vm_key) -> std::shared_ptr<WasmHandleBase> {
+    auto base_wasm = std::make_shared<WasmBase>(newVm(), vm_id, vm_config, vm_key,
+                                                std::unordered_map<std::string, std::string>{},
+                                                AllowedCapabilitiesMap{});
+    return std::make_shared<WasmHandleBase>(base_wasm);
+  };
+
+  WasmHandleCloneFactory wasm_handle_clone_factory =
+      [this](const std::shared_ptr<WasmHandleBase> &base_wasm_handle)
+      -> std::shared_ptr<WasmHandleBase> {
+    auto wasm = std::make_shared<WasmBase>(base_wasm_handle,
+                                           [this]() -> std::unique_ptr<WasmVm> { return newVm(); });
+    return std::make_shared<WasmHandleBase>(wasm);
+  };
+
+  auto canary_count = 0;
+  WasmHandleCloneFactory wasm_handle_clone_factory_for_canary =
+      [&canary_count, this](const std::shared_ptr<WasmHandleBase> &base_wasm_handle)
+      -> std::shared_ptr<WasmHandleBase> {
+    auto wasm = std::make_shared<WasmBase>(base_wasm_handle,
+                                           [this]() -> std::unique_ptr<WasmVm> { return newVm(); });
+    canary_count++;
+    return std::make_shared<WasmHandleBase>(wasm);
+  };
+
+  PluginHandleFactory plugin_handle_factory =
+      [](const std::shared_ptr<WasmHandleBase> &base_wasm,
+         const std::shared_ptr<PluginBase> &plugin) -> std::shared_ptr<PluginHandleBase> {
+    return std::make_shared<PluginHandleBase>(base_wasm, plugin);
+  };
+
+  // Read the minimal loadable binary.
+  auto source = readTestWasmFile("configure_check.wasm");
+
+  // Create a first plugin.
+  const auto plugin_1 = std::make_shared<PluginBase>(plugin_name, root_id_1, vm_id, engine_,
+                                                     plugin_config, fail_open, plugin_key);
+  // Create base Wasm via createWasm.
+  auto base_wasm_handle_1 = createWasm(vm_key, source, plugin_1, wasm_handle_factory,
+                                       wasm_handle_clone_factory_for_canary, false);
+  ASSERT_TRUE(base_wasm_handle_1 && base_wasm_handle_1->wasm());
+
+  // Create a first plugin.
+  const auto plugin_2 = std::make_shared<PluginBase>(plugin_name, root_id_2, vm_id, engine_,
+                                                     plugin_config, fail_open, plugin_key);
+  // Create base Wasm via createWasm.
+  auto base_wasm_handle_2 = createWasm(vm_key, source, plugin_2, wasm_handle_factory,
+                                       wasm_handle_clone_factory_for_canary, false);
+  ASSERT_TRUE(base_wasm_handle_2 && base_wasm_handle_2->wasm());
+
+  // Base Wasm
+  EXPECT_EQ(base_wasm_handle_1->wasm(), base_wasm_handle_2->wasm());
+  // Plugin key should be different with each other, because root_id is different.
+  EXPECT_NE(plugin_1->key(), plugin_2->key());
+  // For each create Wasm, canary should be done.
+  EXPECT_EQ(canary_count, 2);
+}
+
 } // namespace proxy_wasm