clawft-kernel 0.8.3

WeftOS kernel: boot sequence, process table, service registry, and health subsystem
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

//! The `cog` kind (ADR-100), behind [`WorkloadKind`]. Behaviour is the
//! pre-registry cog path unchanged.

#[cfg(all(feature = "workload-runtime", feature = "mesh", unix))]
use std::path::Path;

#[cfg(all(feature = "workload-runtime", feature = "mesh", unix))]
use crate::workload_ctl::{PlaneError, cog_workload_spec};
#[cfg(all(feature = "workload-runtime", feature = "mesh", unix))]
use crate::workload_pkg::{DirSource, TrustAnchors, VerifyPolicy, verify_dir_in};
use crate::workload_pkg::{ManifestEnvelope, ManifestError};
#[cfg(all(feature = "workload-runtime", feature = "mesh", unix))]
use crate::workload_runtime::VerifiedWorkload;
#[cfg(all(feature = "workload-runtime", feature = "mesh", unix))]
use clawft_types::placement::engine::WorkloadSpec;

use super::WorkloadKind;
#[cfg(all(feature = "workload-runtime", feature = "mesh", unix))]
use super::{KindRegistry, MAX_KIND_LEN};

/// Native, container and Seed-hosted cog packages.
#[derive(Debug, Clone, Copy, Default)]
pub struct CogKind;

impl WorkloadKind for CogKind {
    fn id(&self) -> &'static str {
        crate::workload_pkg::KIND_COG
    }

    fn validate(&self, envelope: &ManifestEnvelope) -> Result<(), ManifestError> {
        envelope.cog_body().map(|_| ())
    }

    #[cfg(all(feature = "workload-runtime", feature = "mesh", unix))]
    fn load(
        &self,
        package_dir: &Path,
        anchors: &TrustAnchors,
        kinds: &KindRegistry,
    ) -> Result<VerifiedWorkload, PlaneError> {
        load_cog_shaped(self.id(), package_dir, anchors, kinds)
    }

    #[cfg(all(feature = "workload-runtime", feature = "mesh", unix))]
    fn spec(&self, workload: &VerifiedWorkload) -> Result<WorkloadSpec, String> {
        cog_workload_spec(workload)
    }

    #[cfg(all(feature = "workload-runtime", feature = "mesh", unix))]
    fn adapters(&self) -> &'static [&'static str] {
        &["native", "container", "emulated", "remote.api"]
    }
}

/// Verify and load a package whose verified body is cog-shaped, refusing it
/// unless the verified envelope's kind is `expected` (closes the window
/// between peeking the kind and verifying the package).
#[cfg(all(feature = "workload-runtime", feature = "mesh", unix))]
pub fn load_cog_shaped(
    expected: &str,
    package_dir: &Path,
    anchors: &TrustAnchors,
    kinds: &KindRegistry,
) -> Result<VerifiedWorkload, PlaneError> {
    let verified = verify_dir_in(package_dir, anchors, &VerifyPolicy::default(), kinds)
        .map_err(|e| PlaneError::Package(e.to_string()))?;
    if verified.envelope.kind != expected {
        return Err(PlaneError::Package(format!(
            "manifest kind {:?} is not {expected:?}",
            verified
                .envelope
                .kind
                .chars()
                .take(MAX_KIND_LEN)
                .collect::<String>()
        )));
    }
    VerifiedWorkload::from_package(&verified, &DirSource::new(package_dir))
        .map_err(|e| PlaneError::Package(e.to_string()))
}