Support request method get/set and version get in the host_api

Author: elliottt

runtime/js-compute-runtime/builtins/fetch-event.cpp

@@ -6,6 +6,8 @@
 #include "builtins/worker-location.h"
 #include "host_interface/host_api.h"
 
+using namespace std::literals::string_view_literals;
+
 namespace builtins {
 
 namespace {
@@ -77,33 +79,30 @@ JSObject *FetchEvent::prepare_downstream_request(JSContext *cx) {
   return Request::create(cx, requestInstance, HttpReq{}, HttpBody{}, true);
 }
 
-bool FetchEvent::init_downstream_request(JSContext *cx, JS::HandleObject request,
-                                         fastly_request_t *req) {
+bool FetchEvent::init_downstream_request(JSContext *cx, JS::HandleObject request, HttpReq req,
+                                         HttpBody body) {
   MOZ_ASSERT(!Request::request_handle(request).is_valid());
 
   fastly_error_t err;
 
-  fastly_request_handle_t request_handle = req->f0;
-  fastly_body_handle_t body_handle = req->f1;
-
   JS::SetReservedSlot(request, static_cast<uint32_t>(Request::Slots::Request),
-                      JS::Int32Value(request_handle));
+                      JS::Int32Value(req.handle));
   JS::SetReservedSlot(request, static_cast<uint32_t>(Request::Slots::Body),
-                      JS::Int32Value(body_handle));
+                      JS::Int32Value(body.handle));
 
   // Set the method.
-  fastly_world_string_t method_str;
-  if (!fastly_http_req_method_get(request_handle, &method_str, &err)) {
-    HANDLE_ERROR(cx, err);
+  auto res = req.get_method();
+  if (auto *err = res.to_err()) {
+    HANDLE_ERROR(cx, *err);
     return false;
   }
 
-  bool is_get = strncmp(method_str.ptr, "GET", method_str.len) == 0;
-  bool is_head = strncmp(method_str.ptr, "HEAD", method_str.len) == 0;
+  auto method_str = std::move(res.unwrap());
+  bool is_get = method_str == "GET"sv;
+  bool is_head = method_str == "HEAD"sv;
 
   if (!is_get) {
-    JS::RootedString method(cx, JS_NewStringCopyN(cx, method_str.ptr, method_str.len));
-    JS_free(cx, method_str.ptr);
+    JS::RootedString method(cx, JS_NewStringCopyN(cx, method_str.ptr.release(), method_str.len));
     if (!method) {
       return false;
     }
@@ -121,7 +120,7 @@ bool FetchEvent::init_downstream_request(JSContext *cx, JS::HandleObject request
   }
 
   fastly_world_string_t uri_str;
-  if (!fastly_http_req_uri_get(request_handle, &uri_str, &err)) {
+  if (!fastly_http_req_uri_get(req.handle, &uri_str, &err)) {
     HANDLE_ERROR(cx, err);
     return false;
   }
@@ -423,10 +422,10 @@ JSObject *FetchEvent::create(JSContext *cx) {
 
 JS::HandleObject FetchEvent::instance() { return INSTANCE; }
 
-bool FetchEvent::init_request(JSContext *cx, JS::HandleObject self, fastly_request_t *req) {
+bool FetchEvent::init_request(JSContext *cx, JS::HandleObject self, HttpReq req, HttpBody body) {
   JS::RootedObject request(
       cx, &JS::GetReservedSlot(self, static_cast<uint32_t>(Slots::Request)).toObject());
-  return init_downstream_request(cx, request, req);
+  return init_downstream_request(cx, request, req, body);
 }
 
 bool FetchEvent::is_active(JSObject *self) {

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

@@ -3,6 +3,7 @@
 
 #include "builtin.h"
 #include "host_interface/fastly.h"
+#include "host_interface/host_api.h"
 
 namespace builtins {
 
@@ -51,11 +52,11 @@ class FetchEvent final : public BuiltinNoConstructor<FetchEvent> {
   /**
    * Fully initialize the Request object based on the incoming request.
    */
-  static bool init_downstream_request(JSContext *cx, JS::HandleObject request,
-                                      fastly_request_t *req);
+  static bool init_downstream_request(JSContext *cx, JS::HandleObject request, HttpReq req,
+                                      HttpBody body);
 
   static bool respondWithError(JSContext *cx, JS::HandleObject self);
-  static bool init_request(JSContext *cx, JS::HandleObject self, fastly_request_t *req);
+  static bool init_request(JSContext *cx, JS::HandleObject self, HttpReq req, HttpBody body);
   static bool is_active(JSObject *self);
   static bool is_dispatching(JSObject *self);
   static void start_dispatching(JSObject *self);

runtime/js-compute-runtime/builtins/request-response.cpp

@@ -1217,14 +1217,13 @@ bool Request::url_get(JSContext *cx, unsigned argc, JS::Value *vp) {
 bool Request::version_get(JSContext *cx, unsigned argc, JS::Value *vp) {
   METHOD_HEADER(0)
 
-  fastly_error_t err;
-  fastly_http_version_t version = 0;
-  if (!fastly_http_req_version_get(request_handle(self).handle, &version, &err)) {
-    HANDLE_ERROR(cx, err);
+  auto res = request_handle(self).get_version();
+  if (auto *err = res.to_err()) {
+    HANDLE_ERROR(cx, *err);
     return false;
   }
 
-  args.rval().setInt32(version);
+  args.rval().setInt32(res.unwrap());
   return true;
 }
 
@@ -1753,10 +1752,9 @@ JSObject *Request::create(JSContext *cx, JS::HandleObject requestInstance, JS::H
     is_get_or_head = strcmp(method.get(), "GET") == 0 || strcmp(method.get(), "HEAD") == 0;
 
     JS::SetReservedSlot(request, static_cast<uint32_t>(Slots::Method), JS::StringValue(method_str));
-    fastly_world_string_t method_fastly_str = {method.get(), method_len};
-    fastly_error_t err;
-    if (!fastly_http_req_method_set(request_handle.handle, &method_fastly_str, &err)) {
-      HANDLE_ERROR(cx, err);
+    auto res = request_handle.set_method(std::string_view{method.get(), method_len});
+    if (auto *err = res.to_err()) {
+      HANDLE_ERROR(cx, *err);
       return nullptr;
     }
   }
@@ -2224,14 +2222,13 @@ bool Response::url_get(JSContext *cx, unsigned argc, JS::Value *vp) {
 bool Response::version_get(JSContext *cx, unsigned argc, JS::Value *vp) {
   METHOD_HEADER(0)
 
-  fastly_http_version_t version = 0;
-  fastly_error_t err;
-  if (!fastly_http_resp_version_get(response_handle(self).handle, &version, &err)) {
-    HANDLE_ERROR(cx, err);
+  auto res = response_handle(self).get_version();
+  if (auto *err = res.to_err()) {
+    HANDLE_ERROR(cx, *err);
     return false;
   }
 
-  args.rval().setInt32(version);
+  args.rval().setInt32(res.unwrap());
   return true;
 }
 

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

@@ -4,6 +4,17 @@
 #include "fastly-world/fastly_world.h"
 #include "host_interface/host_api.h"
 
+namespace {
+
+fastly_world_string_t string_view_to_world_string(std::string_view str) {
+  return {
+      .ptr = const_cast<char *>(str.data()),
+      .len = str.size(),
+  };
+}
+
+} // namespace
+
 Result<HttpBody> HttpBody::make() {
   Result<HttpBody> res;
 
@@ -121,7 +132,7 @@ Result<std::optional<std::vector<HostString>>> generic_get_header_values(auto ha
                                                                          std::string_view name) {
   Result<std::optional<std::vector<HostString>>> res;
 
-  fastly_world_string_t hdr{const_cast<char *>(name.data()), name.size()};
+  fastly_world_string_t hdr = string_view_to_world_string(name);
   fastly_option_list_string_t ret;
   fastly_error_t err;
   if (!header_values_get(handle, &hdr, &ret, &err)) {
@@ -151,8 +162,8 @@ template <auto header_op>
 Result<Void> generic_header_op(auto handle, std::string_view name, std::string_view value) {
   Result<Void> res;
 
-  fastly_world_string_t hdr{const_cast<char *>(name.data()), name.size()};
-  fastly_world_string_t val{const_cast<char *>(value.data()), value.size()};
+  fastly_world_string_t hdr = string_view_to_world_string(name);
+  fastly_world_string_t val = string_view_to_world_string(value);
   fastly_error_t err;
   if (!header_op(handle, &hdr, &val, &err)) {
     res.emplace_err(err);
@@ -165,7 +176,7 @@ template <auto remove_header>
 Result<Void> generic_header_remove(auto handle, std::string_view name) {
   Result<Void> res;
 
-  fastly_world_string_t hdr{const_cast<char *>(name.data()), name.size()};
+  fastly_world_string_t hdr = string_view_to_world_string(name);
   fastly_error_t err;
   if (!remove_header(handle, &hdr, &err)) {
     res.emplace_err(err);
@@ -190,8 +201,48 @@ Result<HttpReq> HttpReq::make() {
   return res;
 }
 
+Result<Void> HttpReq::set_method(std::string_view method) {
+  Result<Void> res;
+
+  fastly_error_t err;
+  fastly_world_string_t str = string_view_to_world_string(method);
+  if (!fastly_http_req_method_set(this->handle, &str, &err)) {
+    res.emplace_err(err);
+  }
+
+  return res;
+}
+
+Result<HostString> HttpReq::get_method() const {
+  Result<HostString> res;
+
+  fastly_error_t err;
+  fastly_world_string_t ret;
+  if (!fastly_http_req_method_get(this->handle, &ret, &err)) {
+    res.emplace_err(err);
+  } else {
+    res.emplace(ret);
+  }
+
+  return res;
+}
+
 bool HttpReq::is_valid() const { return this->handle != HttpReq::invalid; }
 
+Result<fastly_http_version_t> HttpReq::get_version() const {
+  Result<fastly_http_version_t> res;
+
+  fastly_error_t err;
+  fastly_http_version_t ret;
+  if (!fastly_http_req_version_get(this->handle, &ret, &err)) {
+    res.emplace_err(err);
+  } else {
+    res.emplace(ret);
+  }
+
+  return res;
+}
+
 Result<std::vector<HostString>> HttpReq::get_header_names() {
   return generic_get_header_names<fastly_http_req_header_names_get>(this->handle);
 }
@@ -228,6 +279,20 @@ Result<HttpResp> HttpResp::make() {
 
 bool HttpResp::is_valid() const { return this->handle != HttpResp::invalid; }
 
+Result<fastly_http_version_t> HttpResp::get_version() const {
+  Result<fastly_http_version_t> res;
+
+  fastly_error_t err;
+  fastly_http_version_t ret;
+  if (!fastly_http_resp_version_get(this->handle, &ret, &err)) {
+    res.emplace_err(err);
+  } else {
+    res.emplace(ret);
+  }
+
+  return res;
+}
+
 Result<std::vector<HostString>> HttpResp::get_header_names() {
   return generic_get_header_names<fastly_http_resp_header_names_get>(this->handle);
 }

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

@@ -133,6 +133,9 @@ class HttpBase {
 
   virtual bool is_valid() const = 0;
 
+  /// Get the http version used for this request.
+  virtual Result<fastly_http_version_t> get_version() const = 0;
+
   virtual Result<std::vector<HostString>> get_header_names() = 0;
   virtual Result<std::optional<std::vector<HostString>>>
   get_header_values(std::string_view name) = 0;
@@ -152,8 +155,18 @@ class HttpReq final : public HttpBase {
 
   static Result<HttpReq> make();
 
+  /// Get the http version used for this request.
+
+  /// Set the request method.
+  Result<Void> set_method(std::string_view method);
+
+  /// Get the request method.
+  Result<HostString> get_method() const;
+
   bool is_valid() const override;
 
+  Result<fastly_http_version_t> get_version() const override;
+
   Result<std::vector<HostString>> get_header_names() override;
   Result<std::optional<std::vector<HostString>>> get_header_values(std::string_view name) override;
   Result<Void> insert_header(std::string_view name, std::string_view value) override;
@@ -174,6 +187,8 @@ class HttpResp final : public HttpBase {
 
   bool is_valid() const override;
 
+  Result<fastly_http_version_t> get_version() const override;
+
   Result<std::vector<HostString>> get_header_names() override;
   Result<std::optional<std::vector<HostString>>> get_header_values(std::string_view name) override;
   Result<Void> insert_header(std::string_view name, std::string_view value) override;

runtime/js-compute-runtime/js-compute-runtime.cpp

@@ -21,6 +21,7 @@
 
 #include "builtins/fetch-event.h"
 #include "core/allocator.h"
+#include "host_interface/host_api.h"
 #include "js-compute-builtins.h"
 #include "third_party/wizer.h"
 #ifdef MEM_STATS
@@ -488,8 +489,7 @@ bool js_compute_runtime_serve(js_compute_runtime_request_t *req) {
   js::ResetMathRandomSeed(cx);
 
   HandleObject fetch_event = builtins::FetchEvent::instance();
-  builtins::FetchEvent::init_request(cx, fetch_event,
-                                     static_cast<fastly_request_t *>(static_cast<void *>(req)));
+  builtins::FetchEvent::init_request(cx, fetch_event, HttpReq{req->f0}, HttpBody{req->f1});
 
   dispatch_fetch_event(cx, fetch_event, &total_compute);