chore: Finish migrating to the host_api (#539)

Author: elliottt

runtime/js-compute-runtime/builtins/backend.cpp

@@ -712,109 +712,93 @@ bool Backend::isCipherSuiteSupportedByFastly(std::string_view cipherSpec) {
 JS::Result<mozilla::Ok> Backend::register_dynamic_backend(JSContext *cx, JS::HandleObject backend) {
   MOZ_ASSERT(is_instance(backend));
 
-  fastly_world_string_t name_str;
   JS::RootedString name(cx, JS::GetReservedSlot(backend, Backend::Slots::Name).toString());
-  JS::UniqueChars nameChars = encode(cx, name, &name_str.len);
-  name_str.ptr = nameChars.get();
+  size_t name_len;
+  JS::UniqueChars nameChars = encode(cx, name, &name_len);
+  std::string_view name_str{nameChars.get(), name_len};
 
-  fastly_world_string_t target_str;
   JS::RootedString target(cx, JS::GetReservedSlot(backend, Backend::Slots::Target).toString());
-  JS::UniqueChars targetChars = encode(cx, target, &target_str.len);
-  target_str.ptr = targetChars.get();
+  size_t target_len;
+  JS::UniqueChars targetChars = encode(cx, target, &target_len);
+  std::string_view target_str{targetChars.get(), target_len};
 
-  fastly_dynamic_backend_config_t backend_config;
-  std::memset(&backend_config, 0, sizeof(backend_config));
+  BackendConfig backend_config;
 
-  std::string hostOverride;
   auto hostOverrideSlot = JS::GetReservedSlot(backend, Backend::Slots::HostOverride);
-  if ((backend_config.host_override.is_some = !hostOverrideSlot.isNullOrUndefined())) {
+  if (!hostOverrideSlot.isNullOrUndefined()) {
     JS::RootedString hostOverrideString(cx, hostOverrideSlot.toString());
     size_t hostOverride_len;
     JS::UniqueChars hostOverrideChars = encode(cx, hostOverrideString, &hostOverride_len);
-    hostOverride = std::string(hostOverrideChars.get(), hostOverride_len);
-    backend_config.host_override.val.ptr = const_cast<char *>(hostOverride.c_str());
-    backend_config.host_override.val.len = hostOverride.length();
+    backend_config.host_override.emplace(std::move(hostOverrideChars), hostOverride_len);
   }
 
   auto connectTimeoutSlot = JS::GetReservedSlot(backend, Backend::Slots::ConnectTimeout);
-  if ((backend_config.connect_timeout.is_some = !connectTimeoutSlot.isNullOrUndefined())) {
-    backend_config.connect_timeout.val = connectTimeoutSlot.toInt32();
+  if (!connectTimeoutSlot.isNullOrUndefined()) {
+    backend_config.connect_timeout = connectTimeoutSlot.toInt32();
   }
 
   auto firstByteTimeoutSlot = JS::GetReservedSlot(backend, Backend::Slots::FirstByteTimeout);
-  if ((backend_config.first_byte_timeout.is_some = !firstByteTimeoutSlot.isNullOrUndefined())) {
-    backend_config.first_byte_timeout.val = firstByteTimeoutSlot.toInt32();
+  if (!firstByteTimeoutSlot.isNullOrUndefined()) {
+    backend_config.first_byte_timeout = firstByteTimeoutSlot.toInt32();
   }
 
   auto betweenBytesTimeoutSlot = JS::GetReservedSlot(backend, Backend::Slots::BetweenBytesTimeout);
-  if ((backend_config.between_bytes_timeout.is_some =
-           !betweenBytesTimeoutSlot.isNullOrUndefined())) {
-    backend_config.between_bytes_timeout.val = betweenBytesTimeoutSlot.toInt32();
+  if (!betweenBytesTimeoutSlot.isNullOrUndefined()) {
+    backend_config.between_bytes_timeout = betweenBytesTimeoutSlot.toInt32();
   }
 
   auto useSslSlot = JS::GetReservedSlot(backend, Backend::Slots::UseSsl);
-  if ((backend_config.use_ssl.is_some = !useSslSlot.isNullOrUndefined())) {
-    backend_config.use_ssl.val = useSslSlot.toBoolean();
+  if (!useSslSlot.isNullOrUndefined()) {
+    backend_config.use_ssl = useSslSlot.toBoolean();
   }
 
   auto tlsMinVersion = JS::GetReservedSlot(backend, Backend::Slots::TlsMinVersion);
-  if ((backend_config.ssl_min_version.is_some = !tlsMinVersion.isNullOrUndefined())) {
-    backend_config.ssl_min_version.val = (int8_t)tlsMinVersion.toInt32();
+  if (!tlsMinVersion.isNullOrUndefined()) {
+    backend_config.ssl_min_version = static_cast<uint8_t>(tlsMinVersion.toInt32());
   }
 
   auto tlsMaxVersion = JS::GetReservedSlot(backend, Backend::Slots::TlsMaxVersion);
-  if ((backend_config.ssl_max_version.is_some = !tlsMaxVersion.isNullOrUndefined())) {
-    backend_config.ssl_max_version.val = (int8_t)tlsMaxVersion.toInt32();
+  if (!tlsMaxVersion.isNullOrUndefined()) {
+    backend_config.ssl_max_version = static_cast<int8_t>(tlsMaxVersion.toInt32());
   }
 
-  std::string certificateHostname;
   auto certificateHostnameSlot = JS::GetReservedSlot(backend, Backend::Slots::CertificateHostname);
-  if ((backend_config.cert_hostname.is_some = !certificateHostnameSlot.isNullOrUndefined())) {
+  if (!certificateHostnameSlot.isNullOrUndefined()) {
     JS::RootedString certificateHostnameString(cx, certificateHostnameSlot.toString());
     size_t certificateHostname_len;
     JS::UniqueChars certificateHostnameChars =
         encode(cx, certificateHostnameString, &certificateHostname_len);
-    certificateHostname = std::string(certificateHostnameChars.get(), certificateHostname_len);
-    backend_config.cert_hostname.val.ptr = const_cast<char *>(certificateHostname.c_str());
-    backend_config.cert_hostname.val.len = certificateHostname.length();
+    backend_config.cert_hostname.emplace(std::move(certificateHostnameChars),
+                                         certificateHostname_len);
   }
 
-  std::string caCertificate;
   auto caCertificateSlot = JS::GetReservedSlot(backend, Backend::Slots::CaCertificate);
-  if ((backend_config.ca_cert.is_some = !caCertificateSlot.isNullOrUndefined())) {
+  if (!caCertificateSlot.isNullOrUndefined()) {
     JS::RootedString caCertificateString(cx, caCertificateSlot.toString());
     size_t caCertificate_len;
     JS::UniqueChars caCertificateChars = encode(cx, caCertificateString, &caCertificate_len);
-    caCertificate = std::string(caCertificateChars.get(), caCertificate_len);
-    backend_config.ca_cert.val.ptr = const_cast<char *>(caCertificate.c_str());
-    backend_config.ca_cert.val.len = caCertificate.length();
+    backend_config.ca_cert.emplace(std::move(caCertificateChars), caCertificate_len);
   }
 
-  std::string ciphers;
   auto ciphersSlot = JS::GetReservedSlot(backend, Backend::Slots::Ciphers);
-  if ((backend_config.ciphers.is_some = !ciphersSlot.isNullOrUndefined())) {
+  if (!ciphersSlot.isNullOrUndefined()) {
     JS::RootedString ciphersString(cx, ciphersSlot.toString());
     size_t ciphers_len;
     JS::UniqueChars ciphersChars = encode(cx, ciphersString, &ciphers_len);
-    ciphers = std::string(ciphersChars.get(), ciphers_len);
-    backend_config.ciphers.val.ptr = const_cast<char *>(ciphers.c_str());
-    backend_config.ciphers.val.len = ciphers.length();
+    backend_config.ciphers.emplace(std::move(ciphersChars), ciphers_len);
   }
 
-  std::string sniHostname;
   auto sniHostnameSlot = JS::GetReservedSlot(backend, Backend::Slots::SniHostname);
-  if ((backend_config.sni_hostname.is_some = !sniHostnameSlot.isNullOrUndefined())) {
+  if (!sniHostnameSlot.isNullOrUndefined()) {
     JS::RootedString sniHostnameString(cx, sniHostnameSlot.toString());
     size_t sniHostname_len;
     JS::UniqueChars sniHostnameChars = encode(cx, sniHostnameString, &sniHostname_len);
-    sniHostname = std::string(sniHostnameChars.get(), sniHostname_len);
-    backend_config.sni_hostname.val.ptr = const_cast<char *>(sniHostname.c_str());
-    backend_config.sni_hostname.val.len = sniHostname.length();
+    backend_config.sni_hostname.emplace(std::move(sniHostnameChars), sniHostname_len);
   }
 
-  fastly_error_t err;
-  if (!fastly_http_req_register_dynamic_backend(&name_str, &target_str, &backend_config, &err)) {
-    HANDLE_ERROR(cx, err);
+  auto res = HttpReq::register_dynamic_backend(name_str, target_str, backend_config);
+  if (auto *err = res.to_err()) {
+    HANDLE_ERROR(cx, *err);
     return JS::Result<mozilla::Ok>(JS::Error());
   }
   return mozilla::Ok();

runtime/js-compute-runtime/builtins/client-info.cpp

@@ -1,6 +1,6 @@
 #include "builtins/client-info.h"
 #include "core/geo_ip.h"
-#include "host_interface/host_call.h"
+#include "host_interface/host_api.h"
 
 #include "js/JSON.h"
 #include <arpa/inet.h>
@@ -20,45 +20,43 @@ JSString *geo_info(JSObject *obj) {
 }
 
 static JSString *retrieve_address(JSContext *cx, JS::HandleObject self) {
-  JS::RootedString address(cx);
-
-  fastly_world_list_u8_t octets;
-  fastly_error_t err;
-  if (!fastly_http_req_downstream_client_ip_addr(&octets, &err)) {
-    HANDLE_ERROR(cx, err);
+  auto res = HttpReq::downstream_client_ip_addr();
+  if (auto *err = res.to_err()) {
+    HANDLE_ERROR(cx, *err);
     return nullptr;
   }
 
+  auto octets = std::move(res.unwrap());
+  char address_chars[INET6_ADDRSTRLEN];
+  int addr_family = 0;
+  socklen_t size = 0;
+
   switch (octets.len) {
   case 0: {
     // No address to be had, leave `address` as a nullptr.
-    JS_free(cx, octets.ptr);
     break;
   }
   case 4: {
-    char address_chars[INET_ADDRSTRLEN];
-    // TODO: do we need to do error handling here, or can we depend on the
-    // host giving us a valid address?
-    inet_ntop(AF_INET, octets.ptr, address_chars, INET_ADDRSTRLEN);
-    address = JS_NewStringCopyZ(cx, address_chars);
-    JS_free(cx, octets.ptr);
-    if (!address)
-      return nullptr;
-
+    addr_family = AF_INET;
+    size = INET_ADDRSTRLEN;
     break;
   }
   case 16: {
-    char address_chars[INET6_ADDRSTRLEN];
+    addr_family = AF_INET6;
+    size = INET6_ADDRSTRLEN;
+    break;
+  }
+  }
+
+  JS::RootedString address(cx);
+  if (octets.len > 0) {
     // TODO: do we need to do error handling here, or can we depend on the
     // host giving us a valid address?
-    inet_ntop(AF_INET6, octets.ptr, address_chars, INET6_ADDRSTRLEN);
+    inet_ntop(addr_family, octets.begin(), address_chars, size);
     address = JS_NewStringCopyZ(cx, address_chars);
-    JS_free(cx, octets.ptr);
-    if (!address)
+    if (!address) {
       return nullptr;
-
-    break;
-  }
+    }
   }
 
   JS::SetReservedSlot(self, static_cast<uint32_t>(ClientInfo::Slots::Address),

runtime/js-compute-runtime/builtins/config-store.cpp

@@ -1,50 +1,50 @@
 #include "config-store.h"
-#include "host_interface/host_call.h"
+#include "host_interface/host_api.h"
 
 namespace builtins {
 
-fastly_dictionary_handle_t ConfigStore::config_store_handle(JSObject *obj) {
+Dict ConfigStore::config_store_handle(JSObject *obj) {
   JS::Value val = JS::GetReservedSlot(obj, ConfigStore::Slots::Handle);
-  return static_cast<fastly_dictionary_handle_t>(val.toInt32());
+  return Dict{static_cast<fastly_dictionary_handle_t>(val.toInt32())};
 }
 
 bool ConfigStore::get(JSContext *cx, unsigned argc, JS::Value *vp) {
   METHOD_HEADER(1)
 
-  fastly_world_string_t key_str;
-  JS::UniqueChars key = encode(cx, args[0], &key_str.len);
+  size_t key_len;
+  JS::UniqueChars key = encode(cx, args[0], &key_len);
   // If the converted string has a length of 0 then we throw an Error
   // because Dictionary keys have to be at-least 1 character.
-  if (!key || key_str.len == 0) {
+  if (!key || key_len == 0) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_CONFIG_STORE_KEY_EMPTY);
     return false;
   }
-  key_str.ptr = key.get();
 
   // key has to be less than 256
-  if (key_str.len > 255) {
+  if (key_len > 255) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_CONFIG_STORE_KEY_TOO_LONG);
     return false;
   }
 
-  fastly_world_option_string_t ret;
-  fastly_error_t err;
+  std::string_view key_str{key.get(), key_len};
   // Ensure that we throw an exception for all unexpected host errors.
-  if (!fastly_dictionary_get(ConfigStore::config_store_handle(self), &key_str, &ret, &err)) {
-    HANDLE_ERROR(cx, err);
+  auto get_res = ConfigStore::config_store_handle(self).get(key_str);
+  if (auto *err = get_res.to_err()) {
+    HANDLE_ERROR(cx, *err);
     return false;
   }
 
   // None indicates the key wasn't found, so we return null.
-  if (!ret.is_some) {
+  auto ret = std::move(get_res.unwrap());
+  if (!ret.has_value()) {
     args.rval().setNull();
     return true;
   }
 
-  JS::RootedString text(cx, JS_NewStringCopyUTF8N(cx, JS::UTF8Chars(ret.val.ptr, ret.val.len)));
-  JS_free(cx, ret.val.ptr);
-  if (!text)
+  JS::RootedString text(cx, JS_NewStringCopyUTF8N(cx, JS::UTF8Chars(ret->begin(), ret->size())));
+  if (!text) {
     return false;
+  }
 
   args.rval().setString(text);
   return true;
@@ -66,26 +66,24 @@ bool ConfigStore::constructor(JSContext *cx, unsigned argc, JS::Value *vp) {
   REQUEST_HANDLER_ONLY("The ConfigStore builtin");
   CTOR_HEADER("ConfigStore", 1);
 
-  fastly_world_string_t name_str;
-  JS::UniqueChars name_chars = encode(cx, args[0], &name_str.len);
-  name_str.ptr = name_chars.get();
+  size_t name_len;
+  JS::UniqueChars name_chars = encode(cx, args[0], &name_len);
+  std::string_view name{name_chars.get(), name_len};
 
   // If the converted string has a length of 0 then we throw an Error
   // because Dictionary names have to be at-least 1 character.
-  if (name_str.len == 0) {
+  if (name.empty()) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_CONFIG_STORE_NAME_EMPTY);
     return false;
   }
 
   // If the converted string has a length of more than 255 then we throw an Error
   // because Dictionary names have to be less than 255 characters.
-  if (name_str.len > 255) {
+  if (name.size() > 255) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_CONFIG_STORE_NAME_TOO_LONG);
     return false;
   }
 
-  std::string_view name(name_str.ptr, name_str.len);
-
   // Name must start with ascii alphabetical and contain only ascii alphanumeric, underscore, and
   // whitespace
   if (!std::isalpha(name.front())) {
@@ -105,20 +103,20 @@ bool ConfigStore::constructor(JSContext *cx, unsigned argc, JS::Value *vp) {
   }
 
   JS::RootedObject config_store(cx, JS_NewObjectForConstructor(cx, &class_, args));
-  fastly_dictionary_handle_t dict_handle = INVALID_HANDLE;
-  fastly_error_t err;
-  if (!fastly_dictionary_open(&name_str, &dict_handle, &err)) {
-    if (err == FASTLY_ERROR_BAD_HANDLE) {
+  auto open_res = Dict::open(name);
+  if (auto *err = open_res.to_err()) {
+    if (*err == FASTLY_ERROR_BAD_HANDLE) {
       JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_CONFIG_STORE_DOES_NOT_EXIST,
                                 name.data());
       return false;
     } else {
-      HANDLE_ERROR(cx, err);
+      HANDLE_ERROR(cx, *err);
       return false;
     }
   }
 
-  JS::SetReservedSlot(config_store, ConfigStore::Slots::Handle, JS::Int32Value(dict_handle));
+  JS::SetReservedSlot(config_store, ConfigStore::Slots::Handle,
+                      JS::Int32Value(open_res.unwrap().handle));
   if (!config_store)
     return false;
   args.rval().setObject(*config_store);

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

@@ -2,6 +2,7 @@
 #define JS_COMPUTE_RUNTIME_CONFIG_STORE_H
 
 #include "builtin.h"
+#include "host_interface/host_api.h"
 #include "js-compute-builtins.h"
 
 namespace builtins {
@@ -20,7 +21,7 @@ class ConfigStore : public BuiltinImpl<ConfigStore> {
 
   static bool get(JSContext *cx, unsigned argc, JS::Value *vp);
 
-  static fastly_dictionary_handle_t config_store_handle(JSObject *obj);
+  static Dict config_store_handle(JSObject *obj);
   static bool constructor(JSContext *cx, unsigned argc, JS::Value *vp);
 
   static bool init_class(JSContext *cx, JS::HandleObject global);