krata 0.0.21

Client library and common services for the krata isolation engine
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
128
129

use anyhow::Result;
use prost::Message;
use prost_types::{ListValue, Value};

use super::serialize::{IdmRequest, IdmSerializable};

include!(concat!(env!("OUT_DIR"), "/krata.idm.internal.rs"));

pub const INTERNAL_IDM_CHANNEL: u64 = 0;

impl IdmSerializable for Event {
    fn encode(&self) -> Result<Vec<u8>> {
        Ok(self.encode_to_vec())
    }

    fn decode(bytes: &[u8]) -> Result<Self> {
        Ok(<Self as prost::Message>::decode(bytes)?)
    }
}

impl IdmSerializable for Request {
    fn encode(&self) -> Result<Vec<u8>> {
        Ok(self.encode_to_vec())
    }

    fn decode(bytes: &[u8]) -> Result<Self> {
        Ok(<Self as prost::Message>::decode(bytes)?)
    }
}

impl IdmRequest for Request {
    type Response = Response;
}

impl IdmSerializable for Response {
    fn encode(&self) -> Result<Vec<u8>> {
        Ok(self.encode_to_vec())
    }

    fn decode(bytes: &[u8]) -> Result<Self> {
        Ok(<Self as prost::Message>::decode(bytes)?)
    }
}

pub trait AsIdmMetricValue {
    fn as_metric_value(&self) -> Value;
}

impl MetricNode {
    pub fn structural<N: AsRef<str>>(name: N, children: Vec<MetricNode>) -> MetricNode {
        MetricNode {
            name: name.as_ref().to_string(),
            value: None,
            format: MetricFormat::Unknown.into(),
            children,
        }
    }

    pub fn raw_value<N: AsRef<str>, V: AsIdmMetricValue>(name: N, value: V) -> MetricNode {
        MetricNode {
            name: name.as_ref().to_string(),
            value: Some(value.as_metric_value()),
            format: MetricFormat::Unknown.into(),
            children: vec![],
        }
    }

    pub fn value<N: AsRef<str>, V: AsIdmMetricValue>(
        name: N,
        value: V,
        format: MetricFormat,
    ) -> MetricNode {
        MetricNode {
            name: name.as_ref().to_string(),
            value: Some(value.as_metric_value()),
            format: format.into(),
            children: vec![],
        }
    }
}

impl AsIdmMetricValue for String {
    fn as_metric_value(&self) -> Value {
        Value {
            kind: Some(prost_types::value::Kind::StringValue(self.to_string())),
        }
    }
}

impl AsIdmMetricValue for &str {
    fn as_metric_value(&self) -> Value {
        Value {
            kind: Some(prost_types::value::Kind::StringValue(self.to_string())),
        }
    }
}

impl AsIdmMetricValue for u64 {
    fn as_metric_value(&self) -> Value {
        numeric(*self as f64)
    }
}

impl AsIdmMetricValue for i64 {
    fn as_metric_value(&self) -> Value {
        numeric(*self as f64)
    }
}

impl AsIdmMetricValue for f64 {
    fn as_metric_value(&self) -> Value {
        numeric(*self)
    }
}

impl<T: AsIdmMetricValue> AsIdmMetricValue for Vec<T> {
    fn as_metric_value(&self) -> Value {
        let values = self.iter().map(|x| x.as_metric_value()).collect::<_>();
        Value {
            kind: Some(prost_types::value::Kind::ListValue(ListValue { values })),
        }
    }
}

fn numeric(value: f64) -> Value {
    Value {
        kind: Some(prost_types::value::Kind::NumberValue(value)),
    }
}