Add proper syscall versioning

Author: coolreader18

crates/core/src/host/v8/error.rs

@@ -1,6 +1,5 @@
 //! Utilities for error handling when dealing with V8.
 
-use super::de::scratch_buf;
 use super::serialize_to_js;
 use super::string::IntoJsString;
 use crate::{
@@ -46,13 +45,6 @@ impl<'scope, M: IntoJsString> IntoException<'scope> for TypeError<M> {
     }
 }
 
-/// Returns a "module not found" exception to be thrown.
-pub fn module_exception(scope: &mut PinScope<'_, '_>, spec: Local<'_, v8::String>) -> TypeError<String> {
-    let mut buf = scratch_buf::<32>();
-    let spec = spec.to_rust_cow_lossy(scope, &mut buf);
-    TypeError(format!("Could not find module {spec:?}"))
-}
-
 /// A type converting into a JS `RangeError` exception.
 #[derive(Copy, Clone)]
 pub struct RangeError<M>(pub M);

crates/core/src/host/v8/mod.rs

@@ -5,7 +5,9 @@ use self::error::{
 };
 use self::ser::serialize_to_js;
 use self::string::{str_from_ident, IntoJsString};
-use self::syscall::{call_call_reducer, call_describe_module, call_reducer_fun, resolve_sys_module, FnRet};
+use self::syscall::{
+    call_call_reducer, call_describe_module, get_hook, resolve_sys_module, FnRet, HookFunction, ModuleHook,
+};
 use super::module_common::{build_common_module_from_raw, run_describer, ModuleCommon};
 use super::module_host::{CallReducerParams, Module, ModuleInfo, ModuleRuntime};
 use super::UpdateDatabaseResult;
@@ -18,6 +20,7 @@ use crate::host::{ReducerCallResult, Scheduler};
 use crate::module_host_context::{ModuleCreationContext, ModuleCreationContextLimited};
 use crate::replica_context::ReplicaContext;
 use crate::util::asyncify;
+use anyhow::Context as _;
 use core::str;
 use itertools::Either;
 use spacetimedb_datastore::locking_tx_datastore::MutTxId;
@@ -322,12 +325,13 @@ fn startup_instance_worker<'scope>(
     scope: &mut PinScope<'scope, '_>,
     program: Arc<str>,
     module_or_mcc: Either<ModuleCommon, ModuleCreationContextLimited>,
-) -> anyhow::Result<(Local<'scope, Function>, Either<ModuleCommon, ModuleCommon>)> {
+) -> anyhow::Result<(HookFunction<'scope>, Either<ModuleCommon, ModuleCommon>)> {
     // Start-up the user's module.
     eval_user_module_catch(scope, &program).map_err(DescribeError::Setup)?;
 
     // Find the `__call_reducer__` function.
-    let call_reducer_fun = catch_exception(scope, |scope| Ok(call_reducer_fun(scope)?)).map_err(|(e, _)| e)?;
+    let call_reducer_fun =
+        get_hook(scope, ModuleHook::CallReducer).context("The `spacetimedb/server` module was never imported")?;
 
     // If we don't have a module, make one.
     let module_common = match module_or_mcc {
@@ -571,7 +575,7 @@ fn call_reducer<'scope>(
     instance_common: &mut InstanceCommon,
     replica_ctx: &ReplicaContext,
     scope: &mut PinScope<'scope, '_>,
-    fun: Local<'scope, Function>,
+    fun: HookFunction<'_>,
     tx: Option<MutTxId>,
     params: CallReducerParams,
 ) -> (super::ReducerCallResult, bool) {
@@ -648,14 +652,18 @@ fn extract_description<'scope>(
         |a, b, c| log_traceback(replica_ctx, a, b, c),
         || {
             catch_exception(scope, |scope| {
-                let def = call_describe_module(scope)?;
+                let Some(describe_module) = get_hook(scope, ModuleHook::DescribeModule) else {
+                    return Ok(RawModuleDef::V9(Default::default()));
+                };
+                let def = call_describe_module(scope, describe_module)?;
                 Ok(def)
             })
             .map_err(|(e, _)| e)
             .map_err(Into::into)
         },
     )
 }
+
 #[cfg(test)]
 mod test {
     use super::to_value::test::with_scope;
@@ -684,7 +692,7 @@ mod test {
     fn call_call_reducer_works() {
         let call = |code| {
             with_module_catch(code, |scope| {
-                let fun = call_reducer_fun(scope)?;
+                let fun = get_hook(scope, ModuleHook::CallReducer).unwrap();
                 let op = ReducerOp {
                     id: ReducerId(42),
                     name: "foobar",
@@ -762,7 +770,11 @@ js error Uncaught Error: foobar
                 },
             })
         "#;
-        let raw_mod = with_module_catch(code, call_describe_module).map_err(|e| e.to_string());
+        let raw_mod = with_module_catch(code, |scope| {
+            let describe_module = get_hook(scope, ModuleHook::DescribeModule).unwrap();
+            call_describe_module(scope, describe_module)
+        })
+        .map_err(|e| e.to_string());
         assert_eq!(raw_mod, Ok(RawModuleDef::V9(<_>::default())));
     }
 }

crates/core/src/host/v8/string.rs

@@ -36,6 +36,10 @@ impl StringConst {
         v8::String::new_from_onebyte_const(scope, &self.0)
             .expect("`create_external_onebyte_const` should've asserted `.len() < kMaxLength`")
     }
+
+    pub(super) fn as_str(&'static self) -> &'static str {
+        self.0.as_str()
+    }
 }
 
 /// Converts an identifier to a compile-time ASCII string.

crates/core/src/host/v8/syscall/hooks.rs

@@ -0,0 +1,103 @@
+use std::cell::OnceCell;
+use std::rc::Rc;
+
+use enum_map::EnumMap;
+use v8::{Context, Function, Local, Object, PinScope};
+
+use super::AbiVersion;
+use crate::host::v8::de::property;
+use crate::host::v8::error::ExcResult;
+use crate::host::v8::error::Throwable;
+use crate::host::v8::error::TypeError;
+use crate::host::v8::from_value::cast;
+use crate::host::v8::string::StringConst;
+
+pub(super) fn get_hook_function<'s>(
+    scope: &mut PinScope<'s, '_>,
+    hooks_obj: Local<'_, Object>,
+    name: &'static StringConst,
+) -> ExcResult<Local<'s, Function>> {
+    let key = name.string(scope);
+    let object = property(scope, hooks_obj, key)?;
+    cast!(scope, object, Function, "module function hook `{}`", name.as_str()).map_err(|e| e.throw(scope))
+}
+
+pub(super) fn set_hook_slots(
+    scope: &mut PinScope<'_, '_>,
+    abi: AbiVersion,
+    hooks: &[(ModuleHook, Local<'_, Function>)],
+) -> ExcResult<()> {
+    // Make sure to call `set_slot` first, as it creates the annex
+    // and `set_embedder_data` is currently buggy.
+    let ctx = scope.get_current_context();
+    let hooks_info = HooksInfo::get_or_create(&ctx);
+    for &(hook, func) in hooks {
+        hooks_info
+            .register(hook, abi)
+            .map_err(|_| TypeError("cannot call register_hooks multiple times").throw(scope))?;
+        ctx.set_embedder_data(hook.to_slot_index(), func.into());
+    }
+    Ok(())
+}
+
+#[derive(enum_map::Enum, Copy, Clone)]
+pub(in crate::host::v8) enum ModuleHook {
+    DescribeModule,
+    CallReducer,
+}
+
+impl ModuleHook {
+    /// Get the `v8::Context::{get,set}_embedder_data` slot that holds this hook.
+    fn to_slot_index(self) -> i32 {
+        match self {
+            ModuleHook::DescribeModule => 20,
+            ModuleHook::CallReducer => 21,
+        }
+    }
+}
+
+#[derive(Default)]
+struct HooksInfo {
+    abi: OnceCell<AbiVersion>,
+    registered: EnumMap<ModuleHook, OnceCell<()>>,
+}
+
+impl HooksInfo {
+    fn get_or_create(ctx: &Context) -> Rc<Self> {
+        ctx.get_slot().unwrap_or_else(|| {
+            let this = Rc::<Self>::default();
+            ctx.set_slot(this.clone());
+            this
+        })
+    }
+
+    fn register(&self, hook: ModuleHook, abi: AbiVersion) -> Result<(), ()> {
+        if *self.abi.get_or_init(|| abi) != abi {
+            return Err(());
+        }
+        self.registered[hook].set(())
+    }
+
+    fn get(&self, hook: ModuleHook) -> Option<AbiVersion> {
+        self.registered[hook].get().and(self.abi.get().copied())
+    }
+}
+
+#[derive(Copy, Clone)]
+pub(in crate::host::v8) struct HookFunction<'s>(pub AbiVersion, pub Local<'s, Function>);
+
+/// Returns the hook function previously registered in [`register_hooks`].
+pub(in crate::host::v8) fn get_hook<'scope>(
+    scope: &mut PinScope<'scope, '_>,
+    hook: ModuleHook,
+) -> Option<HookFunction<'scope>> {
+    let ctx = scope.get_current_context();
+    let hooks = ctx.get_slot::<HooksInfo>()?;
+
+    let abi_version = hooks.get(hook)?;
+
+    let hooks = ctx
+        .get_embedder_data(scope, hook.to_slot_index())
+        .expect("if `AbiVersion` is set the hook must be set");
+    Some(HookFunction(abi_version, hooks.cast()))
+}

crates/core/src/host/v8/syscall/mod.rs

@@ -0,0 +1,88 @@
+use spacetimedb_lib::RawModuleDef;
+use v8::{callback_scope, Context, FixedArray, Local, Module, PinScope};
+
+use crate::host::v8::de::scratch_buf;
+use crate::host::v8::error::ExcResult;
+use crate::host::v8::error::Throwable;
+use crate::host::v8::error::TypeError;
+use crate::host::wasm_common::module_host_actor::{ReducerOp, ReducerResult};
+
+mod hooks;
+mod v1;
+
+pub(super) use self::hooks::{get_hook, HookFunction, ModuleHook};
+
+/// The return type of a module -> host syscall.
+pub(super) type FnRet<'scope> = ExcResult<Local<'scope, v8::Value>>;
+
+/// The version of the ABI that is exposed to V8.
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub enum AbiVersion {
+    V1,
+}
+
+/// A dependency resolver for the user's module
+/// that will resolve `spacetimedb_sys` to a module that exposes the ABI.
+pub(super) fn resolve_sys_module<'s>(
+    context: Local<'s, Context>,
+    spec: Local<'s, v8::String>,
+    _attrs: Local<'s, FixedArray>,
+    _referrer: Local<'s, Module>,
+) -> Option<Local<'s, Module>> {
+    callback_scope!(unsafe scope, context);
+    resolve_sys_module_inner(scope, spec).ok()
+}
+
+fn resolve_sys_module_inner<'s>(
+    scope: &mut PinScope<'s, '_>,
+    spec: Local<'s, v8::String>,
+) -> ExcResult<Local<'s, Module>> {
+    let scratch = &mut scratch_buf::<32>();
+    let spec = spec.to_rust_cow_lossy(scope, scratch);
+
+    let generic_error = || TypeError(format!("Could not find module {spec:?}"));
+
+    let (module, ver) = spec
+        .strip_prefix("spacetime:")
+        .and_then(|spec| spec.split_once('@'))
+        .ok_or_else(|| generic_error().throw(scope))?;
+
+    let (maj, min) = ver
+        .split_once('.')
+        .and_then(|(maj, min)| Option::zip(maj.parse::<u32>().ok(), min.parse::<u32>().ok()))
+        .ok_or_else(|| TypeError(format!("Invalid version in module spec {spec:?}")).throw(scope))?;
+
+    match module {
+        "sys" => match (maj, min) {
+            (1, 0) => Ok(v1::sys_v1_0(scope)),
+            _ => Err(TypeError(format!(
+                "Could not import {spec:?}, likely because this module was built for a newer version of SpacetimeDB.\n\
+                It requires sys module v{maj}.{min}, but that version is not supported by the database."
+            ))
+            .throw(scope)),
+        },
+        _ => Err(generic_error().throw(scope)),
+    }
+}
+
+pub(super) fn call_call_reducer(
+    scope: &mut PinScope<'_, '_>,
+    fun: HookFunction<'_>,
+    op: ReducerOp<'_>,
+) -> ExcResult<ReducerResult> {
+    let HookFunction(ver, fun) = fun;
+    match ver {
+        AbiVersion::V1 => v1::call_call_reducer(scope, fun, op),
+    }
+}
+
+/// Calls the registered `__describe_module__` function hook.
+pub(super) fn call_describe_module<'scope>(
+    scope: &mut PinScope<'scope, '_>,
+    fun: HookFunction<'_>,
+) -> ExcResult<RawModuleDef> {
+    let HookFunction(ver, fun) = fun;
+    match ver {
+        AbiVersion::V1 => v1::call_describe_module(scope, fun),
+    }
+}