chore: Rework the reactor interface (#610)

Author: elliottt

runtime/js-compute-runtime/fastly-world/fastly_world.c

@@ -3051,14 +3051,14 @@ bool fastly_compute_at_edge_uap_parse(fastly_world_string_t *user_agent, fastly_
   }
 }
 
-__attribute__((__export_name__("compute-at-edge#serve")))
-int32_t __wasm_export_compute_at_edge_serve(int32_t arg, int32_t arg0) {
-  compute_at_edge_request_t arg1 = (compute_at_edge_request_t) {
+__attribute__((__export_name__("fastly:compute-at-edge/reactor#serve")))
+int32_t __wasm_export_exports_fastly_compute_at_edge_reactor_serve(int32_t arg, int32_t arg0) {
+  fastly_compute_at_edge_reactor_request_t arg1 = (fastly_compute_at_edge_http_types_request_t) {
     (uint32_t) (arg),
     (uint32_t) (arg0),
   };
   fastly_world_result_void_void_t ret;
-  ret.is_err = !compute_at_edge_serve(&arg1);
+  ret.is_err = !exports_fastly_compute_at_edge_reactor_serve(&arg1);
   int32_t result;
   if ((ret).is_err) {
     result = 1;

runtime/js-compute-runtime/fastly-world/fastly_world.h

@@ -442,14 +442,7 @@ typedef struct {
   fastly_compute_at_edge_cache_handle_t f1;
 } fastly_world_tuple2_fastly_compute_at_edge_cache_body_handle_fastly_compute_at_edge_cache_handle_t;
 
-typedef uint32_t compute_at_edge_request_handle_t;
-
-typedef uint32_t compute_at_edge_body_handle_t;
-
-typedef struct {
-  compute_at_edge_request_handle_t f0;
-  compute_at_edge_body_handle_t f1;
-} compute_at_edge_request_t;
+typedef fastly_compute_at_edge_http_types_request_t fastly_compute_at_edge_reactor_request_t;
 
 // Imported Functions from `fastly:compute-at-edge/async-io`
 // Blocks until one of the given objects is ready for I/O, or the optional timeout expires.
@@ -610,8 +603,8 @@ bool fastly_compute_at_edge_secret_store_plaintext(fastly_compute_at_edge_secret
 // Imported Functions from `fastly:compute-at-edge/uap`
 bool fastly_compute_at_edge_uap_parse(fastly_world_string_t *user_agent, fastly_compute_at_edge_uap_user_agent_t *ret, fastly_compute_at_edge_uap_error_t *err);
 
-// Exported Functions from `compute-at-edge`
-bool compute_at_edge_serve(compute_at_edge_request_t *req);
+// Exported Functions from `fastly:compute-at-edge/reactor`
+bool exports_fastly_compute_at_edge_reactor_serve(fastly_compute_at_edge_reactor_request_t *req);
 
 #ifdef __cplusplus
 }

runtime/js-compute-runtime/fastly-world/fastly_world_component_type.o

@@ -667,6 +667,16 @@ interface cache {
   get-body: func(handle: handle, options: get-body-options) -> result<body-handle, error>
 }
 
+interface reactor {
+  use http-types.{request}
+
+  /// Serve the given request
+  ///
+  /// response handle not currently returned, because in the case of a streamed response
+  /// send downstream must be fully streamed due to the run to completion semantics.
+  serve: func(req: request) -> result
+}
+
 world fastly-world {
 
   import async-io
@@ -682,15 +692,5 @@ world fastly-world {
   import secret-store
   import uap
 
-  export compute-at-edge: interface {
-    type request-handle = u32
-    type body-handle = u32
-    type request = tuple<request-handle, body-handle>
-
-    /// Serve the given request
-    ///
-    /// response handle not currently returned, because in the case of a streamed response
-    /// send downstream must be fully streamed due to the run to completion semantics.
-    serve: func(req: request) -> result
-  }
+  export reactor
 }

runtime/js-compute-runtime/fastly.wit

@@ -330,6 +330,8 @@ struct CacheOverrideTag final {
   void set_pci();
 };
 
+struct Request;
+
 class HttpReq final : public HttpBase {
 public:
   using Handle = uint32_t;
@@ -348,6 +350,9 @@ class HttpReq final : public HttpBase {
   static Result<Void> register_dynamic_backend(std::string_view name, std::string_view target,
                                                const BackendConfig &config);
 
+  /// Fetch the downstream request/body pair
+  static Result<Request> downstream_get();
+
   /// Get the downstream ip address.
   static Result<HostBytes> downstream_client_ip_addr();
 
@@ -442,6 +447,15 @@ struct Response {
   Response(HttpResp resp, HttpBody body) : resp{resp}, body{body} {}
 };
 
+/// The pair of a request and its body.
+struct Request {
+  HttpReq req;
+  HttpBody body;
+
+  Request() = default;
+  Request(HttpReq req, HttpBody body) : req{req}, body{body} {}
+};
+
 class GeoIp final {
   ~GeoIp() = delete;
 

runtime/js-compute-runtime/host_interface/host_api.h

@@ -1,13 +1,16 @@
 #include "host_interface/fastly.h"
+#include "host_interface/host_api.h"
+#include "js-compute-builtins.h"
 
 int main(int argc, const char *argv[]) {
-  fastly_compute_at_edge_http_types_request_t req;
-  if (fastly::req_body_downstream_get(&req.f0, &req.f1) != 0) {
+  host_api::Request req;
+
+  if (fastly::req_body_downstream_get(&req.req.handle, &req.body.handle) != 0) {
     abort();
     return 1;
   }
 
-  compute_at_edge_serve(static_cast<compute_at_edge_request_t *>(static_cast<void *>(&req)));
+  reactor_main(req);
 
   // Note: we deliberately skip shutdown, because it takes quite a while,
   // and serves no purpose for us.

runtime/js-compute-runtime/impl/main.cpp

@@ -1,3 +1,10 @@
 #include "host_interface/fastly.h"
+#include "host_interface/host_api.h"
+#include "js-compute-builtins.h"
 
 int main() { return 0; }
+
+bool exports_fastly_compute_at_edge_reactor_serve(fastly_compute_at_edge_reactor_request_t *req) {
+  host_api::Request request{host_api::HttpReq{req->f0}, host_api::HttpBody{req->f1}};
+  return reactor_main(request);
+}

runtime/js-compute-runtime/impl/main_component.cpp

@@ -113,4 +113,6 @@ void dump_promise_rejection(JSContext *cx, JS::HandleValue reason, JS::HandleObj
 bool print_stack(JSContext *cx, FILE *fp);
 bool print_stack(JSContext *cx, JS::HandleObject stack, FILE *fp);
 
+bool reactor_main(host_api::Request req);
+
 #endif // fastly_sys_h

runtime/js-compute-runtime/js-compute-builtins.h

@@ -23,7 +23,6 @@
 #include "core/allocator.h"
 #include "core/encode.h"
 #include "core/event_loop.h"
-#include "host_interface/fastly.h"
 #include "host_interface/host_api.h"
 #include "js-compute-builtins.h"
 #include "third_party/wizer.h"
@@ -480,7 +479,7 @@ static void wait_for_backends(JSContext *cx, double *total_compute) {
     printf("Done, waited for %fms\n", diff / 1000);
 }
 
-bool compute_at_edge_serve(compute_at_edge_request_t *req) {
+bool reactor_main(host_api::Request req) {
   assert(hasWizeningFinished());
 
   builtins::Performance::timeOrigin.emplace(std::chrono::high_resolution_clock::now());
@@ -501,8 +500,7 @@ bool compute_at_edge_serve(compute_at_edge_request_t *req) {
   js::ResetMathRandomSeed(cx);
 
   HandleObject fetch_event = builtins::FetchEvent::instance();
-  builtins::FetchEvent::init_request(cx, fetch_event, host_api::HttpReq{req->f0},
-                                     host_api::HttpBody{req->f1});
+  builtins::FetchEvent::init_request(cx, fetch_event, req.req, req.body);
 
   dispatch_fetch_event(cx, fetch_event, &total_compute);