chore: Switch to using the config-store host calls (#809)

Fixes #801

Use the config-store host calls for the ConfigStore api, instead of the deprecated dictionary host calls.

Author: elliottt

runtime/fastly/builtins/config-store.cpp

@@ -8,17 +8,17 @@ using fastly::fastly::FastlyGetErrorMessage;
 
 namespace fastly::config_store {
 
-host_api::Dict ConfigStore::config_store_handle(JSObject *obj) {
+host_api::ConfigStore ConfigStore::config_store_handle(JSObject *obj) {
   JS::Value val = JS::GetReservedSlot(obj, ConfigStore::Slots::Handle);
-  return host_api::Dict(val.toInt32());
+  return host_api::ConfigStore(val.toInt32());
 }
 
 bool ConfigStore::get(JSContext *cx, unsigned argc, JS::Value *vp) {
   METHOD_HEADER(1)
 
   auto key = core::encode(cx, args[0]);
   // If the converted string has a length of 0 then we throw an Error
-  // because Dictionary keys have to be at-least 1 character.
+  // because config-store keys have to be at-least 1 character.
   if (!key || key.len == 0) {
     JS_ReportErrorNumberASCII(cx, FastlyGetErrorMessage, nullptr, JSMSG_CONFIG_STORE_KEY_EMPTY);
     return false;
@@ -73,14 +73,14 @@ bool ConfigStore::constructor(JSContext *cx, unsigned argc, JS::Value *vp) {
   auto name = core::encode(cx, args[0]);
 
   // If the converted string has a length of 0 then we throw an Error
-  // because Dictionary names have to be at-least 1 character.
+  // because config-store names have to be at-least 1 character.
   if (!name) {
     JS_ReportErrorNumberASCII(cx, FastlyGetErrorMessage, 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.
+  // because config-store names have to be less than 255 characters.
   if (name.size() > 255) {
     JS_ReportErrorNumberASCII(cx, FastlyGetErrorMessage, nullptr, JSMSG_CONFIG_STORE_NAME_TOO_LONG);
     return false;
@@ -105,7 +105,7 @@ bool ConfigStore::constructor(JSContext *cx, unsigned argc, JS::Value *vp) {
   }
 
   JS::RootedObject config_store(cx, JS_NewObjectForConstructor(cx, &class_, args));
-  auto open_res = host_api::Dict::open(name);
+  auto open_res = host_api::ConfigStore::open(name);
   if (auto *err = open_res.to_err()) {
     if (host_api::error_is_bad_handle(*err)) {
       JS_ReportErrorNumberASCII(cx, FastlyGetErrorMessage, nullptr,

runtime/fastly/builtins/config-store.h

@@ -21,7 +21,7 @@ class ConfigStore : public builtins::BuiltinImpl<ConfigStore> {
 
   static bool get(JSContext *cx, unsigned argc, JS::Value *vp);
 
-  static host_api::Dict config_store_handle(JSObject *obj);
+  static host_api::ConfigStore config_store_handle(JSObject *obj);
   static bool constructor(JSContext *cx, unsigned argc, JS::Value *vp);
 
   static bool init_class(JSContext *cx, JS::HandleObject global);

runtime/fastly/host-api/component/fastly_world.c

@@ -112,6 +112,14 @@ extern void __wasm_import_fastly_compute_at_edge_dictionary_open(uint8_t *, size
 __attribute__((__import_module__("fastly:compute-at-edge/dictionary"), __import_name__("get")))
 extern void __wasm_import_fastly_compute_at_edge_dictionary_get(int32_t, uint8_t *, size_t, uint8_t *);
 
+// Imported Functions from `fastly:compute-at-edge/config-store`
+
+__attribute__((__import_module__("fastly:compute-at-edge/config-store"), __import_name__("open")))
+extern void __wasm_import_fastly_compute_at_edge_config_store_open(uint8_t *, size_t, uint8_t *);
+
+__attribute__((__import_module__("fastly:compute-at-edge/config-store"), __import_name__("get")))
+extern void __wasm_import_fastly_compute_at_edge_config_store_get(int32_t, uint8_t *, size_t, uint8_t *);
+
 // Imported Functions from `fastly:compute-at-edge/edge-rate-limiter`
 
 __attribute__((__import_module__("fastly:compute-at-edge/edge-rate-limiter"), __import_name__("check-rate")))
@@ -1353,6 +1361,73 @@ bool fastly_compute_at_edge_dictionary_get(fastly_compute_at_edge_dictionary_han
   }
 }
 
+bool fastly_compute_at_edge_config_store_open(fastly_world_string_t *name, fastly_compute_at_edge_config_store_handle_t *ret, fastly_compute_at_edge_config_store_error_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[8];
+  uint8_t *ptr = (uint8_t *) &ret_area;
+  __wasm_import_fastly_compute_at_edge_config_store_open((uint8_t *) (*name).ptr, (*name).len, ptr);
+  fastly_compute_at_edge_config_store_result_handle_error_t result;
+  switch ((int32_t) *((uint8_t*) (ptr + 0))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (uint32_t) (*((int32_t*) (ptr + 4)));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) *((uint8_t*) (ptr + 4));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool fastly_compute_at_edge_config_store_get(fastly_compute_at_edge_config_store_handle_t h, fastly_world_string_t *key, fastly_world_option_string_t *ret, fastly_compute_at_edge_config_store_error_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[16];
+  uint8_t *ptr = (uint8_t *) &ret_area;
+  __wasm_import_fastly_compute_at_edge_config_store_get((int32_t) (h), (uint8_t *) (*key).ptr, (*key).len, ptr);
+  fastly_compute_at_edge_config_store_result_option_string_error_t result;
+  switch ((int32_t) *((uint8_t*) (ptr + 0))) {
+    case 0: {
+      result.is_err = false;
+      fastly_world_option_string_t option;
+      switch ((int32_t) *((uint8_t*) (ptr + 4))) {
+        case 0: {
+          option.is_some = false;
+          break;
+        }
+        case 1: {
+          option.is_some = true;
+          option.val = (fastly_world_string_t) { (uint8_t*)(*((uint8_t **) (ptr + 8))), (*((size_t*) (ptr + 12))) };
+          break;
+        }
+      }
+
+      result.val.ok = option;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) *((uint8_t*) (ptr + 4));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
 bool fastly_compute_at_edge_edge_rate_limiter_check_rate(fastly_world_string_t *rate_counter_name, fastly_world_string_t *entry, uint32_t delta, uint32_t window, uint32_t limit, fastly_world_string_t *penalty_box_name, uint32_t time_to_live, bool *ret, fastly_compute_at_edge_edge_rate_limiter_error_t *err) {
   __attribute__((__aligned__(1)))
   uint8_t ret_area[2];

runtime/fastly/host-api/component/fastly_world.h

@@ -522,6 +522,26 @@ typedef struct {
   } val;
 } fastly_compute_at_edge_dictionary_result_option_string_error_t;
 
+typedef fastly_compute_at_edge_types_error_t fastly_compute_at_edge_config_store_error_t;
+
+typedef uint32_t fastly_compute_at_edge_config_store_handle_t;
+
+typedef struct {
+  bool is_err;
+  union {
+    fastly_compute_at_edge_config_store_handle_t ok;
+    fastly_compute_at_edge_config_store_error_t err;
+  } val;
+} fastly_compute_at_edge_config_store_result_handle_error_t;
+
+typedef struct {
+  bool is_err;
+  union {
+    fastly_world_option_string_t ok;
+    fastly_compute_at_edge_config_store_error_t err;
+  } val;
+} fastly_compute_at_edge_config_store_result_option_string_error_t;
+
 typedef fastly_compute_at_edge_types_error_t fastly_compute_at_edge_edge_rate_limiter_error_t;
 
 typedef struct {
@@ -1296,6 +1316,15 @@ extern bool fastly_compute_at_edge_dictionary_get(fastly_compute_at_edge_diction
                                                   fastly_world_option_string_t *ret,
                                                   fastly_compute_at_edge_dictionary_error_t *err);
 
+// Imported Functions from `fastly:compute-at-edge/config-store`
+extern bool
+fastly_compute_at_edge_config_store_open(fastly_world_string_t *name,
+                                         fastly_compute_at_edge_config_store_handle_t *ret,
+                                         fastly_compute_at_edge_config_store_error_t *err);
+extern bool fastly_compute_at_edge_config_store_get(
+    fastly_compute_at_edge_config_store_handle_t h, fastly_world_string_t *key,
+    fastly_world_option_string_t *ret, fastly_compute_at_edge_config_store_error_t *err);
+
 // Imported Functions from `fastly:compute-at-edge/edge-rate-limiter`
 extern bool fastly_compute_at_edge_edge_rate_limiter_check_rate(
     fastly_world_string_t *rate_counter_name, fastly_world_string_t *entry, uint32_t delta,
@@ -1599,7 +1628,7 @@ fastly_compute_at_edge_secret_store_open(fastly_world_string_t *name,
 extern bool fastly_compute_at_edge_secret_store_get(
     fastly_compute_at_edge_secret_store_store_handle_t store, fastly_world_string_t *key,
     fastly_world_option_secret_handle_t *ret, fastly_compute_at_edge_secret_store_error_t *err);
-bool fastly_compute_at_edge_secret_store_plaintext(
+extern bool fastly_compute_at_edge_secret_store_plaintext(
     fastly_compute_at_edge_secret_store_secret_handle_t secret, fastly_world_option_list_u8_t *ret,
     fastly_compute_at_edge_secret_store_error_t *err);
 extern bool fastly_compute_at_edge_secret_store_from_bytes(

runtime/fastly/host-api/component/fastly_world_adapter.cpp

@@ -785,6 +785,36 @@ bool fastly_compute_at_edge_dictionary_get(fastly_compute_at_edge_dictionary_han
   return true;
 }
 
+bool fastly_compute_at_edge_config_store_open(fastly_world_string_t *name,
+                                              fastly_compute_at_edge_config_store_handle_t *ret,
+                                              fastly_compute_at_edge_types_error_t *err) {
+  return convert_result(
+      fastly::config_store_open(reinterpret_cast<char *>(name->ptr), name->len, ret), err);
+}
+
+bool fastly_compute_at_edge_config_store_get(fastly_compute_at_edge_config_store_handle_t h,
+                                             fastly_world_string_t *key,
+                                             fastly_world_option_string_t *ret,
+                                             fastly_compute_at_edge_types_error_t *err) {
+  ret->val.ptr = static_cast<uint8_t *>(cabi_malloc(CONFIG_STORE_ENTRY_MAX_LEN, 1));
+  if (!convert_result(fastly::config_store_get(h, reinterpret_cast<char *>(key->ptr), key->len,
+                                               reinterpret_cast<char *>(ret->val.ptr),
+                                               CONFIG_STORE_ENTRY_MAX_LEN, &ret->val.len),
+                      err)) {
+    if (*err == FASTLY_COMPUTE_AT_EDGE_TYPES_ERROR_OPTIONAL_NONE) {
+      ret->is_some = false;
+      return true;
+    } else {
+      cabi_free(ret->val.ptr);
+      return false;
+    }
+  }
+  ret->is_some = true;
+  ret->val.ptr = static_cast<uint8_t *>(
+      cabi_realloc(ret->val.ptr, CONFIG_STORE_ENTRY_MAX_LEN, 1, ret->val.len));
+  return true;
+}
+
 bool fastly_compute_at_edge_secret_store_open(
     fastly_world_string_t *name, fastly_compute_at_edge_secret_store_store_handle_t *ret,
     fastly_compute_at_edge_types_error_t *err) {

runtime/fastly/host-api/component/fastly_world_component_type.o

@@ -352,6 +352,15 @@ WASM_IMPORT("fastly_dictionary", "get")
 int dictionary_get(fastly_compute_at_edge_dictionary_handle_t dict_handle, const char *key,
                    size_t key_len, char *value, size_t value_max_len, size_t *nwritten);
 
+// Module fastly_config_store
+WASM_IMPORT("fastly_config_store", "open")
+int config_store_open(const char *name, size_t name_len,
+                      fastly_compute_at_edge_config_store_handle_t *dict_handle_out);
+
+WASM_IMPORT("fastly_config_store", "get")
+int config_store_get(fastly_compute_at_edge_config_store_handle_t dict_handle, const char *key,
+                     size_t key_len, char *value, size_t value_max_len, size_t *nwritten);
+
 // Module fastly_secret_store
 WASM_IMPORT("fastly_secret_store", "open")
 int secret_store_open(const char *name, size_t name_len,

runtime/fastly/host-api/fastly.h

@@ -1252,6 +1252,38 @@ Result<std::optional<HostString>> Dict::get(std::string_view name) {
   return res;
 }
 
+Result<ConfigStore> ConfigStore::open(std::string_view name) {
+  Result<ConfigStore> res;
+
+  auto name_str = string_view_to_world_string(name);
+  fastly_compute_at_edge_config_store_handle_t ret;
+  fastly_compute_at_edge_types_error_t err;
+  if (!fastly_compute_at_edge_config_store_open(&name_str, &ret, &err)) {
+    res.emplace_err(err);
+  } else {
+    res.emplace(ret);
+  }
+
+  return res;
+}
+
+Result<std::optional<HostString>> ConfigStore::get(std::string_view name) {
+  Result<std::optional<HostString>> res;
+
+  auto name_str = string_view_to_world_string(name);
+  fastly_world_option_string_t ret;
+  fastly_compute_at_edge_types_error_t err;
+  if (!fastly_compute_at_edge_config_store_get(this->handle, &name_str, &ret, &err)) {
+    res.emplace_err(err);
+  } else if (ret.is_some) {
+    res.emplace(make_host_string(ret.val));
+  } else {
+    res.emplace(std::nullopt);
+  }
+
+  return res;
+}
+
 Result<ObjectStore> ObjectStore::open(std::string_view name) {
   Result<ObjectStore> res;
 

runtime/fastly/host-api/host_api.cpp

@@ -531,6 +531,18 @@ class Dict final {
   Result<std::optional<HostString>> get(std::string_view name);
 };
 
+class ConfigStore final {
+public:
+  FastlyHandle handle = UINT32_MAX - 1;
+
+  ConfigStore() = default;
+  explicit ConfigStore(FastlyHandle handle) : handle{handle} {}
+
+  static Result<ConfigStore> open(std::string_view name);
+
+  Result<std::optional<HostString>> get(std::string_view name);
+};
+
 class ObjectStore final {
 public:
   FastlyHandle handle = UINT32_MAX - 1;

runtime/fastly/host-api/host_api_fastly.h

@@ -431,6 +431,20 @@ interface dictionary {
   get: func(h: handle, key: string) -> result<option<string>, error>;
 }
 
+/*
+ * Fastly Config Store
+ */
+interface config-store {
+
+  use types.{error};
+
+  type handle = u32;
+
+  open: func(name: string) -> result<handle, error>;
+
+  get: func(h: handle, key: string) -> result<option<string>, error>;
+}
+
 /*
  * Fastly Geo
  */