Cleanup API

Author: MikailBag

minion-cli/src/main.rs

@@ -1,4 +1,4 @@
-use minion::{self, Dominion};
+use minion::{self};
 use std::time::Duration;
 use structopt::StructOpt;
 
@@ -16,7 +16,7 @@ fn parse_env_item(src: &str) -> Result<EnvItem, &'static str> {
     })
 }
 
-fn parse_path_exposition_item(src: &str) -> Result<minion::PathExpositionOptions, String> {
+fn parse_path_exposition_item(src: &str) -> Result<minion::SharedDir, String> {
     let parts = src.splitn(3, ':').collect::<Vec<_>>();
     if parts.len() != 3 {
         return Err(format!(
@@ -31,20 +31,20 @@ fn parse_path_exposition_item(src: &str) -> Result<minion::PathExpositionOptions
             amask.len()
         ));
     }
-    let access = match amask {
-        "rwx" => minion::DesiredAccess::Full,
-        "r-x" => minion::DesiredAccess::Readonly,
+    let kind = match amask {
+        "rwx" => minion::SharedDirKind::Full,
+        "r-x" => minion::SharedDirKind::Readonly,
         _ => {
             return Err(format!(
                 "unknown access mask {}. rwx or r-x expected",
                 amask
             ));
         }
     };
-    Ok(minion::PathExpositionOptions {
+    Ok(minion::SharedDir {
         src: parts[0].to_string().into(),
         dest: parts[2].to_string().into(),
-        access,
+        kind,
     })
 }
 
@@ -92,7 +92,7 @@ struct ExecOpt {
         long = "expose",
         parse(try_from_str = parse_path_exposition_item)
     )]
-    exposed_paths: Vec<minion::PathExpositionOptions>,
+    exposed_paths: Vec<minion::SharedDir>,
 
     /// Process working dir, relative to `isolation_root`
     #[structopt(short = "p", long = "pwd", default_value = "/")]
@@ -108,18 +108,18 @@ fn main() {
         eprintln!("Error: {}", err);
         std::process::exit(1);
     }
-    let backend = minion::setup();
-
-    let dominion = backend.new_dominion(minion::DominionOptions {
-        max_alive_process_count: options.num_processes.min(u32::max_value() as usize) as u32,
-        memory_limit: options.memory_limit as u64,
-        isolation_root: options.isolation_root.into(),
-        exposed_paths: options.exposed_paths,
-        cpu_time_limit: Duration::from_millis(u64::from(options.time_limit)),
-        real_time_limit: Duration::from_millis(u64::from(options.time_limit * 3)),
-    });
-
-    let dominion = dominion.unwrap();
+    let backend = minion::erased::setup();
+
+    let sandbox = backend
+        .new_sandbox(minion::SandboxOptions {
+            max_alive_process_count: options.num_processes.min(u32::max_value() as usize) as u32,
+            memory_limit: options.memory_limit as u64,
+            isolation_root: options.isolation_root.into(),
+            exposed_paths: options.exposed_paths,
+            cpu_time_limit: Duration::from_millis(u64::from(options.time_limit)),
+            real_time_limit: Duration::from_millis(u64::from(options.time_limit * 3)),
+        })
+        .unwrap();
 
     let (stdin_fd, stdout_fd, stderr_fd);
     unsafe {
@@ -135,7 +135,7 @@ fn main() {
             .iter()
             .map(|v| format!("{}={}", &v.name, &v.value).into())
             .collect(),
-        dominion: dominion.clone(),
+        sandbox: sandbox.clone(),
         stdio: minion::StdioSpecification {
             stdin: unsafe { minion::InputSpecification::handle(stdin_fd) },
             stdout: unsafe { minion::OutputSpecification::handle(stdout_fd) },
@@ -150,10 +150,10 @@ fn main() {
     cp.wait_for_exit(None).unwrap();
     let exit_code = cp.get_exit_code().unwrap();
     println!("---> Child process exited with code {:?} <---", exit_code);
-    if dominion.check_cpu_tle().unwrap() {
+    if sandbox.check_cpu_tle().unwrap() {
         println!("Note: CPU time limit was exceeded");
     }
-    if dominion.check_real_tle().unwrap() {
+    if sandbox.check_real_tle().unwrap() {
         println!("Note: wall-clock time limit was exceeded");
     }
 }

minion-ffi/src/lib.rs

@@ -1,6 +1,6 @@
 #![cfg_attr(minion_nightly, feature(unsafe_block_in_unsafe_fn))]
 #![cfg_attr(minion_nightly, warn(unsafe_op_in_unsafe_fn))]
-use minion::{self, Dominion as _};
+use minion::{self};
 use std::{
     ffi::{CStr, OsStr, OsString},
     mem::{self},
@@ -50,7 +50,7 @@ unsafe fn get_string(buf: *const c_char) -> OsString {
     s.to_os_string()
 }
 
-pub struct Backend(Box<dyn minion::Backend>);
+pub struct Backend(Box<dyn minion::erased::Backend>);
 
 /// # Safety
 /// Must be called once
@@ -69,7 +69,7 @@ pub unsafe extern "C" fn minion_lib_init() -> ErrorCode {
 #[no_mangle]
 #[must_use]
 pub extern "C" fn minion_backend_create(out: &mut *mut Backend) -> ErrorCode {
-    let backend = Backend(minion::setup());
+    let backend = Backend(minion::erased::setup());
     let backend = Box::new(backend);
     *out = Box::into_raw(backend);
     ErrorCode::Ok
@@ -93,7 +93,7 @@ pub struct TimeSpec {
 }
 
 #[repr(C)]
-pub struct DominionOptions {
+pub struct SandboxOptions {
     pub cpu_time_limit: TimeSpec,
     pub real_time_limit: TimeSpec,
     pub process_limit: u32,
@@ -103,16 +103,16 @@ pub struct DominionOptions {
 }
 
 #[derive(Clone)]
-pub struct Dominion(minion::DominionRef);
+pub struct Sandbox(Box<dyn minion::erased::Sandbox>);
 
 /// # Safety
 /// `out` must be valid
 #[no_mangle]
-pub unsafe extern "C" fn minion_dominion_check_cpu_tle(
-    dominion: &Dominion,
+pub unsafe extern "C" fn minion_sandbox_check_cpu_tle(
+    sandbox: &Sandbox,
     out: *mut bool,
 ) -> ErrorCode {
-    match dominion.0.check_cpu_tle() {
+    match sandbox.0.check_cpu_tle() {
         Ok(st) => {
             unsafe {
                 out.write(st);
@@ -126,11 +126,11 @@ pub unsafe extern "C" fn minion_dominion_check_cpu_tle(
 /// # Safety
 /// `out` must be valid
 #[no_mangle]
-pub unsafe extern "C" fn minion_dominion_check_real_tle(
-    dominion: &Dominion,
+pub unsafe extern "C" fn minion_sandbox_check_real_tle(
+    sandbox: &Sandbox,
     out: *mut bool,
 ) -> ErrorCode {
-    match dominion.0.check_real_tle() {
+    match sandbox.0.check_real_tle() {
         Ok(st) => {
             unsafe {
                 out.write(st);
@@ -142,8 +142,8 @@ pub unsafe extern "C" fn minion_dominion_check_real_tle(
 }
 
 #[no_mangle]
-pub extern "C" fn minion_dominion_kill(dominion: &Dominion) -> ErrorCode {
-    match dominion.0.kill() {
+pub extern "C" fn minion_sandbox_kill(sandbox: &Sandbox) -> ErrorCode {
+    match sandbox.0.kill() {
         Ok(_) => ErrorCode::Ok,
         Err(_) => ErrorCode::Unknown,
     }
@@ -153,29 +153,29 @@ pub extern "C" fn minion_dominion_kill(dominion: &Dominion) -> ErrorCode {
 /// Provided arguments must be well-formed
 #[no_mangle]
 #[must_use]
-pub unsafe extern "C" fn minion_dominion_create(
+pub unsafe extern "C" fn minion_sandbox_create(
     backend: &Backend,
-    options: DominionOptions,
-    out: &mut *mut Dominion,
+    options: SandboxOptions,
+    out: &mut *mut Sandbox,
 ) -> ErrorCode {
     let mut exposed_paths = Vec::new();
     unsafe {
         let mut p = options.shared_directories;
         while !(*p).host_path.is_null() {
-            let opt = minion::PathExpositionOptions {
+            let opt = minion::SharedDir {
                 src: get_string((*p).host_path).into(),
                 dest: get_string((*p).sandbox_path).into(),
-                access: match (*p).kind {
-                    SharedDirectoryAccessKind::Full => minion::DesiredAccess::Full,
-                    SharedDirectoryAccessKind::Readonly => minion::DesiredAccess::Readonly,
+                kind: match (*p).kind {
+                    SharedDirectoryAccessKind::Full => minion::SharedDirKind::Full,
+                    SharedDirectoryAccessKind::Readonly => minion::SharedDirKind::Readonly,
                 },
             };
             exposed_paths.push(opt);
             p = p.offset(1);
         }
     }
     let isolation_root = unsafe { get_string(options.isolation_root) }.into();
-    let opts = minion::DominionOptions {
+    let opts = minion::SandboxOptions {
         max_alive_process_count: options.process_limit as _,
         memory_limit: u64::from(options.memory_limit),
         cpu_time_limit: std::time::Duration::new(
@@ -189,20 +189,20 @@ pub unsafe extern "C" fn minion_dominion_create(
         isolation_root,
         exposed_paths,
     };
-    let d = backend.0.new_dominion(opts);
+    let d = backend.0.new_sandbox(opts);
     let d = d.unwrap();
 
-    let dw = Dominion(d);
+    let dw = Sandbox(d);
     *out = Box::into_raw(Box::new(dw));
     ErrorCode::Ok
 }
 
 /// # Safety
-/// `dominion` must be pointer, returned by `minion_dominion_create`.
+/// `sandbox` must be pointer, returned by `minion_sandbox_create`.
 #[no_mangle]
 #[must_use]
-pub unsafe extern "C" fn minion_dominion_free(dominion: *mut Dominion) -> ErrorCode {
-    let b = unsafe { Box::from_raw(dominion) };
+pub unsafe extern "C" fn minion_sandbox_free(sandbox: *mut Sandbox) -> ErrorCode {
+    let b = unsafe { Box::from_raw(sandbox) };
     mem::drop(b);
     ErrorCode::Ok
 }
@@ -242,7 +242,7 @@ pub struct ChildProcessOptions {
     pub argv: *const *const c_char,
     pub envp: *const EnvItem,
     pub stdio: StdioHandleSet,
-    pub dominion: *mut Dominion,
+    pub sandbox: *mut Sandbox,
     pub workdir: *const c_char,
 }
 
@@ -269,7 +269,7 @@ pub static SHARED_DIRECTORY_ACCESS_FIN: SharedDirectoryAccess = SharedDirectoryA
     sandbox_path: std::ptr::null(),
 };
 
-pub struct ChildProcess(Box<dyn minion::ChildProcess>);
+pub struct ChildProcess(Box<dyn minion::erased::ChildProcess>);
 
 /// # Safety
 /// Provided `options` must be well-formed
@@ -314,7 +314,7 @@ pub unsafe extern "C" fn minion_cp_spawn(
             path: get_string(options.image_path).into(),
             arguments,
             environment,
-            dominion: (*options.dominion).0.clone(),
+            sandbox: (*options.sandbox).0.clone(),
             stdio,
             pwd: get_string(options.workdir).into(),
         }

minion-tests/src/main.rs

@@ -8,7 +8,7 @@
 //! master. Finally, test itself is executed inside another process.
 //! I.e.
 //! Master: parses CLI, selects tests, spawns Workers
-//! Worker: sets up dominion, executes `minion-tests` in Test mode.
+//! Worker: sets up sandbox, executes `minion-tests` in Test mode.
 //! Test: just executes test selected by name
 #![feature(asm, test)]
 mod master;
@@ -27,7 +27,7 @@ pub trait TestCase: Send + Sync {
     /// If tests passed, does nothing otherwise
     /// panics.
     /// Executed on worker.
-    fn check(&self, cp: &mut dyn minion::ChildProcess, d: minion::DominionRef);
+    fn check(&self, cp: &mut dyn minion::erased::ChildProcess, sb: &dyn minion::erased::Sandbox);
     /// Overrides CPU time limit
     fn time_limit(&self) -> std::time::Duration {
         std::time::Duration::from_secs(1)

minion-tests/src/tests.rs

@@ -1,7 +1,7 @@
 mod simple;
 
 use crate::TestCase;
-use minion::ChildProcess;
+use minion::erased::ChildProcess;
 use once_cell::sync::Lazy;
 use std::io::Read;
 

minion-tests/src/tests/simple.rs

@@ -1,5 +1,5 @@
 //! Tests that simple program that does nothing completes successfully.
-use minion::ChildProcess;
+use minion::erased::{ChildProcess, Sandbox};
 
 pub(crate) struct TOk;
 impl crate::TestCase for TOk {
@@ -12,7 +12,7 @@ impl crate::TestCase for TOk {
     fn test(&self) -> ! {
         std::process::exit(0)
     }
-    fn check(&self, cp: &mut dyn ChildProcess, _: minion::DominionRef) {
+    fn check(&self, cp: &mut dyn ChildProcess, _: &dyn Sandbox) {
         assert!(matches!(cp.get_exit_code(), Ok(Some(0))));
         super::assert_empty(&mut cp.stdout().unwrap());
         super::assert_empty(&mut cp.stderr().unwrap());
@@ -34,7 +34,7 @@ impl crate::TestCase for TTl {
     fn test(&self) -> ! {
         exceed_time_limit()
     }
-    fn check(&self, cp: &mut dyn ChildProcess, _: minion::DominionRef) {
+    fn check(&self, cp: &mut dyn ChildProcess, _: &dyn Sandbox) {
         super::assert_killed(cp);
     }
 }
@@ -53,7 +53,7 @@ impl crate::TestCase for TTlFork {
         nix::unistd::fork().unwrap();
         exceed_time_limit()
     }
-    fn check(&self, cp: &mut dyn ChildProcess, _: minion::DominionRef) {
+    fn check(&self, cp: &mut dyn ChildProcess, _: &dyn Sandbox) {
         super::assert_killed(cp);
     }
     fn process_count_limit(&self) -> u32 {
@@ -74,7 +74,7 @@ impl crate::TestCase for TIdle {
         nix::unistd::sleep(1_000_000_000);
         std::process::exit(0)
     }
-    fn check(&self, cp: &mut dyn ChildProcess, _: minion::DominionRef) {
+    fn check(&self, cp: &mut dyn ChildProcess, _: &dyn Sandbox) {
         super::assert_killed(cp);
     }
 }
@@ -90,7 +90,7 @@ impl crate::TestCase for TRet1 {
     fn test(&self) -> ! {
         std::process::exit(1);
     }
-    fn check(&self, cp: &mut dyn ChildProcess, _: minion::DominionRef) {
+    fn check(&self, cp: &mut dyn ChildProcess, _: &dyn Sandbox) {
         super::assert_exit_code(cp, 1);
     }
 }
@@ -125,7 +125,7 @@ impl crate::TestCase for TOom {
         }
     }
 
-    fn check(&self, _cp: &mut dyn ChildProcess, _d: minion::DominionRef) {
+    fn check(&self, _cp: &mut dyn ChildProcess, _sb: &dyn Sandbox) {
         // TODO this test is broken
         // super::assert_exit_code(cp, -9);
         // assert!(!d.check_cpu_tle().unwrap());
@@ -164,7 +164,7 @@ impl crate::TestCase for TSecurity {
         assert!(matches!(err, nix::Error::Sys(nix::errno::Errno::EPERM)));
         std::process::exit(24)
     }
-    fn check(&self, cp: &mut dyn minion::ChildProcess, _d: minion::DominionRef) {
+    fn check(&self, cp: &mut dyn ChildProcess, _sb: &dyn Sandbox) {
         super::assert_exit_code(cp, 24);
         super::assert_empty(&mut cp.stdout().unwrap());
         super::assert_empty(&mut cp.stderr().unwrap());