shell-cell 1.7.1

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
66
67
68

mod ui;

use std::{
    sync::mpsc::{Receiver, RecvError, RecvTimeoutError},
    time::Duration,
};

use super::{App, StoppingState};
use crate::buildkit::{BuildKitD, container_info::SCellContainerInfo};

pub struct LoadingState {
    rx: Receiver<color_eyre::Result<Vec<SCellContainerInfo>>>,
    buildkit: BuildKitD,
}

impl LoadingState {
    pub fn load(buildkit: BuildKitD) -> App {
        let (tx, rx) = std::sync::mpsc::channel();

        // Spawn async task to fetch containers for stop
        tokio::spawn({
            let buildkit = buildkit.clone();
            async move {
                let result = async {
                    let res = buildkit.list_containers().await;
                    tokio::time::sleep(std::time::Duration::from_millis(500)).await;
                    res
                }
                .await;
                drop(tx.send(result));
            }
        });

        App::Loading(LoadingState { rx, buildkit })
    }

    pub fn try_recv(
        self,
        timeout: Option<Duration>,
    ) -> color_eyre::Result<App> {
        if let Some(timeout) = timeout {
            match self.rx.recv_timeout(timeout) {
                Ok(Ok(items)) => Ok(StoppingState::stop(items, self.buildkit)),
                Ok(Err(e)) => {
                    color_eyre::eyre::bail!(e)
                },
                Err(RecvTimeoutError::Timeout) => Ok(App::Loading(self)),
                Err(RecvTimeoutError::Disconnected) => {
                    color_eyre::eyre::bail!(
                        "LoadingState channel cannot be disconnected without returning a result"
                    )
                },
            }
        } else {
            match self.rx.recv() {
                Ok(Ok(items)) => Ok(StoppingState::stop(items, self.buildkit)),
                Ok(Err(e)) => {
                    color_eyre::eyre::bail!(e)
                },
                Err(RecvError) => {
                    color_eyre::eyre::bail!(
                        "LoadingState channel cannot be disconnected without returning a result"
                    )
                },
            }
        }
    }
}