Crate sandkiste

Run code in virtual machines (sandboxes)

Summary

This crate provides an abstract API for the Rust programming language to allow executing scripting language code snippets in a sandbox.

The scripting language (or VM which executes code written in that scripting language) is not specified by this crate. Instead, other crates may use this crate to provide a scripting-language-independent interface to execute certain functions or provide callbacks from the VM to Rust.

Central trait is a Machine, which is capable to compile certain code into a function (see trait Compile for compiling code into functions, and see associated type Machine::Function and trait Function for executing these functions).

Passing values from Rust to the VM or from the VM to Rust is done through a “datum” type that is specific to each particular VM used (see associated type Machine::Datum). Some VMs may support creating closures in Rust which can then be converted into a “datum” and passed to the VM (see trait Callback).

VMs may also support setting global variables or variables in modules (see traits Globals and HasModules).

As different VMs may have “datum” types with different features (e.g. some scripting languages might support integers while others only know strings, a Machine::Datum can implement different traits in the types module which determine which functionality is supported (e.g. types::MaybeString if a datum can be a string).

Re-exports

pub use errors::*;

Modules

errors

Error traits and error kinds

prelude

Prelude that (currently) re-exports everything

traits

Unnameable traits to be included via wildcard syntax

types

Traits to be implemented by Machine::Datum to support specific types

Traits

Callback

Ability of Machines to call provided callbacks

Compile

Ability of Machines to compile provided code (of a certain type, e.g. &str or String)

Function

Basic interface of function that runs in a Machine

Globals

Machines that support global variables

HasModules

Ability to load language-independent modules into a Machine

Machine

Virtual machine to execute code (with inner mutability)

Module

Module of Machine where values can be read and set (access with HasModules::module)