enarx 0.2.1

Enarx Keep Loader
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

// SPDX-License-Identifier: Apache-2.0

mod exec;
mod info;
mod log;
mod run;
#[cfg(feature = "backend-sev")]
pub mod sev;

use anyhow::{anyhow, Result};
use std::ops::Deref;
use structopt::{clap::AppSettings, StructOpt};

pub use self::log::LogOptions;

/// `enarx` subcommands and their options/arguments.
#[derive(StructOpt, Debug)]
pub enum Command {
    Info(info::Options),
    #[structopt(setting(AppSettings::Hidden))]
    Exec(exec::Options),
    Run(run::Options),
    #[cfg(feature = "backend-sev")]
    Sev(sev::Command),
}

//
// Options & shared setup code for backends/shims
//

use crate::backend::{Backend, BACKENDS};

#[derive(StructOpt, Debug)]
pub struct BackendOptions {
    /// Set which backend to use
    #[structopt(long, env = "ENARX_BACKEND")]
    backend: Option<String>,
    // TODO: Path to an external shim binary?
    //shim: Option<PathBuf>,
}

impl BackendOptions {
    pub fn pick(&self) -> Result<&dyn Backend> {
        if let Some(ref name) = self.backend {
            BACKENDS
                .deref()
                .iter()
                .find(|b| b.have() && b.name() == name)
                .ok_or_else(|| anyhow!("Keep backend {:?} is unsupported", name))
        } else {
            BACKENDS
                .deref()
                .iter()
                .find(|b| b.have())
                .ok_or_else(|| anyhow!("No supported backend found"))
        }
        .map(|b| &**b)
    }
}

//
// Options & shared setup code for workldr
//
use crate::workldr::{Workldr, WORKLDRS};

#[derive(StructOpt, Debug)]
pub struct WorkldrOptions {
    #[structopt(long, env = "ENARX_WASMCFGFILE")]
    pub wasmcfgfile: Option<String>,
    // FUTURE: Path to an external workldr binary
}

impl WorkldrOptions {
    pub fn pick(&self) -> Result<&dyn Workldr> {
        WORKLDRS
            .deref()
            .iter()
            .find(|_| true)
            .ok_or_else(|| anyhow!("No supported workldr found"))
            .map(|b| &**b)
    }
}