astrid 0.10.1

Command-line interface for Astrid secure agent runtime
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

//! Distro-batch capsule installation contract.

use std::sync::atomic::Ordering;

use astrid_capsule::capsule::CapsuleId;

/// Concrete git selector for a distro capsule install.
#[derive(Debug, Clone, Default)]
pub(crate) struct RefSpec {
    pub(crate) version: Option<String>,
    pub(crate) tag: Option<String>,
}

impl RefSpec {
    pub(crate) fn from_capsule(cap: &super::super::distro::manifest::DistroCapsule) -> Self {
        Self {
            version: (!cap.version.trim().is_empty()).then(|| cap.version.trim().to_string()),
            tag: cap
                .tag
                .as_deref()
                .map(str::trim)
                .filter(|tag| !tag.is_empty())
                .map(str::to_string),
        }
    }
}

#[derive(Debug)]
pub(crate) struct InstalledCapsuleOutcome {
    pub(crate) id: CapsuleId,
    pub(crate) version: String,
    pub(crate) wasm_hash: Option<String>,
}

#[derive(Debug)]
pub(crate) struct BatchInstallOutcome {
    pub(crate) installed: Vec<InstalledCapsuleOutcome>,
    pub(crate) resolved_ref: Option<String>,
}

/// Install without prompting, returning the identities that actually landed.
pub(crate) async fn install_capsule_batch(
    source: &str,
    expected: &CapsuleId,
    workspace: bool,
    refspec: &RefSpec,
    principal: &astrid_core::PrincipalId,
) -> anyhow::Result<BatchInstallOutcome> {
    anyhow::ensure!(
        refspec.version.is_some() || refspec.tag.is_some(),
        "distro capsule '{expected}' has no concrete released version or tag"
    );
    super::install::BATCH_MODE.store(true, Ordering::Relaxed);
    let prompt = super::install::ManualInstallOptions::default();
    let result = super::install::install_capsule_inner(
        source,
        Some(expected.as_str()),
        workspace,
        refspec,
        principal,
        Some(expected),
        &prompt,
    )
    .await;
    super::install::BATCH_MODE.store(false, Ordering::Relaxed);
    result.map(|(installed, resolved_ref)| BatchInstallOutcome {
        installed,
        resolved_ref,
    })
}