add V8Runtime skeleton + HostType::Js

Author: Centril

crates/core/src/db/datastore/system_tables.rs

@@ -816,12 +816,15 @@ pub struct ModuleKind(u8);
 impl ModuleKind {
     /// The [`ModuleKind`] of WASM-based modules.
     pub const WASM: ModuleKind = ModuleKind(0);
+    /// The [`ModuleKind`] of JS modules.
+    pub const JS: ModuleKind = ModuleKind(1);
 }
 
 impl From<crate::messages::control_db::HostType> for ModuleKind {
     fn from(host_type: crate::messages::control_db::HostType) -> Self {
         match host_type {
             crate::messages::control_db::HostType::Wasm => Self::WASM,
+            crate::messages::control_db::HostType::Js => Self::JS,
         }
     }
 }

crates/core/src/host/host_controller.rs

@@ -9,6 +9,7 @@ use crate::db::db_metrics::DB_METRICS;
 use crate::db::relational_db::{self, DiskSizeFn, RelationalDB, Txdata};
 use crate::db::{self, spawn_tx_metrics_recorder};
 use crate::energy::{EnergyMonitor, EnergyQuanta, NullEnergyMonitor};
+use crate::host::v8::V8Runtime;
 use crate::messages::control_db::{Database, HostType};
 use crate::module_host_context::ModuleCreationContext;
 use crate::replica_context::ReplicaContext;
@@ -106,12 +107,14 @@ pub struct HostController {
 
 struct HostRuntimes {
     wasmtime: WasmtimeRuntime,
+    v8: V8Runtime,
 }
 
 impl HostRuntimes {
     fn new(data_dir: Option<&ServerDataDir>) -> Arc<Self> {
         let wasmtime = WasmtimeRuntime::new(data_dir);
-        Arc::new(Self { wasmtime })
+        let v8 = V8Runtime::new();
+        Arc::new(Self { wasmtime, v8 })
     }
 }
 
@@ -671,19 +674,25 @@ async fn make_module_host(
     //       threads, but those aren't for computation. Also, wasmtime uses rayon
     //       to run compilation in parallel, so it'll need to run stuff in rayon anyway.
     asyncify(move || {
+        let mcc = ModuleCreationContext {
+            replica_ctx,
+            scheduler,
+            program: &program,
+            energy_monitor,
+        };
+
+        let start = Instant::now();
         let module_host = match host_type {
             HostType::Wasm => {
-                let mcc = ModuleCreationContext {
-                    replica_ctx,
-                    scheduler,
-                    program: &program,
-                    energy_monitor,
-                };
-                let start = Instant::now();
                 let actor = runtimes.wasmtime.make_actor(mcc)?;
                 trace!("wasmtime::make_actor blocked for {:?}", start.elapsed());
                 ModuleHost::new(actor, unregister, core)
             }
+            HostType::Js => {
+                let actor = runtimes.v8.make_actor(mcc)?;
+                trace!("v8::make_actor blocked for {:?}", start.elapsed());
+                ModuleHost::new(actor, unregister, core)
+            }
         };
         Ok((program, module_host))
     })

crates/core/src/host/mod.rs

@@ -16,8 +16,10 @@ mod host_controller;
 pub mod module_host;
 pub mod scheduler;
 pub mod wasmtime;
+
 // Visible for integration testing.
 pub mod instance_env;
+pub mod v8; // only pub for testing
 mod wasm_common;
 
 pub use disk_storage::DiskStorage;

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

@@ -0,0 +1,84 @@
+use crate::{
+    db::datastore::locking_tx_datastore::MutTxId,
+    host::{
+        module_host::{DynModule, Module, ModuleInfo, ModuleInstance},
+        Scheduler,
+    },
+    module_host_context::ModuleCreationContext,
+    replica_context::ReplicaContext,
+};
+use anyhow::anyhow;
+use std::sync::{Arc, Once};
+
+use super::module_host::CallReducerParams;
+
+pub struct V8Runtime {
+    _priv: (),
+}
+
+impl V8Runtime {
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Self {
+        static V8_INIT: Once = Once::new();
+        V8_INIT.call_once(|| {
+            // TODO
+        });
+
+        Self { _priv: () }
+    }
+
+    pub fn make_actor(&self, _: ModuleCreationContext<'_>) -> anyhow::Result<impl Module> {
+        Err::<JsModule, _>(anyhow!("v8_todo"))
+    }
+}
+
+#[derive(Clone)]
+struct JsModule;
+
+impl DynModule for JsModule {
+    fn replica_ctx(&self) -> &Arc<ReplicaContext> {
+        todo!()
+    }
+
+    fn scheduler(&self) -> &Scheduler {
+        todo!()
+    }
+}
+
+impl Module for JsModule {
+    type Instance = JsInstance;
+
+    type InitialInstances<'a> = std::iter::Empty<JsInstance>;
+
+    fn initial_instances(&mut self) -> Self::InitialInstances<'_> {
+        std::iter::empty()
+    }
+
+    fn info(&self) -> Arc<ModuleInfo> {
+        todo!()
+    }
+
+    fn create_instance(&self) -> Self::Instance {
+        todo!()
+    }
+}
+
+struct JsInstance;
+
+impl ModuleInstance for JsInstance {
+    fn trapped(&self) -> bool {
+        todo!()
+    }
+
+    fn update_database(
+        &mut self,
+        _program: crate::db::datastore::traits::Program,
+        _old_module_info: Arc<ModuleInfo>,
+    ) -> anyhow::Result<super::UpdateDatabaseResult> {
+        todo!()
+    }
+
+    fn call_reducer(&mut self, _tx: Option<MutTxId>, _params: CallReducerParams) -> super::ReducerCallResult {
+        todo!()
+    }
+}

crates/core/src/messages/control_db.rs

@@ -74,4 +74,5 @@ pub struct NodeStatus {
 #[repr(i32)]
 pub enum HostType {
     Wasm = 0,
+    Js,
 }

crates/standalone/src/subcommands/extract_schema.rs

@@ -22,12 +22,14 @@ struct Args {
 #[derive(clap::ValueEnum, Copy, Clone)]
 enum HostType {
     Wasm,
+    Js,
 }
 
 impl From<HostType> for control_db::HostType {
     fn from(x: HostType) -> Self {
         match x {
             HostType::Wasm => control_db::HostType::Wasm,
+            HostType::Js => control_db::HostType::Js,
         }
     }
 }