greentic-deployer-dev 1.1.27182584028

Greentic deployer runtime for plan construction and deployment-pack dispatch
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! Local-process deployer env-pack (C2 reference impl).
//!
//! Backs the default `local` env's `Deployer` slot binding
//! (`greentic.deployer.local-process@0.1.0` per [`crate::defaults`]).
//! Unlike the metadata-only [`BuiltinHandler`](super::slot::BuiltinHandler)
//! that previously stood in here, this handler ships a
//! [`DeployerCredentials`](crate::credentials::DeployerCredentials) impl
//! so `gtc op credentials requirements local` returns real probe results
//! today (C1 + C2 together).
//!
//! Reference shape for downstream deployers (Phase D AWS / K8s / GCP /
//! Azure). The structure is:
//!
//! - `mod.rs` (this file) wires the [`EnvPackHandler`] surface — slot,
//!   descriptor path, supported versions, and the accessor returning the
//!   credentials handler.
//! - [`credentials`] holds the [`DeployerCredentials`] impl
//!   ([`LocalProcessCredentials`]) with the per-capability probes.

pub mod credentials;

use greentic_deploy_spec::CapabilitySlot;
use semver::VersionReq;

use super::slot::EnvPackHandler;
use crate::tool_check::ToolCheck;

pub use credentials::LocalProcessCredentials;

/// Native handler for the local-process deployer env-pack.
#[derive(Debug, Default)]
pub struct LocalProcessDeployerHandler {
    creds: LocalProcessCredentials,
}

impl LocalProcessDeployerHandler {
    /// Version-independent descriptor path used as the registry key.
    /// Must stay in lock-step with [`crate::defaults::LOCAL_DEPLOYER_PACK`]'s
    /// path component (the part before `@`).
    pub const DESCRIPTOR_PATH: &'static str = "greentic.deployer.local-process";

    /// Descriptor versions this handler implements. Same `^0.1.0`
    /// requirement the metadata-only `BuiltinHandler` previously declared,
    /// so the existing `local` env's `greentic.deployer.local-process@0.1.0`
    /// binding continues to resolve.
    pub const VERSION_REQ: &'static str = "^0.1.0";

    pub fn new() -> Self {
        Self::default()
    }

    /// Construct with an overridden port range for the
    /// `local-process.port.available` capability probe. Lets tests
    /// exercise the probe with a known-free or known-busy range without
    /// gambling on the default `8080..=8090`.
    pub fn with_port_range(range: std::ops::RangeInclusive<u16>) -> Self {
        Self {
            creds: LocalProcessCredentials::with_port_range(range),
        }
    }
}

impl EnvPackHandler for LocalProcessDeployerHandler {
    fn slot(&self) -> CapabilitySlot {
        CapabilitySlot::Deployer
    }

    fn descriptor_path(&self) -> &str {
        Self::DESCRIPTOR_PATH
    }

    fn supported_versions(&self) -> VersionReq {
        Self::VERSION_REQ
            .parse()
            .expect("local-process version-req is valid (guarded by tests)")
    }

    fn preflight(&self) -> Vec<ToolCheck> {
        // No external tools — local-process spawns child processes
        // directly and does not shell out to a provider CLI. Matches the
        // honest answer the prior `BuiltinHandler` returned (default).
        Vec::new()
    }

    fn deployer_credentials(&self) -> Option<&dyn crate::credentials::DeployerCredentials> {
        Some(&self.creds)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::defaults::LOCAL_DEPLOYER_PACK;
    use greentic_deploy_spec::PackDescriptor;

    #[test]
    fn handler_serves_deployer_slot_with_local_process_path() {
        let h = LocalProcessDeployerHandler::default();
        assert_eq!(h.slot(), CapabilitySlot::Deployer);
        assert_eq!(h.descriptor_path(), "greentic.deployer.local-process");
        // Version req is valid.
        let _ = h.supported_versions();
    }

    #[test]
    fn version_req_accepts_default_local_binding_descriptor() {
        let h = LocalProcessDeployerHandler::default();
        let pd = PackDescriptor::try_new(LOCAL_DEPLOYER_PACK).expect("descriptor parses");
        assert!(
            h.supported_versions().matches(&pd.version().0),
            "version req {} must accept the default {} binding's version",
            h.supported_versions(),
            LOCAL_DEPLOYER_PACK
        );
    }

    #[test]
    fn exposes_credentials_contract() {
        let h = LocalProcessDeployerHandler::default();
        let creds = h
            .deployer_credentials()
            .expect("local-process handler must expose credentials");
        // Sanity: contract returns the two C2 capabilities.
        let caps = creds.required_capabilities();
        assert_eq!(caps.len(), 2);
    }
}