Add wasm_cc_binary rule. (#68)

Signed-off-by: Pengyuan Bian <[email protected]>

Author: bianpengyuan

bazel/wasm/BUILD

@@ -0,0 +1 @@
+licenses(["notice"])  # Apache 2

bazel/wasm/wasm.bzl

@@ -0,0 +1,87 @@
+#  Copyright 2016-2020 Envoy Project Authors
+#  Copyright 2020 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.
+
+load("@rules_cc//cc:defs.bzl", "cc_binary")
+
+def _wasm_cc_transition_impl(settings, attr):
+    return {
+        "//command_line_option:cpu": "wasm32",
+        "//command_line_option:crosstool_top": "@proxy_wasm_cpp_sdk//toolchain:emscripten",
+
+        # Overriding copt/cxxopt/linkopt to prevent sanitizers/coverage options leak
+        # into Wasm build configuration
+        "//command_line_option:copt": [],
+        "//command_line_option:cxxopt": [],
+        "//command_line_option:linkopt": [],
+        "//command_line_option:collect_code_coverage": "false",
+        "//command_line_option:fission": "no",
+    }
+
+wasm_cc_transition = transition(
+    implementation = _wasm_cc_transition_impl,
+    inputs = [],
+    outputs = [
+        "//command_line_option:cpu",
+        "//command_line_option:crosstool_top",
+        "//command_line_option:copt",
+        "//command_line_option:cxxopt",
+        "//command_line_option:fission",
+        "//command_line_option:linkopt",
+        "//command_line_option:collect_code_coverage",
+    ],
+)
+
+def wasm_binary_impl(ctx):
+    out = ctx.actions.declare_file(ctx.label.name)
+    ctx.actions.run(
+        executable = "cp",
+        arguments = [ctx.files.binary[0].path, out.path],
+        outputs = [out],
+        inputs = ctx.files.binary,
+    )
+
+    return [DefaultInfo(files = depset([out]), runfiles = ctx.runfiles([out]))]
+
+def _wasm_attrs(transition):
+    return {
+        "binary": attr.label(mandatory = True, cfg = transition),
+        "_whitelist_function_transition": attr.label(default = "@bazel_tools//tools/whitelists/function_transition_whitelist"),
+    }
+
+# Wasm binary rule implementation.
+# This copies the binary specified in binary attribute in Wasm configuration to
+# target configuration, so a binary in non-Wasm configuration can depend on them.
+wasm_cc_binary_rule = rule(
+    implementation = wasm_binary_impl,
+    attrs = _wasm_attrs(wasm_cc_transition),
+)
+
+def wasm_cc_binary(name, tags = [], **kwargs):
+    wasm_name = "_wasm_" + name
+    kwargs.setdefault("visibility", ["//visibility:public"])
+    cc_binary(
+        name = wasm_name,
+        # Adding manual tag it won't be built in non-Wasm (e.g. x86_64 config)
+        # when an wildcard is specified, but it will be built in Wasm configuration
+        # when the wasm_binary below is built.
+        tags = ["manual"],
+        **kwargs
+    )
+
+    wasm_cc_binary_rule(
+        name = name,
+        binary = ":" + wasm_name,
+        tags = tags,
+    )

example/BUILD

@@ -0,0 +1,11 @@
+load("//bazel/wasm:wasm.bzl", "wasm_cc_binary")
+
+licenses(["notice"])  # Apache 2
+
+wasm_cc_binary(
+    name = "http_wasm_example.wasm",
+    srcs = ["http_wasm_example.cc"],
+    deps = [
+        "@proxy_wasm_cpp_sdk//:proxy_wasm_intrinsics",
+    ],
+)

example/http_wasm_example.cc

@@ -0,0 +1,105 @@
+// Copyright 2016-2020 Envoy Project Authors
+// Copyright 2020 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 ExampleRootContext : public RootContext {
+public:
+  explicit ExampleRootContext(uint32_t id, std::string_view root_id) : RootContext(id, root_id) {}
+
+  bool onStart(size_t) override;
+  bool onConfigure(size_t) override;
+  void onTick() override;
+};
+
+class ExampleContext : public Context {
+public:
+  explicit ExampleContext(uint32_t id, RootContext *root) : Context(id, root) {}
+
+  void onCreate() override;
+  FilterHeadersStatus onRequestHeaders(uint32_t headers, bool end_of_stream) override;
+  FilterDataStatus onRequestBody(size_t body_buffer_length, bool end_of_stream) override;
+  FilterHeadersStatus onResponseHeaders(uint32_t headers, bool end_of_stream) override;
+  FilterDataStatus onResponseBody(size_t body_buffer_length, bool end_of_stream) override;
+  void onDone() override;
+  void onLog() override;
+  void onDelete() override;
+};
+static RegisterContextFactory register_ExampleContext(CONTEXT_FACTORY(ExampleContext),
+                                                      ROOT_FACTORY(ExampleRootContext),
+                                                      "my_root_id");
+
+bool ExampleRootContext::onStart(size_t) {
+  LOG_TRACE("onStart");
+  return true;
+}
+
+bool ExampleRootContext::onConfigure(size_t) {
+  LOG_TRACE("onConfigure");
+  proxy_set_tick_period_milliseconds(1000); // 1 sec
+  return true;
+}
+
+void ExampleRootContext::onTick() { LOG_TRACE("onTick"); }
+
+void ExampleContext::onCreate() { LOG_WARN(std::string("onCreate " + std::to_string(id()))); }
+
+FilterHeadersStatus ExampleContext::onRequestHeaders(uint32_t, bool) {
+  LOG_DEBUG(std::string("onRequestHeaders ") + std::to_string(id()));
+  auto result = getRequestHeaderPairs();
+  auto pairs = result->pairs();
+  LOG_INFO(std::string("headers: ") + std::to_string(pairs.size()));
+  for (auto &p : pairs) {
+    LOG_INFO(std::string(p.first) + std::string(" -> ") + std::string(p.second));
+  }
+  return FilterHeadersStatus::Continue;
+}
+
+FilterHeadersStatus ExampleContext::onResponseHeaders(uint32_t, bool) {
+  LOG_DEBUG(std::string("onResponseHeaders ") + std::to_string(id()));
+  auto result = getResponseHeaderPairs();
+  auto pairs = result->pairs();
+  LOG_INFO(std::string("headers: ") + std::to_string(pairs.size()));
+  for (auto &p : pairs) {
+    LOG_INFO(std::string(p.first) + std::string(" -> ") + std::string(p.second));
+  }
+  addResponseHeader("X-Wasm-custom", "FOO");
+  replaceResponseHeader("content-type", "text/plain; charset=utf-8");
+  removeResponseHeader("content-length");
+  return FilterHeadersStatus::Continue;
+}
+
+FilterDataStatus ExampleContext::onRequestBody(size_t body_buffer_length,
+                                               bool /* end_of_stream */) {
+  auto body = getBufferBytes(WasmBufferType::HttpRequestBody, 0, body_buffer_length);
+  LOG_ERROR(std::string("onRequestBody ") + std::string(body->view()));
+  return FilterDataStatus::Continue;
+}
+
+FilterDataStatus ExampleContext::onResponseBody(size_t /* body_buffer_length */,
+                                                bool /* end_of_stream */) {
+  setBuffer(WasmBufferType::HttpResponseBody, 0, 12, "Hello, world");
+  return FilterDataStatus::Continue;
+}
+
+void ExampleContext::onDone() { LOG_WARN(std::string("onDone " + std::to_string(id()))); }
+
+void ExampleContext::onLog() { LOG_WARN(std::string("onLog " + std::to_string(id()))); }
+
+void ExampleContext::onDelete() { LOG_WARN(std::string("onDelete " + std::to_string(id()))); }