icebox-client 0.2.6

HTTP client SDK for ICEBOX governance runtime — govern actions, record outcomes, and interact with the ICEBOX GEE 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

use std::collections::HashMap;

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GovernAction {
    pub action: String,
    pub target: String,
    pub capability: String,
    pub impact: String,
    pub destructive: bool,
    #[serde(default)]
    pub metadata: HashMap<String, String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GovernResult {
    pub approved: bool,
    pub decision: String,
    pub reason: Option<String>,
    pub decision_id: u64,
    pub chain_tip: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ActionOutcome {
    pub success: bool,
    pub evidence: Vec<String>,
    pub data: serde_json::Value,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RecordResult {
    pub decision_id: u64,
    pub chain_tip: String,
}

#[derive(Debug, thiserror::Error)]
pub enum ClientError {
    #[error("HTTP error: {0}")]
    Http(#[from] reqwest::Error),
    #[error("governance denied: {0}")]
    Denied(String),
    #[error("response parse error: {0}")]
    Parse(String),
}

/// ICEBOX Governance SDK client. Wraps any action in a GEE with one call.
pub struct GovernClient {
    client: reqwest::Client,
    base_url: String,
}

impl GovernClient {
    pub fn new(base_url: &str) -> Result<Self, ClientError> {
        let client = reqwest::Client::builder().build()?;
        Ok(GovernClient {
            client,
            base_url: base_url.trim_end_matches('/').to_string(),
        })
    }

    pub async fn govern(&self, action: GovernAction) -> Result<GovernResult, ClientError> {
        let resp = self
            .client
            .post(format!("{}/api/v1/govern", self.base_url))
            .json(&action)
            .send()
            .await?;
        let result: GovernResult = resp.json().await?;
        Ok(result)
    }

    pub async fn record(
        &self,
        action: GovernAction,
        outcome: ActionOutcome,
    ) -> Result<RecordResult, ClientError> {
        let resp = self
            .client
            .post(format!("{}/api/v1/govern/record", self.base_url))
            .json(&(action, outcome))
            .send()
            .await?;
        let result: RecordResult = resp.json().await?;
        Ok(result)
    }
}