feat: epoch-based interruption

Closes #15.

Author: crepererum

guests/evil/src/common.rs

@@ -0,0 +1,21 @@
+//! Methods used by multiple payloads.
+
+use std::sync::Arc;
+
+use datafusion_common::Result as DataFusionResult;
+use datafusion_expr::ScalarUDFImpl;
+
+/// Return empty root file system.
+///
+/// This always returns [`None`] because the example does not need any files.
+pub(crate) fn root_empty() -> Option<Vec<u8>> {
+    None
+}
+
+/// Returns empty list of UDFs.
+///
+/// The passed `source` is ignored.
+#[expect(clippy::unnecessary_wraps, reason = "public API through export! macro")]
+pub(crate) fn udfs_empty(_source: String) -> DataFusionResult<Vec<Arc<dyn ScalarUDFImpl>>> {
+    Ok(vec![])
+}

guests/evil/src/lib.rs

@@ -7,8 +7,10 @@ use datafusion_common::Result as DataFusionResult;
 use datafusion_expr::ScalarUDFImpl;
 use datafusion_udf_wasm_guest::export;
 
+mod common;
 mod root;
 mod runtime;
+mod spin;
 
 /// Method that returns the root filesystem.
 type RootFn = Box<dyn Fn() -> Option<Vec<u8>>>;
@@ -37,6 +39,34 @@ impl Evil {
                 root: Box::new(runtime::root),
                 udfs: Box::new(runtime::udfs),
             },
+            "spin::root" => Self {
+                root: Box::new(spin::root::root),
+                udfs: Box::new(common::udfs_empty),
+            },
+            "spin::udf_invoke" => Self {
+                root: Box::new(common::root_empty),
+                udfs: Box::new(spin::udf_invoke::udfs),
+            },
+            "spin::udf_name" => Self {
+                root: Box::new(common::root_empty),
+                udfs: Box::new(spin::udf_name::udfs),
+            },
+            "spin::udf_return_type_exact" => Self {
+                root: Box::new(common::root_empty),
+                udfs: Box::new(spin::udf_return_type_exact::udfs),
+            },
+            "spin::udf_return_type_other" => Self {
+                root: Box::new(common::root_empty),
+                udfs: Box::new(spin::udf_return_type_other::udfs),
+            },
+            "spin::udf_signature" => Self {
+                root: Box::new(common::root_empty),
+                udfs: Box::new(spin::udf_signature::udfs),
+            },
+            "spin::udfs" => Self {
+                root: Box::new(common::root_empty),
+                udfs: Box::new(spin::udfs::udfs),
+            },
             other => panic!("unknown evil: {other}"),
         }
     }

guests/evil/src/spin/mod.rs

@@ -0,0 +1,26 @@
+//! Payloads that lock the CPU during various operations.
+
+use std::hash::{DefaultHasher, Hash, Hasher};
+
+pub(crate) mod root;
+pub(crate) mod udf_invoke;
+pub(crate) mod udf_name;
+pub(crate) mod udf_return_type_exact;
+pub(crate) mod udf_return_type_other;
+pub(crate) mod udf_signature;
+pub(crate) mod udfs;
+
+/// Method that locks the CPU forever.
+fn spin() {
+    // Use a non-predictable costly loop.
+    //
+    // Practically `u64::MAX` will never come to an end.
+    let mut hasher = DefaultHasher::new();
+    for i in 0..u64::MAX {
+        i.hash(&mut hasher);
+    }
+    let result = hasher.finish();
+
+    // side-effect to prevent the compiler from removing our code
+    println!("hash: {result}");
+}

guests/evil/src/spin/root.rs

@@ -0,0 +1,10 @@
+//! Payload that spins while retrieving the root filesystem.
+use crate::spin::spin;
+
+/// Return root file system.
+///
+/// This always returns [`None`] because the example does not need any files.
+pub(crate) fn root() -> Option<Vec<u8>> {
+    spin();
+    None
+}

guests/evil/src/spin/udf_invoke.rs

@@ -0,0 +1,57 @@
+//! UDF that spins forever when [`ScalarUDFImpl::invoke_with_args`] is called.
+use std::sync::Arc;
+
+use arrow::datatypes::DataType;
+use datafusion_common::{Result as DataFusionResult, ScalarValue};
+use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl, Signature, Volatility};
+
+use crate::spin::spin;
+
+/// UDF that spins.
+#[derive(Debug)]
+struct SpinUdf {
+    /// Signature of the UDF.
+    ///
+    /// We store this here because [`ScalarUDFImpl::signature`] requires us to return a reference.
+    signature: Signature,
+}
+
+impl SpinUdf {
+    /// Create new  UDF.
+    fn new() -> Self {
+        Self {
+            signature: Signature::uniform(0, vec![], Volatility::Immutable),
+        }
+    }
+}
+
+impl ScalarUDFImpl for SpinUdf {
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
+    fn name(&self) -> &str {
+        "spin"
+    }
+
+    fn signature(&self) -> &Signature {
+        &self.signature
+    }
+
+    fn return_type(&self, _arg_types: &[DataType]) -> DataFusionResult<DataType> {
+        Ok(DataType::Null)
+    }
+
+    fn invoke_with_args(&self, _args: ScalarFunctionArgs) -> DataFusionResult<ColumnarValue> {
+        spin();
+        Ok(ColumnarValue::Scalar(ScalarValue::Null))
+    }
+}
+
+/// Returns our evil UDFs.
+///
+/// The passed `source` is ignored.
+#[expect(clippy::unnecessary_wraps, reason = "public API through export! macro")]
+pub(crate) fn udfs(_source: String) -> DataFusionResult<Vec<Arc<dyn ScalarUDFImpl>>> {
+    Ok(vec![Arc::new(SpinUdf::new())])
+}

guests/evil/src/spin/udf_name.rs

@@ -0,0 +1,57 @@
+//! UDF that spins forever when [`ScalarUDFImpl::name`] is called.
+use std::sync::Arc;
+
+use arrow::datatypes::DataType;
+use datafusion_common::{Result as DataFusionResult, ScalarValue};
+use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl, Signature, Volatility};
+
+use crate::spin::spin;
+
+/// UDF that spins.
+#[derive(Debug)]
+struct SpinUdf {
+    /// Signature of the UDF.
+    ///
+    /// We store this here because [`ScalarUDFImpl::signature`] requires us to return a reference.
+    signature: Signature,
+}
+
+impl SpinUdf {
+    /// Create new  UDF.
+    fn new() -> Self {
+        Self {
+            signature: Signature::uniform(0, vec![], Volatility::Immutable),
+        }
+    }
+}
+
+impl ScalarUDFImpl for SpinUdf {
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
+    fn name(&self) -> &str {
+        spin();
+        "spin"
+    }
+
+    fn signature(&self) -> &Signature {
+        &self.signature
+    }
+
+    fn return_type(&self, _arg_types: &[DataType]) -> DataFusionResult<DataType> {
+        Ok(DataType::Null)
+    }
+
+    fn invoke_with_args(&self, _args: ScalarFunctionArgs) -> DataFusionResult<ColumnarValue> {
+        Ok(ColumnarValue::Scalar(ScalarValue::Null))
+    }
+}
+
+/// Returns our evil UDFs.
+///
+/// The passed `source` is ignored.
+#[expect(clippy::unnecessary_wraps, reason = "public API through export! macro")]
+pub(crate) fn udfs(_source: String) -> DataFusionResult<Vec<Arc<dyn ScalarUDFImpl>>> {
+    Ok(vec![Arc::new(SpinUdf::new())])
+}

guests/evil/src/spin/udf_return_type_exact.rs

@@ -0,0 +1,57 @@
+//! UDF that spins forever when [`ScalarUDFImpl::return_type`] is called.
+use std::sync::Arc;
+
+use arrow::datatypes::DataType;
+use datafusion_common::{Result as DataFusionResult, ScalarValue};
+use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl, Signature, Volatility};
+
+use crate::spin::spin;
+
+/// UDF that spins.
+#[derive(Debug)]
+struct SpinUdf {
+    /// Signature of the UDF.
+    ///
+    /// We store this here because [`ScalarUDFImpl::signature`] requires us to return a reference.
+    signature: Signature,
+}
+
+impl SpinUdf {
+    /// Create new  UDF.
+    fn new() -> Self {
+        Self {
+            signature: Signature::exact(vec![], Volatility::Immutable),
+        }
+    }
+}
+
+impl ScalarUDFImpl for SpinUdf {
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
+    fn name(&self) -> &str {
+        "spin"
+    }
+
+    fn signature(&self) -> &Signature {
+        &self.signature
+    }
+
+    fn return_type(&self, _arg_types: &[DataType]) -> DataFusionResult<DataType> {
+        spin();
+        Ok(DataType::Null)
+    }
+
+    fn invoke_with_args(&self, _args: ScalarFunctionArgs) -> DataFusionResult<ColumnarValue> {
+        Ok(ColumnarValue::Scalar(ScalarValue::Null))
+    }
+}
+
+/// Returns our evil UDFs.
+///
+/// The passed `source` is ignored.
+#[expect(clippy::unnecessary_wraps, reason = "public API through export! macro")]
+pub(crate) fn udfs(_source: String) -> DataFusionResult<Vec<Arc<dyn ScalarUDFImpl>>> {
+    Ok(vec![Arc::new(SpinUdf::new())])
+}

guests/evil/src/spin/udf_return_type_other.rs

@@ -0,0 +1,57 @@
+//! UDF that spins forever when [`ScalarUDFImpl::return_type`] is called.
+use std::sync::Arc;
+
+use arrow::datatypes::DataType;
+use datafusion_common::{Result as DataFusionResult, ScalarValue};
+use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl, Signature, Volatility};
+
+use crate::spin::spin;
+
+/// UDF that spins.
+#[derive(Debug)]
+struct SpinUdf {
+    /// Signature of the UDF.
+    ///
+    /// We store this here because [`ScalarUDFImpl::signature`] requires us to return a reference.
+    signature: Signature,
+}
+
+impl SpinUdf {
+    /// Create new  UDF.
+    fn new() -> Self {
+        Self {
+            signature: Signature::uniform(0, vec![], Volatility::Immutable),
+        }
+    }
+}
+
+impl ScalarUDFImpl for SpinUdf {
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
+    fn name(&self) -> &str {
+        "spin"
+    }
+
+    fn signature(&self) -> &Signature {
+        &self.signature
+    }
+
+    fn return_type(&self, _arg_types: &[DataType]) -> DataFusionResult<DataType> {
+        spin();
+        Ok(DataType::Null)
+    }
+
+    fn invoke_with_args(&self, _args: ScalarFunctionArgs) -> DataFusionResult<ColumnarValue> {
+        Ok(ColumnarValue::Scalar(ScalarValue::Null))
+    }
+}
+
+/// Returns our evil UDFs.
+///
+/// The passed `source` is ignored.
+#[expect(clippy::unnecessary_wraps, reason = "public API through export! macro")]
+pub(crate) fn udfs(_source: String) -> DataFusionResult<Vec<Arc<dyn ScalarUDFImpl>>> {
+    Ok(vec![Arc::new(SpinUdf::new())])
+}

guests/evil/src/spin/udf_signature.rs

@@ -0,0 +1,57 @@
+//! UDF that spins forever when [`ScalarUDFImpl::signature`] is called.
+use std::sync::Arc;
+
+use arrow::datatypes::DataType;
+use datafusion_common::{Result as DataFusionResult, ScalarValue};
+use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl, Signature, Volatility};
+
+use crate::spin::spin;
+
+/// UDF that spins.
+#[derive(Debug)]
+struct SpinUdf {
+    /// Signature of the UDF.
+    ///
+    /// We store this here because [`ScalarUDFImpl::signature`] requires us to return a reference.
+    signature: Signature,
+}
+
+impl SpinUdf {
+    /// Create new  UDF.
+    fn new() -> Self {
+        Self {
+            signature: Signature::uniform(0, vec![], Volatility::Immutable),
+        }
+    }
+}
+
+impl ScalarUDFImpl for SpinUdf {
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
+    fn name(&self) -> &str {
+        "spin"
+    }
+
+    fn signature(&self) -> &Signature {
+        spin();
+        &self.signature
+    }
+
+    fn return_type(&self, _arg_types: &[DataType]) -> DataFusionResult<DataType> {
+        Ok(DataType::Null)
+    }
+
+    fn invoke_with_args(&self, _args: ScalarFunctionArgs) -> DataFusionResult<ColumnarValue> {
+        Ok(ColumnarValue::Scalar(ScalarValue::Null))
+    }
+}
+
+/// Returns our evil UDFs.
+///
+/// The passed `source` is ignored.
+#[expect(clippy::unnecessary_wraps, reason = "public API through export! macro")]
+pub(crate) fn udfs(_source: String) -> DataFusionResult<Vec<Arc<dyn ScalarUDFImpl>>> {
+    Ok(vec![Arc::new(SpinUdf::new())])
+}