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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
use fidl::unpersist;
use fidl_cf_sc_internal_receiverconfig::Config as FidlConfig;
use fuchsia_inspect::{ArithmeticArrayProperty, ArrayProperty, Node};
use fuchsia_runtime::{take_startup_handle, HandleInfo, HandleType};
use fuchsia_zircon as zx;
#[derive(Debug)]
pub struct Config {
    pub my_flag: bool,
    pub my_int16: i16,
    pub my_int32: i32,
    pub my_int64: i64,
    pub my_int8: i8,
    pub my_string: String,
    pub my_uint16: u16,
    pub my_uint32: u32,
    pub my_uint64: u64,
    pub my_uint8: u8,
    pub my_vector_of_flag: Vec<bool>,
    pub my_vector_of_int16: Vec<i16>,
    pub my_vector_of_int32: Vec<i32>,
    pub my_vector_of_int64: Vec<i64>,
    pub my_vector_of_int8: Vec<i8>,
    pub my_vector_of_string: Vec<String>,
    pub my_vector_of_uint16: Vec<u16>,
    pub my_vector_of_uint32: Vec<u32>,
    pub my_vector_of_uint64: Vec<u64>,
    pub my_vector_of_uint8: Vec<u8>,
}
impl Config {
    pub fn take_from_startup_handle() -> Self {
        let config_vmo: zx::Vmo =
            take_startup_handle(HandleInfo::new(HandleType::ComponentConfigVmo, 0))
                .expect("Config VMO handle must be provided and cannot already have been taken.")
                .into();
        let config_size =
            config_vmo.get_content_size().expect("must be able to read config vmo content size");
        assert_ne!(config_size, 0, "config vmo must be non-empty");
        let mut config_bytes = Vec::new();
        config_bytes.resize(config_size as usize, 0);
        config_vmo.read(&mut config_bytes, 0).expect("must be able to read config vmo");
        let checksum_length = u16::from_le_bytes([config_bytes[0], config_bytes[1]]) as usize;
        let fidl_start = 2 + checksum_length;
        let observed_checksum = &config_bytes[2..fidl_start];
        let expected_checksum = vec![
            0xcd, 0x57, 0xb2, 0xa2, 0x89, 0xbb, 0xb6, 0x11, 0xcf, 0x81, 0x50, 0xec, 0x06, 0xc5,
            0x06, 0x4c, 0x7c, 0xae, 0x79, 0x0f, 0xaa, 0x73, 0x0b, 0x6f, 0xa1, 0x02, 0xc3, 0x53,
            0x7b, 0x94, 0xee, 0x1a,
        ];
        assert_eq!(
            observed_checksum, expected_checksum,
            "checksum from config VMO does not match expected checksum"
        );
        let fidl_config: FidlConfig = unpersist(&config_bytes[fidl_start..])
            .expect("must be able to parse bytes as config FIDL");
        Self {
            my_flag: fidl_config.my_flag,
            my_int16: fidl_config.my_int16,
            my_int32: fidl_config.my_int32,
            my_int64: fidl_config.my_int64,
            my_int8: fidl_config.my_int8,
            my_string: fidl_config.my_string,
            my_uint16: fidl_config.my_uint16,
            my_uint32: fidl_config.my_uint32,
            my_uint64: fidl_config.my_uint64,
            my_uint8: fidl_config.my_uint8,
            my_vector_of_flag: fidl_config.my_vector_of_flag,
            my_vector_of_int16: fidl_config.my_vector_of_int16,
            my_vector_of_int32: fidl_config.my_vector_of_int32,
            my_vector_of_int64: fidl_config.my_vector_of_int64,
            my_vector_of_int8: fidl_config.my_vector_of_int8,
            my_vector_of_string: fidl_config.my_vector_of_string,
            my_vector_of_uint16: fidl_config.my_vector_of_uint16,
            my_vector_of_uint32: fidl_config.my_vector_of_uint32,
            my_vector_of_uint64: fidl_config.my_vector_of_uint64,
            my_vector_of_uint8: fidl_config.my_vector_of_uint8,
        }
    }
    pub fn record_inspect(&self, inspector_node: &Node) {
        inspector_node.record_bool("my_flag", self.my_flag);
        inspector_node.record_int("my_int16", self.my_int16 as i64);
        inspector_node.record_int("my_int32", self.my_int32 as i64);
        inspector_node.record_int("my_int64", self.my_int64);
        inspector_node.record_int("my_int8", self.my_int8 as i64);
        inspector_node.record_string("my_string", &self.my_string);
        inspector_node.record_uint("my_uint16", self.my_uint16 as u64);
        inspector_node.record_uint("my_uint32", self.my_uint32 as u64);
        inspector_node.record_uint("my_uint64", self.my_uint64);
        inspector_node.record_uint("my_uint8", self.my_uint8 as u64);
        let arr =
            inspector_node.create_uint_array("my_vector_of_flag", self.my_vector_of_flag.len());
        for i in 0..self.my_vector_of_flag.len() {
            arr.add(i, self.my_vector_of_flag[i] as u64);
        }
        inspector_node.record(arr);
        let arr =
            inspector_node.create_int_array("my_vector_of_int16", self.my_vector_of_int16.len());
        for i in 0..self.my_vector_of_int16.len() {
            arr.add(i, self.my_vector_of_int16[i] as i64);
        }
        inspector_node.record(arr);
        let arr =
            inspector_node.create_int_array("my_vector_of_int32", self.my_vector_of_int32.len());
        for i in 0..self.my_vector_of_int32.len() {
            arr.add(i, self.my_vector_of_int32[i] as i64);
        }
        inspector_node.record(arr);
        let arr =
            inspector_node.create_int_array("my_vector_of_int64", self.my_vector_of_int64.len());
        for i in 0..self.my_vector_of_int64.len() {
            arr.add(i, self.my_vector_of_int64[i]);
        }
        inspector_node.record(arr);
        let arr =
            inspector_node.create_int_array("my_vector_of_int8", self.my_vector_of_int8.len());
        for i in 0..self.my_vector_of_int8.len() {
            arr.add(i, self.my_vector_of_int8[i] as i64);
        }
        inspector_node.record(arr);
        let arr = inspector_node
            .create_string_array("my_vector_of_string", self.my_vector_of_string.len());
        for i in 0..self.my_vector_of_string.len() {
            arr.set(i, &self.my_vector_of_string[i]);
        }
        inspector_node.record(arr);
        let arr =
            inspector_node.create_uint_array("my_vector_of_uint16", self.my_vector_of_uint16.len());
        for i in 0..self.my_vector_of_uint16.len() {
            arr.add(i, self.my_vector_of_uint16[i] as u64);
        }
        inspector_node.record(arr);
        let arr =
            inspector_node.create_uint_array("my_vector_of_uint32", self.my_vector_of_uint32.len());
        for i in 0..self.my_vector_of_uint32.len() {
            arr.add(i, self.my_vector_of_uint32[i] as u64);
        }
        inspector_node.record(arr);
        let arr =
            inspector_node.create_uint_array("my_vector_of_uint64", self.my_vector_of_uint64.len());
        for i in 0..self.my_vector_of_uint64.len() {
            arr.add(i, self.my_vector_of_uint64[i]);
        }
        inspector_node.record(arr);
        let arr =
            inspector_node.create_uint_array("my_vector_of_uint8", self.my_vector_of_uint8.len());
        for i in 0..self.my_vector_of_uint8.len() {
            arr.add(i, self.my_vector_of_uint8[i] as u64);
        }
        inspector_node.record(arr);
    }
}