fix

Signed-off-by: Shikugawa <[email protected]>

Author: Shikugawa

.bazelrc

@@ -140,6 +140,7 @@ build:remote --spawn_strategy=remote,sandboxed,local
 build:remote --strategy=Javac=remote,sandboxed,local
 build:remote --strategy=Closure=remote,sandboxed,local
 build:remote --strategy=Genrule=remote,sandboxed,local
+build:remote --strategy_regexp=_wasm_.*_rust=local
 build:remote --remote_timeout=7200
 build:remote --auth_enabled=true
 build:remote --remote_download_toplevel

bazel/wasm/wasm.bzl

@@ -98,14 +98,14 @@ def wasm_rust_binary(name, **kwargs):
     )
 
     wasm_rust_binary_rule(
-        name = name,
+        name = "precompile_" + name,
         binary = ":" + wasm_name,
     )
 
     native.genrule(
-        name = "wee8_" + name,
-        srcs = [":" + name],
-        outs = ["wee8_" + name],
+        name = name,
+        srcs = [":precompile_" + name],
+        outs = [name],
         tools = ["//test/tools/wee8_compile:wee8_compile_tool"],
-        cmd = "$(location //test/tools/wee8_compile:wee8_compile_tool) $(SRCS).runfiles $(OUTS).runtimes",
+        cmd = "$(location //test/tools/wee8_compile:wee8_compile_tool) $(SRCS).runfiles $(OUTS).runfiles",
     )

source/common/common/thread.h

@@ -60,9 +60,9 @@ class CondVar {
    * @return WaitStatus whether the condition timed out or not.
    */
   template <class Rep, class Period>
-  WaitStatus waitFor(MutexBasicLockable& mutex,
-                     std::chrono::duration<Rep, Period> duration) noexcept
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex) {
+  WaitStatus waitFor(
+      MutexBasicLockable& mutex,
+      std::chrono::duration<Rep, Period> duration) noexcept ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex) {
     return condvar_.WaitWithTimeout(&mutex.mutex_, absl::FromChrono(duration))
                ? WaitStatus::Timeout
                : WaitStatus::NoTimeout;

source/extensions/common/tap/admin.cc

@@ -110,7 +110,7 @@ void AdminHandler::AdminPerTapSinkHandle::submitTrace(
   std::shared_ptr<envoy::data::tap::v3::TraceWrapper> shared_trace{std::move(trace)};
   // The handle can be destroyed before the cross thread post is complete. Thus, we capture a
   // reference to our parent.
-  parent_.main_thread_dispatcher_.post([&parent = parent_, trace = shared_trace, format]() {
+  parent_.main_thread_dispatcher_.post([& parent = parent_, trace = shared_trace, format]() {
     if (!parent.attached_request_.has_value()) {
       return;
     }

source/extensions/filters/http/ext_authz/ext_authz.cc

@@ -201,7 +201,7 @@ void Filter::onComplete(Filters::Common::ExtAuthz::ResponsePtr&& response) {
 
     callbacks_->sendLocalReply(
         response->status_code, response->body,
-        [&headers = response->headers_to_add,
+        [& headers = response->headers_to_add,
          &callbacks = *callbacks_](Http::HeaderMap& response_headers) -> void {
           ENVOY_STREAM_LOG(trace,
                            "ext_authz filter added header(s) to the local response:", callbacks);

test/extensions/common/wasm/wasm_test.cc

@@ -50,7 +50,7 @@ class TestContext : public Extensions::Common::Wasm::Context {
               const Extensions::Common::Wasm::PluginSharedPtr& plugin)
       : Extensions::Common::Wasm::Context(wasm, root_context_id, plugin) {}
   ~TestContext() override = default;
-  proxy_wasm::WasmResult log(uint32_t level, absl::string_view message) {
+  proxy_wasm::WasmResult log(uint32_t level, absl::string_view message) override {
     std::cerr << std::string(message) << "\n";
     log_(static_cast<spdlog::level::level_enum>(level), message);
     Extensions::Common::Wasm::Context::log(static_cast<spdlog::level::level_enum>(level), message);

test/extensions/wasm/wasm_test.cc

@@ -25,7 +25,7 @@ class TestContext : public Extensions::Common::Wasm::Context {
   using Extensions::Common::Wasm::Context::log;
   TestContext(Extensions::Common::Wasm::Wasm* wasm) : Extensions::Common::Wasm::Context(wasm) {}
   ~TestContext() override = default;
-  proxy_wasm::WasmResult log(uint32_t level, absl::string_view message) {
+  proxy_wasm::WasmResult log(uint32_t level, absl::string_view message) override {
     std::cerr << std::string(message) << "\n";
     log_(static_cast<spdlog::level::level_enum>(level), message);
     return proxy_wasm::WasmResult::Ok;

test/mocks/common.h

@@ -57,9 +57,9 @@ class MockTimeSystem : public Event::TestTimeSystem {
   void advanceTimeAsync(const Duration& duration) override {
     real_time_.advanceTimeAsync(duration);
   }
-  Thread::CondVar::WaitStatus waitFor(Thread::MutexBasicLockable& mutex, Thread::CondVar& condvar,
-                                      const Duration& duration) noexcept
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex) override {
+  Thread::CondVar::WaitStatus
+  waitFor(Thread::MutexBasicLockable& mutex, Thread::CondVar& condvar,
+          const Duration& duration) noexcept ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex) override {
     return real_time_.waitFor(mutex, condvar, duration); // NO_CHECK_FORMAT(real_time)
   }
   MOCK_METHOD(SystemTime, systemTime, ());

test/test_common/simulated_time_system.cc

@@ -247,10 +247,9 @@ void SimulatedTimeSystemHelper::waitForNoPendingLockHeld() const EXCLUSIVE_LOCKS
       &pending_alarms_));
 }
 
-Thread::CondVar::WaitStatus SimulatedTimeSystemHelper::waitFor(Thread::MutexBasicLockable& mutex,
-                                                               Thread::CondVar& condvar,
-                                                               const Duration& duration) noexcept
-    EXCLUSIVE_LOCKS_REQUIRED(mutex) {
+Thread::CondVar::WaitStatus SimulatedTimeSystemHelper::waitFor(
+    Thread::MutexBasicLockable& mutex, Thread::CondVar& condvar,
+    const Duration& duration) noexcept EXCLUSIVE_LOCKS_REQUIRED(mutex) {
   only_one_thread_.checkOneThread();
 
   // TODO(#10568): This real-time polling delay should not be necessary. Without

test/test_common/simulated_time_system.h

@@ -28,9 +28,9 @@ class SimulatedTimeSystemHelper : public TestTimeSystem {
   // TestTimeSystem
   void advanceTimeWait(const Duration& duration) override;
   void advanceTimeAsync(const Duration& duration) override;
-  Thread::CondVar::WaitStatus waitFor(Thread::MutexBasicLockable& mutex, Thread::CondVar& condvar,
-                                      const Duration& duration) noexcept
-      EXCLUSIVE_LOCKS_REQUIRED(mutex) override;
+  Thread::CondVar::WaitStatus
+  waitFor(Thread::MutexBasicLockable& mutex, Thread::CondVar& condvar,
+          const Duration& duration) noexcept EXCLUSIVE_LOCKS_REQUIRED(mutex) override;
 
   // TimeSource
   SystemTime systemTime() override;