@wasm-oj/server 0.2.0

package/crates/runtime-core/src/lib.rs

@@ -0,0 +1,98 @@
+//! One execution contract for browser and server hosts.
+
+mod capabilities;
+mod compiler;
+mod contract;
+mod deterministic;
+mod error;
+mod filesystem;
+mod filesystem_quota;
+mod go_compiler_session;
+mod interactive;
+mod judge_package;
+mod memory;
+mod meter;
+mod module_imports;
+mod module_policy;
+mod output;
+mod run;
+mod types;
+
+pub use compiler::CompilerToolchain;
+pub use contract::{
+    WASM_OJ_COMPILE_BATCH_SCHEMA, WASM_OJ_CONTRACT_ID, WASM_OJ_CONTRACT_VERSION,
+    WASM_OJ_INTERACTIVE_REQUEST_SCHEMA, WASM_OJ_RUN_REQUEST_SCHEMA,
+};
+pub use error::{RunError, RunErrorCode};
+pub use go_compiler_session::GoCompilerSession;
+pub use interactive::interact;
+pub use judge_package::{
+    JudgePackageError, JudgePackageManifest, JudgePackageValidationOptions,
+    TRUSTED_JUDGE_WASM_MAX_BYTES, TrustedJudgeWasmInfo, ValidatedJudgePackage,
+    WASM_OJ_JUDGE_PACKAGE_MAGIC, WASM_OJ_JUDGE_PACKAGE_MAX_BYTES, WASM_OJ_JUDGE_PACKAGE_SCHEMA,
+    validate_judge_package, validate_judge_package_with_options, validate_trusted_judge_wasm,
+};
+pub use meter::{METER_MODEL, instrument_wasm};
+pub use module_policy::enforce_memory_limit;
+pub use run::run;
+pub use types::{
+    CompilePipelineResponse, CompilePipelineResult, CompileRequest, CompileResponse, CompileResult,
+    CompilerToolchainConfig, DeterminismConfig, ExecutionMetrics, ExecutionTermination,
+    GoCompilerSessionConfig, GoCompilerSessionRequest, GoCompilerSessionResponse,
+    GoCompilerSourceDelta, InteractiveMetrics, InteractiveProcessResult, InteractiveProgram,
+    InteractiveRequest, InteractiveResponse, InteractiveResult, ResourcePolicy, RunFailure,
+    RunRequest, RunResponse, RunResult,
+};
+
+pub fn run_response(request: RunRequest) -> RunResponse {
+    match run(request) {
+        Ok(result) => RunResponse {
+            ok: true,
+            result: Some(result),
+            error: None,
+        },
+        Err(error) => RunResponse {
+            ok: false,
+            result: None,
+            error: Some(RunFailure {
+                code: error.code(),
+                message: error.to_string(),
+            }),
+        },
+    }
+}
+
+pub async fn interactive_response(request: InteractiveRequest) -> InteractiveResponse {
+    match interact(request).await {
+        Ok(result) => InteractiveResponse {
+            ok: true,
+            result: Some(result),
+            error: None,
+        },
+        Err(error) => InteractiveResponse {
+            ok: false,
+            result: None,
+            error: Some(RunFailure {
+                code: error.code(),
+                message: error.to_string(),
+            }),
+        },
+    }
+}
+
+pub(crate) fn wasi_error(error: &wasmer::RuntimeError) -> Option<&wasmer_wasix::WasiError> {
+    let mut current = error;
+    loop {
+        if let Some(wasi) = current.downcast_ref::<wasmer_wasix::WasiError>() {
+            return Some(wasi);
+        }
+        let nested = current.downcast_ref::<wasmer::RuntimeError>()?;
+        if std::ptr::eq(current, nested) {
+            return None;
+        }
+        current = nested;
+    }
+}
+
+#[cfg(all(feature = "web", target_arch = "wasm32"))]
+mod web;

package/crates/runtime-core/src/memory.rs

@@ -0,0 +1,84 @@
+#[cfg(not(target_arch = "wasm32"))]
+mod native {
+    use std::ptr::NonNull;
+    use wasmer::sys::{
+        Tunables,
+        vm::{self, VMMemoryDefinition, VMTableDefinition},
+    };
+    use wasmer::{MemoryError, MemoryStyle, MemoryType, Pages, TableStyle, TableType};
+
+    pub struct LimitingTunables<T: Tunables> {
+        limit: Pages,
+        base: T,
+    }
+
+    impl<T: Tunables> LimitingTunables<T> {
+        pub fn new(base: T, limit: Pages) -> Self {
+            Self { limit, base }
+        }
+
+        fn adjusted(&self, requested: &MemoryType) -> Result<MemoryType, MemoryError> {
+            if requested.minimum > self.limit
+                || requested.maximum.is_some_and(|max| max > self.limit)
+            {
+                return Err(MemoryError::Generic(
+                    "linear memory exceeds the configured hard limit".to_string(),
+                ));
+            }
+            let mut adjusted = *requested;
+            adjusted.maximum = Some(adjusted.maximum.unwrap_or(self.limit).min(self.limit));
+            Ok(adjusted)
+        }
+    }
+
+    impl<T: Tunables> Tunables for LimitingTunables<T> {
+        fn memory_style(&self, memory: &MemoryType) -> MemoryStyle {
+            let adjusted = self.adjusted(memory).unwrap_or(*memory);
+            self.base.memory_style(&adjusted)
+        }
+
+        fn table_style(&self, table: &TableType) -> TableStyle {
+            self.base.table_style(table)
+        }
+
+        fn create_host_memory(
+            &self,
+            ty: &MemoryType,
+            style: &MemoryStyle,
+        ) -> Result<vm::VMMemory, MemoryError> {
+            self.base.create_host_memory(&self.adjusted(ty)?, style)
+        }
+
+        unsafe fn create_vm_memory(
+            &self,
+            ty: &MemoryType,
+            style: &MemoryStyle,
+            definition: NonNull<VMMemoryDefinition>,
+        ) -> Result<vm::VMMemory, MemoryError> {
+            unsafe {
+                self.base
+                    .create_vm_memory(&self.adjusted(ty)?, style, definition)
+            }
+        }
+
+        fn create_host_table(
+            &self,
+            ty: &TableType,
+            style: &TableStyle,
+        ) -> Result<vm::VMTable, String> {
+            self.base.create_host_table(ty, style)
+        }
+
+        unsafe fn create_vm_table(
+            &self,
+            ty: &TableType,
+            style: &TableStyle,
+            definition: NonNull<VMTableDefinition>,
+        ) -> Result<vm::VMTable, String> {
+            unsafe { self.base.create_vm_table(ty, style, definition) }
+        }
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub use native::LimitingTunables;