exers 0.1.0

Library for compiling and running other code in sandboxed environment
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

//! Module containing all compilers.
//! Currently supported compilers are:
//!
//! | Compiler | Supported Runtimes |
//! | --- | --- |
//! | [Rust](rust_compiler) | [WASM](crate::runtimes::wasm_runtime), [Native](crate::runtimes::native_runtime) |
//! | [C++](cpp_compiler) | [WASM](crate::runtimes::wasm_runtime), [Native](crate::runtimes::native_runtime) |
//! | [Python](python_compiler) | [Native](crate::runtimes::native_runtime) |

use std::{
    fmt::Debug,
    io,
    path::PathBuf,
    sync::{Arc, Mutex},
};

use tempfile::TempDir;

use crate::{common::compiler::CompilationResult, runtimes::CodeRuntime};

#[cfg(feature = "cpp")]
pub mod cpp_compiler;

#[cfg(feature = "python")]
pub mod python_compiler;
pub mod rust_compiler;

/// Trait for every compiler that can be used to compile some code.
pub trait Compiler<R: CodeRuntime>: Send + Sync + Sized {
    /// Configuration for the compiler.
    type Config: Send + Sync + Sized + Debug + Clone + Default + IntoArgs;

    /// Compile the given code (as stream of bytes) and return the executable (in temporary file).
    fn compile(
        &self,
        code: &mut impl io::Read,
        config: Self::Config,
    ) -> CompilationResult<CompiledCode<R>>;
}

/// Compiled code (executable).
/// Represents compiled code with additional information.
#[derive(Debug, Clone)]
pub struct CompiledCode<R: CodeRuntime> {
    /// Executable file (in temporary file).
    pub executable: Option<PathBuf>,

    /// Handle to the temporary directory.
    /// This is used to clean up the temporary directory when this object is dropped.
    pub temp_dir_handle: Arc<Mutex<Option<TempDir>>>,

    /// Additional data for the runtime.
    /// This can differ for different runtimes.
    pub additional_data: R::AdditionalData,

    /// Runtime marker.
    pub runtime_marker: std::marker::PhantomData<R>,
}

impl<R: CodeRuntime> CompiledCode<R> {
    /// Clean up the compiled code.
    /// This deletes the temporary directory containing the executable.
    pub fn clean_up(&mut self) -> io::Result<()> {
        // Delete the temporary directory.
        match self.temp_dir_handle.lock().unwrap().take() {
            Some(temp_dir) => {
                temp_dir.close()?;
            }
            None => {}
        }

        Ok(())
    }
}

impl<R: CodeRuntime> Drop for CompiledCode<R> {
    fn drop(&mut self) {
        self.clean_up().unwrap();
    }
}

// Converts Config to args.
pub trait IntoArgs {
    fn into_args(self) -> Vec<String>;
}