northstar-runtime 0.9.2

Northstar is an container runtime for Linux targetting embedded systems
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
86
87
88
89
90
91
92
93

use heck::ToSnakeCase;
use itertools::Itertools;
use std::{collections::HashSet, fmt};

use crate::npk::manifest::console::{
    Permission as ManifestPermission, Permissions as ManifestPermissions,
};

/// Set of permissions.
#[derive(Debug, Clone)]
pub struct Permissions(HashSet<Permission>);

impl Permissions {
    /// Returns true if permission is set.
    pub fn contains(&self, permission: &Permission) -> bool {
        self.0.contains(permission)
    }
}

impl fmt::Display for Permissions {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.0.iter().sorted().format(", "))
    }
}

#[derive(Debug, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]
pub enum Permission {
    /// Identification
    Ident,
    /// Inspect a container
    Inspect,
    /// Install a container
    Install,
    /// Send a singal to a container
    Kill,
    /// List all containers
    List,
    /// Notifications
    Notifications,
    /// Mount a container
    Mount,
    /// List repositories
    Repositories,
    /// Shutdown the runtime
    Shutdown,
    /// Start a container
    Start,
    /// Start a container with custom init, args and env
    StartCommand,
    /// Token creation
    TokenCreate,
    /// Token verification
    TokenVerification,
    /// Umount a container
    Umount,
    /// Uninstall a container
    Uninstall,
}

impl fmt::Display for Permission {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
        let s = format!("{:?}", self).to_snake_case();
        write!(f, "{}", s)
    }
}

impl From<crate::npk::manifest::console::Permissions> for Permissions {
    fn from(permissions: ManifestPermissions) -> Self {
        Permissions(permissions.iter().cloned().map(Into::into).collect())
    }
}

impl From<crate::npk::manifest::console::Permission> for Permission {
    fn from(permission: ManifestPermission) -> Permission {
        match permission {
            ManifestPermission::Ident => Permission::Ident,
            ManifestPermission::Inspect => Permission::Inspect,
            ManifestPermission::Install => Permission::Install,
            ManifestPermission::Kill => Permission::Kill,
            ManifestPermission::List => Permission::List,
            ManifestPermission::Notifications => Permission::Notifications,
            ManifestPermission::Mount => Permission::Mount,
            ManifestPermission::Repositories => Permission::Repositories,
            ManifestPermission::Shutdown => Permission::Shutdown,
            ManifestPermission::Start => Permission::Start,
            ManifestPermission::StartCommand => Permission::StartCommand,
            ManifestPermission::TokenCreate => Permission::TokenCreate,
            ManifestPermission::TokenVerification => Permission::TokenVerification,
            ManifestPermission::Umount => Permission::Umount,
            ManifestPermission::Uninstall => Permission::Uninstall,
        }
    }
}