fuchsia_inspect/reader/
tree_reader.rs

1// Copyright 2019 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::reader::error::ReaderError;
6use crate::reader::{
7    DiagnosticsHierarchy, MissingValueReason, PartialNodeHierarchy, ReadableTree, Snapshot,
8};
9use fuchsia_async::{DurationExt, TimeoutExt};
10use futures::future::BoxFuture;
11use futures::prelude::*;
12use inspect_format::LinkNodeDisposition;
13use std::collections::BTreeMap;
14use std::time::Duration;
15
16/// Contains the snapshot of the hierarchy and snapshots of all the lazy nodes in the hierarchy.
17#[derive(Debug)]
18pub struct SnapshotTree {
19    snapshot: Snapshot,
20    children: SnapshotTreeMap,
21}
22
23impl SnapshotTree {
24    /// Loads a snapshot tree from the given inspect tree.
25    #[cfg(target_os = "fuchsia")]
26    pub async fn try_from(
27        tree: &fidl_fuchsia_inspect::TreeProxy,
28    ) -> Result<SnapshotTree, ReaderError> {
29        load_snapshot_tree(tree, None).await
30    }
31
32    pub async fn try_from_with_timeout<T: ReadableTree + Send + Sync>(
33        tree: &T,
34        lazy_child_timeout: Duration,
35    ) -> Result<SnapshotTree, ReaderError> {
36        load_snapshot_tree(tree, Some(lazy_child_timeout)).await
37    }
38}
39
40type SnapshotTreeMap = BTreeMap<String, Result<SnapshotTree, ReaderError>>;
41
42impl TryInto<DiagnosticsHierarchy> for SnapshotTree {
43    type Error = ReaderError;
44
45    fn try_into(mut self) -> Result<DiagnosticsHierarchy, Self::Error> {
46        let partial = PartialNodeHierarchy::try_from(self.snapshot)?;
47        Ok(expand(partial, &mut self.children))
48    }
49}
50
51fn expand(
52    partial: PartialNodeHierarchy,
53    snapshot_children: &mut SnapshotTreeMap,
54) -> DiagnosticsHierarchy {
55    // TODO(miguelfrde): remove recursion or limit depth.
56    let children =
57        partial.children.into_iter().map(|child| expand(child, snapshot_children)).collect();
58    let mut hierarchy = DiagnosticsHierarchy::new(partial.name, partial.properties, children);
59    for link_value in partial.links {
60        let Some(result) = snapshot_children.remove(&link_value.content) else {
61            hierarchy.add_missing(MissingValueReason::LinkNotFound, link_value.name);
62            continue;
63        };
64
65        // TODO(miguelfrde): remove recursion or limit depth.
66        let result: Result<DiagnosticsHierarchy, ReaderError> =
67            result.and_then(|snapshot_tree| snapshot_tree.try_into());
68        match result {
69            Err(ReaderError::TreeTimedOut) => {
70                hierarchy.add_missing(MissingValueReason::Timeout, link_value.name);
71            }
72            Err(_) => {
73                hierarchy.add_missing(MissingValueReason::LinkParseFailure, link_value.name);
74            }
75            Ok(mut child_hierarchy) => match link_value.disposition {
76                LinkNodeDisposition::Child => {
77                    child_hierarchy.name = link_value.name;
78                    hierarchy.children.push(child_hierarchy);
79                }
80                LinkNodeDisposition::Inline => {
81                    hierarchy.children.extend(child_hierarchy.children.into_iter());
82                    hierarchy.properties.extend(child_hierarchy.properties.into_iter());
83                    hierarchy.missing.extend(child_hierarchy.missing.into_iter());
84                }
85            },
86        }
87    }
88    hierarchy
89}
90
91/// Reads the given `ReadableTree` into a DiagnosticsHierarchy.
92/// This reads versions 1 and 2 of the Inspect Format.
93pub async fn read<T>(tree: &T) -> Result<DiagnosticsHierarchy, ReaderError>
94where
95    T: ReadableTree + Send + Sync,
96{
97    load_snapshot_tree(tree, None).await?.try_into()
98}
99
100/// Reads the given `ReadableTree` into a DiagnosticsHierarchy with Lazy Node timeout.
101/// This reads versions 1 and 2 of the Inspect Format.
102pub async fn read_with_timeout<T>(
103    tree: &T,
104    lazy_node_timeout: Duration,
105) -> Result<DiagnosticsHierarchy, ReaderError>
106where
107    T: ReadableTree + Send + Sync,
108{
109    load_snapshot_tree(tree, Some(lazy_node_timeout)).await?.try_into()
110}
111
112fn load_snapshot_tree<T>(
113    tree: &T,
114    lazy_child_timeout: Option<Duration>,
115) -> BoxFuture<'_, Result<SnapshotTree, ReaderError>>
116where
117    T: ReadableTree + Send + Sync,
118{
119    async move {
120        let results = if let Some(t) = lazy_child_timeout {
121            future::join(tree.vmo(), tree.tree_names())
122                .on_timeout(t.after_now(), || {
123                    (Err(ReaderError::TreeTimedOut), Err(ReaderError::TreeTimedOut))
124                })
125                .await
126        } else {
127            future::join(tree.vmo(), tree.tree_names()).await
128        };
129
130        let vmo = results.0?;
131        let children_names = results.1?;
132        let mut children = BTreeMap::new();
133        // TODO(miguelfrde): remove recursion or limit depth.
134        for child_name in children_names {
135            let result = if let Some(t) = lazy_child_timeout {
136                tree.read_tree(&child_name)
137                    .on_timeout(t.after_now(), || Err(ReaderError::TreeTimedOut))
138                    .and_then(|child_tree| load(child_tree, lazy_child_timeout))
139                    .await
140            } else {
141                tree.read_tree(&child_name).and_then(|child_tree| load(child_tree, None)).await
142            };
143            children.insert(child_name, result);
144        }
145        Ok(SnapshotTree { snapshot: Snapshot::try_from(&vmo)?, children })
146    }
147    .boxed()
148}
149
150async fn load<T>(tree: T, lazy_node_timeout: Option<Duration>) -> Result<SnapshotTree, ReaderError>
151where
152    T: ReadableTree + Send + Sync,
153{
154    load_snapshot_tree(&tree, lazy_node_timeout).await
155}
156
157#[cfg(test)]
158mod tests {
159    use super::*;
160    use crate::{reader, Inspector, InspectorConfig};
161    use diagnostics_assertions::{assert_data_tree, assert_json_diff};
162    use inspect_format::constants;
163
164    #[fuchsia::test]
165    async fn test_read() -> Result<(), anyhow::Error> {
166        let inspector = test_inspector();
167        let hierarchy = read(&inspector).await?;
168        assert_data_tree!(hierarchy, root: {
169            int: 3i64,
170            "lazy-node": {
171                a: "test",
172                child: {
173                    double: 3.25,
174                },
175            }
176        });
177        Ok(())
178    }
179
180    #[fuchsia::test]
181    async fn test_load_snapshot_tree() -> Result<(), anyhow::Error> {
182        let inspector = test_inspector();
183        let mut snapshot_tree = load_snapshot_tree(&inspector, None).await?;
184
185        let root_hierarchy: DiagnosticsHierarchy =
186            PartialNodeHierarchy::try_from(snapshot_tree.snapshot)?.into();
187        assert_eq!(snapshot_tree.children.keys().collect::<Vec<&String>>(), vec!["lazy-node-0"]);
188        assert_data_tree!(root_hierarchy, root: {
189            int: 3i64,
190        });
191
192        let mut lazy_node = snapshot_tree.children.remove("lazy-node-0").unwrap().unwrap();
193        let lazy_node_hierarchy: DiagnosticsHierarchy =
194            PartialNodeHierarchy::try_from(lazy_node.snapshot)?.into();
195        assert_eq!(lazy_node.children.keys().collect::<Vec<&String>>(), vec!["lazy-values-0"]);
196        assert_data_tree!(lazy_node_hierarchy, root: {
197            a: "test",
198            child: {},
199        });
200
201        let lazy_values = lazy_node.children.remove("lazy-values-0").unwrap().unwrap();
202        let lazy_values_hierarchy = PartialNodeHierarchy::try_from(lazy_values.snapshot)?;
203        assert_eq!(lazy_values.children.keys().len(), 0);
204        assert_data_tree!(lazy_values_hierarchy, root: {
205            double: 3.25,
206        });
207
208        Ok(())
209    }
210
211    #[fuchsia::test]
212    async fn read_with_hanging_lazy_node() -> Result<(), anyhow::Error> {
213        let inspector = Inspector::default();
214        let root = inspector.root();
215        root.record_string("child", "value");
216
217        root.record_lazy_values("lazy-node-always-hangs", || {
218            async move {
219                fuchsia_async::Timer::new(Duration::from_secs(30 * 60).after_now()).await;
220                Ok(Inspector::default())
221            }
222            .boxed()
223        });
224
225        root.record_int("int", 3);
226
227        let hierarchy = read_with_timeout(&inspector, Duration::from_secs(2)).await?;
228        assert_json_diff!(hierarchy, root: {
229            child: "value",
230            int: 3i64,
231        });
232
233        Ok(())
234    }
235
236    #[fuchsia::test]
237    async fn read_too_big_string() {
238        // magic size is the amount of data that can be written. Basically it is the size of the
239        // VMO minus all of the header and bookkeeping data stored in the VMO
240        let magic_size_found_by_experiment = 259076;
241        let inspector =
242            Inspector::new(InspectorConfig::default().size(constants::DEFAULT_VMO_SIZE_BYTES));
243        let string_head = "X".repeat(magic_size_found_by_experiment);
244        let string_tail =
245            "Y".repeat((constants::DEFAULT_VMO_SIZE_BYTES * 2) - magic_size_found_by_experiment);
246        let full_string = format!("{string_head}{string_tail}");
247
248        inspector.root().record_int(full_string, 5);
249        let hierarchy = reader::read(&inspector).await.unwrap();
250        // somewhat redundant to check both things, but checking the size makes fencepost errors
251        // obvious, while checking the contents make real problems obvious
252        assert_eq!(hierarchy.properties[0].key().len(), string_head.len());
253        assert_eq!(hierarchy.properties[0].key(), &string_head);
254    }
255
256    #[fuchsia::test]
257    async fn missing_value_parse_failure() -> Result<(), anyhow::Error> {
258        let inspector = Inspector::default();
259        let _lazy_child = inspector.root().create_lazy_child("lazy", || {
260            async move {
261                // For the sake of the test, force an invalid vmo.
262                Ok(Inspector::new(InspectorConfig::default().no_op()))
263            }
264            .boxed()
265        });
266        let hierarchy = reader::read(&inspector).await?;
267        assert_eq!(hierarchy.missing.len(), 1);
268        assert_eq!(hierarchy.missing[0].reason, MissingValueReason::LinkParseFailure);
269        assert_data_tree!(hierarchy, root: {});
270        Ok(())
271    }
272
273    #[fuchsia::test]
274    async fn missing_value_not_found() -> Result<(), anyhow::Error> {
275        let inspector = Inspector::default();
276        if let Some(state) = inspector.state() {
277            let mut state = state.try_lock().expect("lock state");
278            state
279                .allocate_link("missing", "missing-404", LinkNodeDisposition::Child, 0.into())
280                .unwrap();
281        }
282        let hierarchy = reader::read(&inspector).await?;
283        assert_eq!(hierarchy.missing.len(), 1);
284        assert_eq!(hierarchy.missing[0].reason, MissingValueReason::LinkNotFound);
285        assert_eq!(hierarchy.missing[0].name, "missing");
286        assert_data_tree!(hierarchy, root: {});
287        Ok(())
288    }
289
290    fn test_inspector() -> Inspector {
291        let inspector = Inspector::default();
292        let root = inspector.root();
293        root.record_int("int", 3);
294        root.record_lazy_child("lazy-node", || {
295            async move {
296                let inspector = Inspector::default();
297                inspector.root().record_string("a", "test");
298                let child = inspector.root().create_child("child");
299                child.record_lazy_values("lazy-values", || {
300                    async move {
301                        let inspector = Inspector::default();
302                        inspector.root().record_double("double", 3.25);
303                        Ok(inspector)
304                    }
305                    .boxed()
306                });
307                inspector.root().record(child);
308                Ok(inspector)
309            }
310            .boxed()
311        });
312        inspector
313    }
314}
fuchsia_inspect/reader/tree_reader.rs

fuchsia_inspect/reader/
tree_reader.rs
