shell-cell 1.6.3

Shell-Cell. CLI app to spawn and manage containerized shell environments
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

//! Shell-Cell definition.
//! Its consists of the `Link`s, smallest abstraction of the whole Shell-Cell unit.
//! Each Shell-Cell would **always** contain at least two links, the root and the node.
//! The root link is always must be a some "base" image e.g. <https://docs.docker.com/build/building/base-images/>.
//! Not necessarily the docker base image, but it must be some image which would be a
//! "base" for entire Shell-Cell.

mod compile;
pub mod container;
pub mod image;
mod link;
pub mod name;
pub mod service;
pub mod types;

use std::hash::Hash;

use crate::scell::{
    container::SCellContainer,
    image::SCellImage,
    link::Link,
    name::SCellId,
    service::Service,
    types::target::{services::ServiceName, shell::ShellStmt},
};

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SCell {
    image: SCellImage,
    container: SCellContainer,
    shell: ShellStmt,
    services: Vec<(ServiceName, Service)>,
}

impl SCell {
    /// Returns an underlying shell's binary path
    pub fn shell(&self) -> &str {
        &self.shell.0
    }

    pub fn container_id(&self) -> color_eyre::Result<SCellId> {
        SCellId::new(|hasher| {
            self.image.hash(hasher)?;
            self.container.hash(hasher);
            for (name, service) in &self.services {
                name.hash(hasher);
                service.image.hash(hasher)?;
                service.container.hash(hasher);
            }
            Ok(())
        })
    }

    pub fn image(&self) -> &SCellImage {
        &self.image
    }

    pub fn container(&self) -> &SCellContainer {
        &self.container
    }

    pub fn services(&self) -> impl Iterator<Item = &(ServiceName, Service)> {
        self.services.iter()
    }
}