ockam_api 0.48.0

Ockam's request-response API
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

use crate::cli_state::{CliState, ProjectConfigCompact, StateDirTrait, StateItemTrait};
use crate::cloud::project::Project;
use crate::config::cli::TrustContextConfig;
use miette::{IntoDiagnostic, WrapErr};
use std::path::PathBuf;

#[derive(Debug, Clone)]
pub struct TrustContextConfigBuilder {
    pub cli_state: CliState,
    pub project_path: Option<PathBuf>,
    pub trust_context: Option<TrustContextConfig>,
    pub project: Option<String>,
    pub authority_identity: Option<String>,
    pub credential_name: Option<String>,
    pub use_default_trust_context: bool,
}

impl TrustContextConfigBuilder {
    pub fn new(cli_state: &CliState) -> Self {
        Self {
            cli_state: cli_state.clone(),
            project_path: None,
            trust_context: None,
            project: None,
            authority_identity: None,
            credential_name: None,
            use_default_trust_context: false,
        }
    }

    pub fn with_authority_identity(&mut self, authority_identity: Option<&String>) -> &mut Self {
        self.authority_identity = authority_identity.map(|s| s.to_string());
        self
    }

    pub fn with_credential_name(&mut self, credential_name: Option<&String>) -> &mut Self {
        self.credential_name = credential_name.map(|s| s.to_string());
        self
    }

    pub fn use_default_trust_context(&mut self, use_default_trust_context: bool) -> &mut Self {
        self.use_default_trust_context = use_default_trust_context;
        self
    }

    pub fn build(&self) -> Option<TrustContextConfig> {
        self.trust_context
            .clone()
            .or_else(|| self.get_from_project_path(self.project_path.as_ref()?))
            .or_else(|| self.get_from_project_name())
            .or_else(|| self.get_from_authority_identity())
            .or_else(|| self.get_from_credential())
            .or_else(|| self.get_from_default_trust_context())
            .or_else(|| self.get_from_default_project())
    }

    fn get_from_project_path(&self, path: &PathBuf) -> Option<TrustContextConfig> {
        let s = std::fs::read_to_string(path)
            .into_diagnostic()
            .context("Failed to read project file")
            .ok()?;
        let proj_info = serde_json::from_str::<ProjectConfigCompact>(&s)
            .into_diagnostic()
            .context("Failed to parse project info")
            .ok()?;
        let proj: Project = (&proj_info).into();
        proj.try_into().ok()
    }

    fn get_from_project_name(&self) -> Option<TrustContextConfig> {
        let project = self.cli_state.projects.get(self.project.as_ref()?).ok()?;
        project.config().clone().try_into().ok()
    }

    fn get_from_authority_identity(&self) -> Option<TrustContextConfig> {
        let authority_identity = self.authority_identity.clone();
        let credential = match &self.credential_name {
            Some(c) => Some(self.cli_state.credentials.get(c).ok()?),
            None => None,
        };

        TrustContextConfig::from_authority_identity(&authority_identity?, credential).ok()
    }

    fn get_from_credential(&self) -> Option<TrustContextConfig> {
        let cred_name = self.credential_name.clone()?;
        let cred_state = self.cli_state.credentials.get(cred_name).ok()?;

        cred_state.try_into().ok()
    }

    fn get_from_default_trust_context(&self) -> Option<TrustContextConfig> {
        if !self.use_default_trust_context {
            return None;
        }

        let tc = self
            .cli_state
            .trust_contexts
            .default()
            .ok()?
            .config()
            .clone();
        Some(tc)
    }

    fn get_from_default_project(&self) -> Option<TrustContextConfig> {
        let proj = self.cli_state.projects.default().ok()?;
        self.get_from_project_path(proj.path())
    }
}