Add nodejs sandbox

examples/wasm/Makefile

@@ -1,5 +1,10 @@
 #OPT=-O3
-OPT=
+OPT=-s EXTRA_EXPORTED_RUNTIME_METHODS='["addOnPostRun"]' -s EXPORTED_FUNCTIONS='["_onStart"]' -s DEMANGLE_SUPPORT=1 -s MODULARIZE=1
+
+run: envoy_filter_http_wasm_example.wasm runfilter.js
+	node runfilter.js
 
 envoy_filter_http_wasm_example.wasm: envoy_filter_http_wasm_example.cc envoy_wasm_intrinsics.h envoy_wasm_filter_intrinsics.h envoy_wasm_intrinsics.js
 	em++ -s WASM=1 --std=c++14 $(OPT) -g3 --js-library envoy_wasm_intrinsics.js envoy_filter_http_wasm_example.cc -o envoy_filter_http_wasm_example.js
+	#em++ -s WASM=1 --std=c++14 $(OPT) -g3 --pre-js enn.js --js-library envoy_wasm_intrinsics.js envoy_filter_http_wasm_example.cc -o envoy_filter_http_wasm_example.js
+

examples/wasm/envoy_filter_http_wasm_example.cc

@@ -16,6 +16,7 @@ class Context {
 
 private:
   int32_t id_;
+	bool suspended_;
 };
 
 static std::unordered_map<int32_t, std::unique_ptr<Context>> context_map;
@@ -47,7 +48,16 @@ FilterHeadersStatus Context::onStart() {
     logInfo(std::string(p.first) + std::string(" -> ") + std::string(p.second));
   }
   addHeader(HeaderType::Header, "newheader", "newheadervalue");
+  addHeader(HeaderType::Header, "x-ctx", std::to_string(id_));
   replaceHeader(HeaderType::Header, "server", "envoy-wasm");
+	if (id_ == 2) {
+		if (suspended_) {
+			suspended_ = false;
+  		return FilterHeadersStatus::Continue;
+		}
+		suspended_ = true;
+		return FilterHeadersStatus::StopIteration;
+	}
   return FilterHeadersStatus::Continue;
 }
 

examples/wasm/envoy_wasm_filter_intrinsics.h

@@ -32,6 +32,9 @@ enum class FilterDataStatus : int { Continue = 0, StopIterationAndBuffer = 1,
   StopIterationAndWatermark = 2, StopIterationNoBuffer = 3 };
 
 // Calls from WASM to Envoy.
+extern "C" void envoy_callAsync(const char* url_ptr, size_t url_size);
+
+
 extern "C" void envoy_addHeader(HeaderType type, const char* key_ptr, size_t key_size,
                                      const char* value_ptr, size_t value_size);
 
@@ -102,6 +105,7 @@ inline std::vector<std::pair<std::string_view, std::string_view>> WasmData::pair
 // Calls from Envoy to WASM.
 extern "C" int main();
 
+extern "C" FilterHeadersStatus onContinue(int32_t context_id, int32_t async_id);
 extern "C" FilterHeadersStatus onStart(int32_t context_id);
 extern "C" FilterDataStatus onBody(int32_t context_id, uint32_t body_buffer_length, uint32_t end_of_stream);
 extern "C" FilterTrailersStatus onTrailers(int32_t context_id);

examples/wasm/envoy_wasm_intrinsics.js

@@ -1,9 +1,82 @@
 mergeInto(LibraryManager.library, {
-    envoy_log: function () {},
-    envoy_addHeader: function () {},
-    envoy_getHeader: function () {},
-    envoy_replaceHeader: function () {},
-    envoy_removeHeader: function () {},
-    envoy_getBodyBufferBytes: function () {},
-    envoy_getHeaderPairs: function () {},
+    envoy_log: function(arg1, arg2) {
+        ps = Pointer_stringify(arg2);
+        console.log("envoy_log:", arg1, ps);
+    },
+    envoy_addHeader: function(type, key_data, key_size, value_data, value_size) {
+        resp = Module["resp"];
+        if (!req) {
+            return;
+        }
+
+        key = UTF8ToString(key_data); //, key_size);
+        value = UTF8ToString(value_data); //, key_size);
+        resp.setHeader(key, value);
+    },
+    envoy_getHeader: function(type, key_data, key_size, value_ptr, value_size_ptr) {
+        req = Module["req"];
+        if (!req) {
+            return;
+        }
+
+        key = UTF8ToString(key_data); //, key_size);
+
+        let val = req.getHeader(key);
+        let val_len = val.length;
+
+        let string_on_heap = _malloc(val_len + 1);
+        stringToUTF8(val, string_on_heap, val_len + 1);
+        setValue(value_ptr, string_on_heap, "i32");
+        setValue(value_size_ptr, val_len + 1, "i32");
+    },
+    envoy_replaceHeader: function(type, key_data, key_size, value_data, value_size) {
+        resp = Module["resp"];
+        if (!req) {
+            return;
+        }
+
+        key = UTF8ToString(key_data); //, key_size);
+        value = UTF8ToString(value_data); //, key_size);
+        resp.setHeader(key, value);
+    },
+    envoy_removeHeader: function(type, key_data, key_size) {},
+    envoy_getBodyBufferBytes: function() {},
+    envoy_getHeaderPairs: function(headertype, hptr, hptr_size) {
+        req = Module["req"];
+        if (!req) {
+            return;
+        }
+        rh = req.headers;
+        let size = 4; // size of int32
+        let nkeys = 0;
+        Object.keys(rh).forEach(key => {
+            size += 8; // size of key, size of value
+            size += key.length + 1; // null terminated key
+            size += rh[key].length + 1; // null terminated value
+            nkeys += 1;
+        });
+        let ptr = _malloc(size);
+        let curr = ptr;
+
+
+        setValue(curr, nkeys, "i32");
+        curr += 4; // sizeof(i32)
+        Object.keys(rh).forEach(key => {
+            setValue(curr, key.length, "i32");
+            curr += 4; // sizeof(i32)
+            setValue(curr, rh[key].length, "i32");
+            curr += 4; // sizeof(i32)
+        });
+
+        Object.keys(rh).forEach(key => {
+            stringToUTF8(key, curr, key.length + 1);
+            curr += key.length + 1;
+            let val = rh[key];
+            stringToUTF8(val, curr, val.length + 1);
+            curr += val.length + 1;
+        });
+
+        setValue(hptr, ptr, "i32");
+        setValue(hptr_size, size, "i32");
+    },
 });

examples/wasm/runfilter.js

@@ -0,0 +1,16 @@
+const enn = require('./envoy_filter_http_wasm_example.js');
+var en = enn();
+
+// library uses request_headers function which can be injected here
+// by the user. There must be a better way !
+en["request_headers"] = function() {
+    return {
+        "qq": "gg",
+        "ab": "cc",
+        "woo": "hoo"
+    };
+}
+
+en.then(function(inst) {
+    inst._onStart();
+});

examples/wasm/server.js

@@ -0,0 +1,46 @@
+const http = require('http');
+const enn = require('./envoy_filter_http_wasm_example.js');
+var en = enn();
+
+var reqNo = 0;
+
+server = http.createServer((request, response) => {
+		let thisReq = reqNo;
+		reqNo++;
+    request.on('error', (err) => {
+        console.error(err);
+        response.statusCode = 400;
+        response.end();
+    });
+    response.on('error', (err) => {
+        console.error(err);
+    });
+
+		response.on('finish', (arg) => {
+				console.log(arg);
+				en._onDestroy(thisReq);
+		});
+
+    // connect http server
+    en["req"] = request;
+    en["resp"] = response;
+
+    // invoke filter
+    let fresult = en._onStart(thisReq);
+		if (fresult == 0){ // 0 is Continue
+    	console.log(fresult);
+    	request.pipe(response);
+		} else {
+			console.log("suspending request");
+			setTimeout(function() {
+    			en["req"] = request;
+    			en["resp"] = response;
+    			fresult = en._onStart(thisReq);
+    			request.pipe(response);
+			}, 5000);
+		}
+});
+
+en.then(function(inst) {
+    server.listen(8080);
+});