wasm: allow using empty vm_id to indicate the current WasmVM.

bazel/repository_locations.bzl

@@ -935,8 +935,8 @@ REPOSITORY_LOCATIONS_SPEC = dict(
         project_name = "WebAssembly for Proxies (C++ host implementation)",
         project_desc = "WebAssembly for Proxies (C++ host implementation)",
         project_url = "https://github.com/proxy-wasm/proxy-wasm-cpp-host",
-        version = "dd33aa6d825cd63deaa0f793c8caca8a9132a05f",
-        sha256 = "dac7998459616396684f17f35890fb03116450110f4d3bce3d9ae652141f2d3f",
+        version = "217320a45ef21db1bf79e7bd8e0190f9a9750b94",
+        sha256 = "cc1eac37f92dad52c0091bb53503f735e5412f61d04693cc0426a92e7f6eae46",
         strip_prefix = "proxy-wasm-cpp-host-{version}",
         urls = ["https://github.com/proxy-wasm/proxy-wasm-cpp-host/archive/{version}.tar.gz"],
         use_category = ["dataplane_ext"],
@@ -951,7 +951,7 @@ REPOSITORY_LOCATIONS_SPEC = dict(
             "envoy.wasm.runtime.wavm",
             "envoy.wasm.runtime.wasmtime",
         ],
-        release_date = "2021-03-03",
+        release_date = "2021-03-08",
         cpe = "N/A",
     ),
     proxy_wasm_rust_sdk = dict(

test/extensions/filters/http/wasm/test_data/shared_queue_rust.rs

@@ -8,7 +8,6 @@ pub fn _start() {
     proxy_wasm::set_root_context(|_| -> Box<dyn RootContext> {
         Box::new(TestRoot { queue_id: None })
     });
-    proxy_wasm::set_http_context(|_, _| -> Box<dyn HttpContext> { Box::new(TestStream) });
 }
 
 struct TestRoot {
@@ -38,24 +37,50 @@ impl RootContext for TestRoot {
             }
         }
     }
+
+    fn get_type(&self) -> Option<ContextType> {
+        Some(ContextType::HttpContext)
+    }
+
+    fn create_http_context(&self, _: u32) -> Option<Box<dyn HttpContext>> {
+        Some(Box::new(TestStream {
+            queue_id: self.queue_id,
+        }))
+    }
 }
 
-struct TestStream;
+struct TestStream {
+    queue_id: Option<u32>,
+}
 
 impl Context for TestStream {}
 
 impl HttpContext for TestStream {
     fn on_http_request_headers(&mut self, _: usize) -> Action {
+        if self.resolve_shared_queue("", "bad_shared_queue").is_none() {
+            warn!("onRequestHeaders not found self/bad_shared_queue");
+        }
         if self
             .resolve_shared_queue("vm_id", "bad_shared_queue")
             .is_none()
         {
-            warn!("onRequestHeaders not found bad_shared_queue");
+            warn!("onRequestHeaders not found vm_id/bad_shared_queue");
+        }
+        if self
+            .resolve_shared_queue("bad_vm_id", "bad_shared_queue")
+            .is_none()
+        {
+            warn!("onRequestHeaders not found bad_vm_id/bad_shared_queue");
+        }
+        if Some(self.resolve_shared_queue("", "my_shared_queue")) == Some(self.queue_id) {
+            warn!("onRequestHeaders found self/my_shared_queue");
         }
-        if let Some(queue_id) = self.resolve_shared_queue("vm_id", "my_shared_queue") {
-            self.enqueue_shared_queue(queue_id, Some(b"data1")).unwrap();
-            warn!("onRequestHeaders enqueue Ok");
+        if Some(self.resolve_shared_queue("vm_id", "my_shared_queue")) == Some(self.queue_id) {
+            warn!("onRequestHeaders found vm_id/my_shared_queue");
         }
+        self.enqueue_shared_queue(self.queue_id.unwrap(), Some(b"data1"))
+            .unwrap();
+        warn!("onRequestHeaders enqueue Ok");
         Action::Continue
     }
 }

test/extensions/filters/http/wasm/test_data/test_shared_queue_cpp.cc

@@ -11,13 +11,6 @@
 
 START_WASM_PLUGIN(HttpWasmTestCpp)
 
-class SharedQueueContext : public Context {
-public:
-  explicit SharedQueueContext(uint32_t id, RootContext* root) : Context(id, root) {}
-
-  FilterHeadersStatus onRequestHeaders(uint32_t, bool) override;
-};
-
 class SharedQueueRootContext : public RootContext {
 public:
   explicit SharedQueueRootContext(uint32_t id, std::string_view root_id)
@@ -29,6 +22,17 @@ class SharedQueueRootContext : public RootContext {
   uint32_t shared_queue_token_;
 };
 
+class SharedQueueContext : public Context {
+public:
+  explicit SharedQueueContext(uint32_t id, RootContext* root) : Context(id, root) {}
+
+  FilterHeadersStatus onRequestHeaders(uint32_t, bool) override;
+
+private:                                                                                            
+  SharedQueueRootContext* root() { return static_cast<SharedQueueRootContext*>(Context::root()); }
+
+};
+
 static RegisterContextFactory register_SharedQueueContext(CONTEXT_FACTORY(SharedQueueContext),
                                                           ROOT_FACTORY(SharedQueueRootContext),
                                                           "shared_queue");
@@ -40,10 +44,23 @@ bool SharedQueueRootContext::onStart(size_t) {
 
 FilterHeadersStatus SharedQueueContext::onRequestHeaders(uint32_t, bool) {
   uint32_t token;
+  if (resolveSharedQueue("", "bad_shared_queue", &token) == WasmResult::NotFound) {
+    logWarn("onRequestHeaders not found self/bad_shared_queue");
+  }
   if (resolveSharedQueue("vm_id", "bad_shared_queue", &token) == WasmResult::NotFound) {
-    logWarn("onRequestHeaders not found bad_shared_queue");
+    logWarn("onRequestHeaders not found vm_id/bad_shared_queue");
+  }
+  if (resolveSharedQueue("bad_vm_id", "bad_shared_queue", &token) == WasmResult::NotFound) {
+    logWarn("onRequestHeaders not found bad_vm_id/bad_shared_queue");
+  }
+  if (resolveSharedQueue("", "my_shared_queue", &token) == WasmResult::Ok &&
+      token == root()->shared_queue_token_) {
+    logWarn("onRequestHeaders found self/my_shared_queue");
+  }
+  if (resolveSharedQueue("vm_id", "my_shared_queue", &token) == WasmResult::Ok &&
+      token == root()->shared_queue_token_) {
+    logWarn("onRequestHeaders found vm_id/my_shared_queue");
   }
-  CHECK_RESULT(resolveSharedQueue("vm_id", "my_shared_queue", &token));
   if (enqueueSharedQueue(token, "data1") == WasmResult::Ok) {
     logWarn("onRequestHeaders enqueue Ok");
   }

test/extensions/filters/http/wasm/wasm_filter_test.cc

@@ -1492,9 +1492,21 @@ TEST_P(WasmHttpFilterTest, SharedQueue) {
   setupTest("shared_queue");
   setupFilter();
   EXPECT_CALL(filter(),
-              log_(spdlog::level::warn, Eq(absl::string_view("onRequestHeaders enqueue Ok"))));
+              log_(spdlog::level::warn,
+                   Eq(absl::string_view("onRequestHeaders not found self/bad_shared_queue"))));
+  EXPECT_CALL(filter(),
+              log_(spdlog::level::warn,
+                   Eq(absl::string_view("onRequestHeaders not found vm_id/bad_shared_queue"))));
+  EXPECT_CALL(filter(),
+              log_(spdlog::level::warn,
+                   Eq(absl::string_view("onRequestHeaders not found bad_vm_id/bad_shared_queue"))));
   EXPECT_CALL(filter(), log_(spdlog::level::warn,
-                             Eq(absl::string_view("onRequestHeaders not found bad_shared_queue"))));
+                             Eq(absl::string_view("onRequestHeaders found self/my_shared_queue"))));
+  EXPECT_CALL(filter(),
+              log_(spdlog::level::warn,
+                   Eq(absl::string_view("onRequestHeaders found vm_id/my_shared_queue"))));
+  EXPECT_CALL(filter(),
+              log_(spdlog::level::warn, Eq(absl::string_view("onRequestHeaders enqueue Ok"))));
   EXPECT_CALL(rootContext(),
               log_(spdlog::level::warn, Eq(absl::string_view("onQueueReady bad token not found"))))
       .Times(2);