containerization-framework 0.4.0

Rust bindings for Apple's Containerization framework: Linux containers in lightweight VMs, in-process and without a daemon.
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
86
87
88
89

use super::LinuxCapabilities;
use super::LinuxRLimit;
use crate::containerization::strings;
use crate::containerization_oci;
use crate::containerization_os::terminal::Terminal;
use crate::error::Error;
use crate::platform;
use crate::platform::ffi;
use std::os::fd::RawFd;

/// `LinuxProcessConfiguration`.
///
/// `stdin`, `stdout` and `stderr` are descriptors where Swift takes a
/// `ReaderStream` or `Writer`. Swift streams a duplicate of each, so the caller
/// keeps its own.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct LinuxProcessConfiguration {
  pub arguments: Vec<String>,
  pub environment_variables: Vec<String>,
  pub working_directory: String,
  pub user: containerization_oci::runtime::User,
  pub rlimits: Vec<LinuxRLimit>,
  pub no_new_privileges: bool,
  pub capabilities: LinuxCapabilities,
  pub terminal: bool,
  pub stdin: Option<RawFd>,
  pub stdout: Option<RawFd>,
  pub stderr: Option<RawFd>,
}

impl LinuxProcessConfiguration {
  /// `LinuxProcessConfiguration.defaultPath`.
  pub const DEFAULT_PATH: &str = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";

  /// `LinuxProcessConfiguration(arguments:)`, its other arguments at their
  /// defaults.
  pub fn new(arguments: &[&str]) -> Self {
    Self {
      arguments: strings(arguments),
      ..Self::default()
    }
  }

  /// `LinuxProcessConfiguration(from:)`: the process an image's
  /// configuration describes.
  pub fn from_image_config(config: &containerization_oci::image::ImageConfig) -> Result<Self, Error> {
    platform::filled_process(
      |receive| ffi::cz_linux_process_configuration_from_image_config(config.clone(), Self::default(), receive),
      "make a process configuration from an image's",
    )
  }

  /// `LinuxProcessConfiguration.setTerminalIO(terminal:)`: sets what a pty
  /// needs, and `terminal` as stdin and stdout. Where Swift keeps the
  /// terminal, `stdin` and `stdout` hold its descriptor.
  pub fn set_terminal_io(&mut self, terminal: &Terminal) -> Result<(), Error> {
    let process = platform::filled_process(
      |receive| ffi::cz_linux_process_configuration_set_terminal_io(self.clone(), terminal.handle.duplicate(), receive),
      "set a process configuration's terminal",
    )?;

    *self = Self {
      stdin: Some(terminal.handle()),
      stdout: Some(terminal.handle()),
      ..process
    };

    Ok(())
  }
}

/// `LinuxProcessConfiguration()`.
impl Default for LinuxProcessConfiguration {
  fn default() -> Self {
    Self {
      arguments: Vec::new(),
      environment_variables: vec![format!("PATH={}", Self::DEFAULT_PATH)],
      working_directory: "/".to_string(),
      user: containerization_oci::runtime::User::default(),
      rlimits: Vec::new(),
      no_new_privileges: false,
      capabilities: LinuxCapabilities::default_oci_capabilities(),
      terminal: false,
      stdin: None,
      stdout: None,
      stderr: None,
    }
  }
}