inspect_validator/
puppet.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 super::data::{self, Data, LazyNode};
6use super::metrics::Metrics;
7use super::PUPPET_MONIKER;
8use anyhow::{format_err, Error};
9use fuchsia_component::client as fclient;
10use serde::Serialize;
11use zx::{self as zx, Vmo};
12use {fidl_diagnostics_validate as validate, fidl_fuchsia_inspect as fidl_inspect};
13
14pub const VMO_SIZE: u64 = 4096;
15
16#[derive(Debug)]
17pub struct Config {
18    pub diff_type: DiffType,
19    pub printable_name: String,
20    pub has_runner_node: bool,
21    pub test_archive: bool,
22}
23
24/// When reporting a discrepancy between local and remote Data trees, should the output include:
25/// - The full rendering of both trees?
26/// - The condensed diff between the trees? (This may still be quite large.)
27/// - Both full and condensed renderings?
28#[derive(Clone, Copy, Debug, Default, Serialize)]
29pub enum DiffType {
30    #[default]
31    Full,
32    Diff,
33    Both,
34}
35
36impl From<Option<validate::DiffType>> for DiffType {
37    fn from(original: Option<validate::DiffType>) -> Self {
38        match original {
39            Some(validate::DiffType::Diff) => Self::Diff,
40            Some(validate::DiffType::Both) => Self::Both,
41            _ => Self::Full,
42        }
43    }
44}
45
46pub struct Puppet {
47    pub vmo: Vmo,
48    // Need to remember the connection to avoid dropping the VMO
49    connection: Connection,
50    // A printable name for output to the user.
51    pub config: Config,
52}
53
54impl Puppet {
55    pub async fn apply(
56        &mut self,
57        action: &mut validate::Action,
58    ) -> Result<validate::TestResult, Error> {
59        Ok(self.connection.fidl.act(action).await?)
60    }
61
62    pub async fn apply_lazy(
63        &mut self,
64        lazy_action: &mut validate::LazyAction,
65    ) -> Result<validate::TestResult, Error> {
66        match &self.connection.root_link_channel {
67            Some(_) => Ok(self.connection.fidl.act_lazy(lazy_action).await?),
68            None => Ok(validate::TestResult::Unimplemented),
69        }
70    }
71
72    pub async fn publish(&mut self) -> Result<validate::TestResult, Error> {
73        Ok(self.connection.fidl.publish().await?)
74    }
75
76    pub async fn connect() -> Result<Self, Error> {
77        Puppet::initialize_with_connection(Connection::connect().await?).await
78    }
79
80    pub(crate) async fn shutdown(self) {
81        let lifecycle_controller =
82            fclient::connect_to_protocol::<fidl_fuchsia_sys2::LifecycleControllerMarker>().unwrap();
83        lifecycle_controller
84            .stop_instance(&format!("./{}", PUPPET_MONIKER))
85            .await
86            .unwrap()
87            .unwrap();
88    }
89
90    /// Get the printable name associated with this puppet/test
91    pub fn printable_name(&self) -> &str {
92        &self.config.printable_name
93    }
94
95    #[cfg(test)]
96    pub async fn connect_local(local_fidl: validate::InspectPuppetProxy) -> Result<Puppet, Error> {
97        let mut puppet = Puppet::initialize_with_connection(Connection::new(local_fidl)).await?;
98        puppet.config.test_archive = false;
99        Ok(puppet)
100    }
101
102    async fn initialize_with_connection(mut connection: Connection) -> Result<Puppet, Error> {
103        Ok(Puppet {
104            vmo: connection.initialize_vmo().await?,
105            config: connection.get_config().await?,
106            connection,
107        })
108    }
109
110    pub async fn read_data(&self) -> Result<Data, Error> {
111        Ok(match &self.connection.root_link_channel {
112            None => data::Scanner::try_from(&self.vmo)?.data(),
113            Some(root_link_channel) => {
114                let vmo_tree = LazyNode::new(root_link_channel.clone()).await?;
115                data::Scanner::try_from(vmo_tree)?.data()
116            }
117        })
118    }
119
120    pub fn metrics(&self) -> Result<Metrics, Error> {
121        Ok(data::Scanner::try_from(&self.vmo)?.metrics())
122    }
123}
124
125struct Connection {
126    fidl: validate::InspectPuppetProxy,
127    // Connection to Tree FIDL if Puppet supports it.
128    // Puppets can add support by implementing InitializeTree method.
129    root_link_channel: Option<fidl_inspect::TreeProxy>,
130}
131
132impl Connection {
133    async fn connect() -> Result<Self, Error> {
134        let puppet_fidl = fclient::connect_to_protocol::<validate::InspectPuppetMarker>().unwrap();
135        Ok(Self::new(puppet_fidl))
136    }
137
138    async fn get_config(&self) -> Result<Config, Error> {
139        let (printable_name, opts) = self.fidl.get_config().await?;
140        Ok(Config {
141            diff_type: opts.diff_type.into(),
142            printable_name,
143            has_runner_node: opts.has_runner_node.unwrap_or(false),
144            test_archive: true,
145        })
146    }
147
148    async fn fetch_link_channel(
149        fidl: &validate::InspectPuppetProxy,
150    ) -> Option<fidl_inspect::TreeProxy> {
151        let params =
152            validate::InitializationParams { vmo_size: Some(VMO_SIZE), ..Default::default() };
153        let response = fidl.initialize_tree(&params).await;
154        if let Ok((Some(tree_client_end), validate::TestResult::Ok)) = response {
155            Some(tree_client_end.into_proxy())
156        } else {
157            None
158        }
159    }
160
161    async fn get_vmo_handle(channel: &fidl_inspect::TreeProxy) -> Result<Vmo, Error> {
162        let tree_content = channel.get_content().await?;
163        let buffer = tree_content.buffer.ok_or(format_err!("Buffer doesn't contain VMO"))?;
164        Ok(buffer.vmo)
165    }
166
167    fn new(fidl: validate::InspectPuppetProxy) -> Self {
168        Self { fidl, root_link_channel: None }
169    }
170
171    async fn initialize_vmo(&mut self) -> Result<Vmo, Error> {
172        self.root_link_channel = Self::fetch_link_channel(&self.fidl).await;
173        match &self.root_link_channel {
174            Some(root_link_channel) => Self::get_vmo_handle(root_link_channel).await,
175            None => {
176                let params = validate::InitializationParams {
177                    vmo_size: Some(VMO_SIZE),
178                    ..Default::default()
179                };
180                let handle: Option<zx::Handle>;
181                let out = self.fidl.initialize(&params).await?;
182                if let (Some(out_handle), _) = out {
183                    handle = Some(out_handle);
184                } else {
185                    return Err(format_err!("Didn't get a VMO handle"));
186                }
187                match handle {
188                    Some(unwrapped_handle) => Ok(Vmo::from(unwrapped_handle)),
189                    None => Err(format_err!("Failed to unwrap handle")),
190                }
191            }
192        }
193    }
194}
195
196#[cfg(test)]
197pub(crate) mod tests {
198    use super::*;
199    use crate::create_node;
200    use anyhow::Context as _;
201    use fidl::endpoints::{create_proxy, RequestStream, ServerEnd};
202    use fidl_diagnostics_validate::{
203        Action, CreateNode, CreateNumericProperty, InspectPuppetMarker, InspectPuppetRequest,
204        InspectPuppetRequestStream, Options, TestResult, Value, ROOT_ID,
205    };
206    use fuchsia_async as fasync;
207    use fuchsia_inspect::{Inspector, InspectorConfig, IntProperty, Node};
208    use futures::prelude::*;
209    use log::info;
210    use std::collections::HashMap;
211    use zx::HandleBased;
212
213    #[fuchsia::test]
214    async fn test_fidl_loopback() -> Result<(), Error> {
215        let mut puppet = local_incomplete_puppet().await?;
216        assert_eq!(puppet.vmo.get_size().unwrap(), VMO_SIZE);
217        let tree = puppet.read_data().await?;
218        assert_eq!(tree.to_string(), "root ->".to_string());
219        let mut data = Data::new();
220        tree.compare(&data, DiffType::Full)?;
221        let mut action = create_node!(parent: ROOT_ID, id: 1, name: "child");
222        puppet.apply(&mut action).await?;
223        data.apply(&action)?;
224        let tree = data::Scanner::try_from(&puppet.vmo)?.data();
225        assert_eq!(tree.to_string(), "root ->\n> child ->".to_string());
226        tree.compare(&data, DiffType::Full)?;
227        Ok(())
228    }
229
230    // This is a partial implementation.
231    // All it can do is initialize, and then create nodes and int properties (which it
232    // will hold forever). Trying to create a uint property will return Unimplemented.
233    // Other actions will give various kinds of incorrect results.
234    pub(crate) async fn local_incomplete_puppet() -> Result<Puppet, Error> {
235        let (client_end, server_end) = create_proxy();
236        spawn_local_puppet(server_end).await;
237        Puppet::connect_local(client_end).await
238    }
239
240    async fn spawn_local_puppet(server_end: ServerEnd<InspectPuppetMarker>) {
241        fasync::Task::spawn(
242            async move {
243                // Inspector must be remembered so its VMO persists
244                let mut inspector_maybe: Option<Inspector> = None;
245                let mut nodes: HashMap<u32, Node> = HashMap::new();
246                let mut properties: HashMap<u32, IntProperty> = HashMap::new();
247                let server_chan = fasync::Channel::from_channel(server_end.into_channel());
248                let mut stream = InspectPuppetRequestStream::from_channel(server_chan);
249                while let Some(event) = stream.try_next().await? {
250                    match event {
251                        InspectPuppetRequest::GetConfig { responder } => {
252                            responder.send("*Local*", Options::default()).ok();
253                        }
254                        InspectPuppetRequest::Initialize { params, responder } => {
255                            let inspector = match params.vmo_size {
256                                Some(size) => {
257                                    Inspector::new(InspectorConfig::default().size(size as usize))
258                                }
259                                None => Inspector::default(),
260                            };
261                            responder
262                                .send(
263                                    inspector.duplicate_vmo().map(|v| v.into_handle()),
264                                    TestResult::Ok,
265                                )
266                                .context("responding to initialize")?;
267                            inspector_maybe = Some(inspector);
268                        }
269                        InspectPuppetRequest::Act { action, responder } => match action {
270                            Action::CreateNode(CreateNode { parent, id, name }) => {
271                                if let Some(ref inspector) = inspector_maybe {
272                                    let parent_node = if parent == ROOT_ID {
273                                        inspector.root()
274                                    } else {
275                                        nodes.get(&parent).unwrap()
276                                    };
277                                    let new_child = parent_node.create_child(name);
278                                    nodes.insert(id, new_child);
279                                }
280                                responder.send(TestResult::Ok)?;
281                            }
282                            Action::CreateNumericProperty(CreateNumericProperty {
283                                parent,
284                                id,
285                                name,
286                                value: Value::IntT(value),
287                            }) => {
288                                inspector_maybe.as_ref().map(|i| {
289                                    let parent_node = if parent == 0 {
290                                        i.root()
291                                    } else {
292                                        nodes.get(&parent).unwrap()
293                                    };
294                                    properties.insert(id, parent_node.create_int(name, value))
295                                });
296                                responder.send(TestResult::Ok)?;
297                            }
298                            Action::CreateNumericProperty(CreateNumericProperty {
299                                value: Value::UintT(_),
300                                ..
301                            }) => {
302                                responder.send(TestResult::Unimplemented)?;
303                            }
304
305                            _ => responder.send(TestResult::Illegal)?,
306                        },
307                        InspectPuppetRequest::InitializeTree { params: _, responder } => {
308                            responder.send(None, TestResult::Unimplemented)?;
309                        }
310                        InspectPuppetRequest::ActLazy { lazy_action: _, responder } => {
311                            responder.send(TestResult::Unimplemented)?;
312                        }
313                        InspectPuppetRequest::Publish { responder } => {
314                            responder.send(TestResult::Unimplemented)?;
315                        }
316                        InspectPuppetRequest::_UnknownMethod { .. } => {}
317                    }
318                }
319                Ok(())
320            }
321            .unwrap_or_else(|e: anyhow::Error| info!("error running validate interface: {:?}", e)),
322        )
323        .detach();
324    }
325}
inspect_validator/puppet.rs

inspect_validator/
puppet.rs
