cache canary results

Signed-off-by: Kuat Yessenov <[email protected]>

Author: kyessenov

include/proxy-wasm/wasm.h

@@ -337,6 +337,7 @@ class WasmHandleBase : public std::enable_shared_from_this<WasmHandleBase> {
 
 protected:
   std::shared_ptr<WasmBase> wasm_base_;
+  std::unordered_map<std::string, bool> plugin_canary_cache_;
 };
 
 std::string makeVmKey(std::string_view vm_id, std::string_view configuration,

src/wasm.cc

@@ -472,6 +472,11 @@ bool WasmHandleBase::canary(const std::shared_ptr<PluginBase> &plugin,
   if (this->wasm() == nullptr) {
     return false;
   }
+  auto it = plugin_canary_cache_.find(plugin->key());
+  if (it != plugin_canary_cache_.end()) {
+    return it->second;
+  }
+  std::cout << "CANARY TEST " << plugin->key() << std::endl;
   auto configuration_canary_handle = clone_factory(shared_from_this());
   if (!configuration_canary_handle) {
     this->wasm()->fail(FailState::UnableToCloneVm, "Failed to clone Base Wasm");
@@ -490,9 +495,11 @@ bool WasmHandleBase::canary(const std::shared_ptr<PluginBase> &plugin,
   if (!configuration_canary_handle->wasm()->configure(root_context, plugin)) {
     configuration_canary_handle->wasm()->fail(FailState::ConfigureFailed,
                                               "Failed to configure base Wasm plugin");
+    plugin_canary_cache_[plugin->key()] = false;
     return false;
   }
   configuration_canary_handle->kill();
+  plugin_canary_cache_[plugin->key()] = true;
   return true;
 }
 

test/wasm_test.cc

@@ -233,6 +233,30 @@ TEST_P(TestVm, AlwaysApplyCanary) {
       }
     }
   }
+
+  {
+    // Validate that canarying is cached
+    canary_count = 0;
+    TestContext::resetGlobalLog();
+    const auto &root_id = root_ids[0];
+    const auto &vm_id = vm_ids[0];
+    const auto &vm_config = vm_configs[0];
+    const auto &plugin_key = plugin_keys[0];
+    const auto &plugin_config = plugin_configs[0];
+    WasmHandleFactory wasm_handle_factory_comp =
+        [this, vm_id, vm_config](std::string_view vm_key) -> std::shared_ptr<WasmHandleBase> {
+      auto base_wasm = std::make_shared<TestWasm>(
+          newVm(), std::unordered_map<std::string, std::string>(), vm_id, vm_config, vm_key);
+      return std::make_shared<WasmHandleBase>(base_wasm);
+    };
+    const auto plugin_comp = std::make_shared<PluginBase>(plugin_name, root_id, vm_id, engine_,
+                                                          plugin_config, fail_open, plugin_key);
+    const auto vm_key = makeVmKey(vm_id, vm_config, "common_code");
+    // Create a base Wasm by createWasm.
+    auto wasm_handle_comp = createWasm(vm_key, source, plugin_comp, wasm_handle_factory_comp,
+                                       wasm_handle_clone_factory_for_canary, false);
+    EXPECT_EQ(canary_count, 0);
+  }
 }
 
 } // namespace proxy_wasm