lenso-cli 0.5.0

Authoring CLI for Lenso Plugins and App intent.
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

use std::{fmt, path::Path};

use lenso_app_plan::authoring::ResolvedApp;

use super::{
    LocalPluginRootAuthority, PluginConfigurationAuthoritySource, PluginRootRevision,
    set_instance_disabled_inner,
};

/// Host-side port for enabling or disabling one Plugin Instance.
///
/// Implementations own the visible selection state and compare-and-swap mutation. They do not
/// own App Generation staging, routing, or Kernel execution.
pub trait PluginSelectionAuthority: fmt::Debug + Send + Sync {
    fn source(&self) -> PluginConfigurationAuthoritySource;

    fn set_enabled(
        &self,
        expected_revision: &PluginRootRevision,
        plugin_id: &str,
        instance: &str,
        enabled: bool,
    ) -> anyhow::Result<PluginSelectionPublication>;
}

/// One committed Plugin Instance selection change.
#[derive(Debug)]
pub struct PluginSelectionPublication {
    base_revision: PluginRootRevision,
    enabled: bool,
    instance: String,
    plugin_id: String,
    revision: PluginRootRevision,
    resolved: ResolvedApp,
}

impl PluginSelectionPublication {
    pub const fn base_revision(&self) -> &PluginRootRevision {
        &self.base_revision
    }

    pub const fn enabled(&self) -> bool {
        self.enabled
    }

    pub fn instance(&self) -> &str {
        &self.instance
    }

    pub fn plugin_id(&self) -> &str {
        &self.plugin_id
    }

    pub const fn revision(&self) -> &PluginRootRevision {
        &self.revision
    }

    pub const fn resolved(&self) -> &ResolvedApp {
        &self.resolved
    }

    pub fn into_resolved(self) -> ResolvedApp {
        self.resolved
    }
}

/// Atomically changes one Instance selection after checking the exact current revision.
pub fn set_instance_enabled_fenced(
    root: &Path,
    expected_revision: &PluginRootRevision,
    plugin_id: &str,
    instance: &str,
    enabled: bool,
) -> anyhow::Result<PluginSelectionPublication> {
    let (base_revision, revision, resolved) =
        set_instance_disabled_inner(root, plugin_id, instance, !enabled, Some(expected_revision))?;
    Ok(PluginSelectionPublication {
        base_revision,
        enabled,
        instance: instance.to_owned(),
        plugin_id: plugin_id.to_owned(),
        revision,
        resolved,
    })
}

impl PluginSelectionAuthority for LocalPluginRootAuthority {
    fn source(&self) -> PluginConfigurationAuthoritySource {
        PluginConfigurationAuthoritySource::new("local_plugin_root", "app")
            .expect("built-in Plugin selection authority source is valid")
    }

    fn set_enabled(
        &self,
        expected_revision: &PluginRootRevision,
        plugin_id: &str,
        instance: &str,
        enabled: bool,
    ) -> anyhow::Result<PluginSelectionPublication> {
        let _guard = self.lock()?;
        set_instance_enabled_fenced(self.root(), expected_revision, plugin_id, instance, enabled)
    }
}