| // Copyright 2020 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| use { |
| crate::component::*, |
| crate::io::{DirectoryProxyExt, MapChildren}, |
| anyhow::{Context, Result}, |
| async_trait::async_trait, |
| cs::{io::Directory, v2::V2Component}, |
| ffx_component_list_args::ComponentListCommand, |
| ffx_core::ffx_plugin, |
| fidl_fuchsia_developer_remotecontrol as rc, fidl_fuchsia_io as fio, |
| fuchsia_zircon_status::Status, |
| futures::future::ready, |
| }; |
| |
| mod component; |
| mod io; |
| |
| #[ffx_plugin()] |
| pub async fn list(rcs_proxy: rc::RemoteControlProxy, cmd: ComponentListCommand) -> Result<()> { |
| list_impl(rcs_proxy, cmd).await |
| } |
| |
| async fn list_impl(rcs_proxy: rc::RemoteControlProxy, _cmd: ComponentListCommand) -> Result<()> { |
| let (root, dir_server) = fidl::endpoints::create_proxy::<fio::DirectoryMarker>() |
| .context("creating hub root proxy")?; |
| rcs_proxy |
| .open_hub(dir_server) |
| .await? |
| .map_err(|i| Status::ok(i).unwrap_err()) |
| .context("opening hub")?; |
| let hub_dir = Directory::from_proxy(root); |
| let component = V2Component::explore(hub_dir).await; |
| component.print_tree(); |
| Ok(()) |
| } |
| |
| pub const V1_ROOT_COMPONENT: &'static str = "fuchsia-pkg://fuchsia.com/appmgr#meta/appmgr.cm"; |
| |
| pub const V1_HUB_PATH: &'static str = "exec/out/hub"; |
| |
| #[async_trait] |
| pub trait DirectoryProxyComponentExt { |
| async fn to_component_v2(self) -> Result<ComponentVersion2>; |
| |
| async fn to_component_v1(self) -> Result<ComponentVersion1>; |
| |
| async fn component_v1_children(&self) -> Result<Vec<ComponentVersion1>>; |
| |
| async fn to_realm(self) -> Result<Realm>; |
| } |
| |
| #[async_trait] |
| impl DirectoryProxyComponentExt for fio::DirectoryProxy { |
| async fn to_component_v2(self) -> Result<ComponentVersion2> { |
| let (url, id, component_type) = futures::try_join!( |
| self.read_file("url"), |
| self.read_file("id"), |
| self.read_file("component_type") |
| )?; |
| |
| let children = match url.as_ref() { |
| V1_ROOT_COMPONENT => vec![Component::V1( |
| self.open_dir(V1_HUB_PATH, fio::OPEN_RIGHT_READABLE)?.to_realm().await?, |
| )], |
| _ => self |
| .open_dir("children", fio::OPEN_RIGHT_READABLE)? |
| .map_children(fio::OPEN_RIGHT_READABLE, |c| c.to_component_v2()) |
| .await? |
| .drain(..) |
| .map(|c| Component::V2(c)) |
| .collect(), |
| }; |
| Ok(ComponentVersion2 { url, id, component_type, children }) |
| } |
| |
| async fn to_component_v1(self) -> Result<ComponentVersion1> { |
| let (id, name, url, merkleroot, children) = futures::join!( |
| self.read_file("job-id"), |
| self.read_file("name"), |
| self.read_file("url"), |
| self.read_file("in/pkg/meta"), |
| self.component_v1_children(), |
| ); |
| let (id, name, url, merkleroot, children) = |
| (id?.parse::<u32>()?, name?, url?, merkleroot.ok(), children?); |
| Ok(ComponentVersion1 { id, url, name, merkleroot, children }) |
| } |
| |
| async fn to_realm(self) -> Result<Realm> { |
| let (id, name, mut realms_stacked, components) = futures::try_join!( |
| self.read_file("job-id"), |
| self.read_file("name"), |
| self.open_dir("r", fio::OPEN_RIGHT_READABLE)?.map_children( |
| fio::OPEN_RIGHT_READABLE, |
| |realm_name| { |
| realm_name.map_children(fio::OPEN_RIGHT_READABLE, |realm_instance| { |
| realm_instance.to_realm() |
| }) |
| } |
| ), |
| self.component_v1_children(), |
| )?; |
| let id = id.parse::<u32>()?; |
| let realms = realms_stacked.drain(..).flatten().collect(); |
| Ok(Realm { id, name, realms, components }) |
| } |
| |
| async fn component_v1_children(&self) -> Result<Vec<ComponentVersion1>> { |
| Ok(self |
| .open_dir_checked("c", fio::OPEN_RIGHT_READABLE) |
| .await? |
| .map(|c| { |
| c.map_children(fio::OPEN_RIGHT_READABLE, |child_name| { |
| child_name.map_children(fio::OPEN_RIGHT_READABLE, |child_instance| { |
| child_instance.to_component_v1() |
| }) |
| }) |
| }) |
| .unwrap_or(Box::pin(ready(Ok(vec![])))) |
| .await? |
| .drain(..) |
| .flatten() |
| .collect()) |
| } |
| } |
| |
| #[cfg(test)] |
| mod test { |
| use super::*; |
| use crate::io::testing::{self as io_test, TreeBuilder}; |
| |
| trait ComponentExt { |
| fn as_v2<'a>(&'a self) -> Option<&'a ComponentVersion2>; |
| |
| fn as_v1<'a>(&'a self) -> Option<&'a Realm>; |
| } |
| |
| impl ComponentExt for Component { |
| fn as_v2<'a>(&'a self) -> Option<&'a ComponentVersion2> { |
| match self { |
| Component::V2(c) => Some(c), |
| _ => None, |
| } |
| } |
| |
| fn as_v1<'a>(&'a self) -> Option<&'a Realm> { |
| match self { |
| Component::V1(c) => Some(c), |
| _ => None, |
| } |
| } |
| } |
| |
| #[fuchsia_async::run_singlethreaded(test)] |
| async fn test_flat_hub() { |
| let mut root = io_test::TestDirentTree::root() |
| .add_file("url", "fuchsia-boot:///#meta/root.cm") |
| .add_file("id", "1") |
| .add_file("component_type", "excellent"); |
| root.add_dir("children"); |
| let root = io_test::setup_fake_directory(root); |
| let component = root.to_component_v2().await.unwrap(); |
| assert_eq!(component.url, "fuchsia-boot:///#meta/root.cm"); |
| assert_eq!(component.id, "1"); |
| assert_eq!(component.component_type, "excellent"); |
| assert_eq!(component.children.len(), 0); |
| } |
| |
| trait ComponentBuilder { |
| /// Add's a "leaf" component, meaning subsequent builder chains will append to whatever |
| /// directory this component is in. |
| fn add_v1_component_leaf(self, name: &str, job_id: &str, merkleroot: Option<&str>) -> Self; |
| |
| /// Add's a "leaf" component, meaning subsequent builder chains will append to whatever |
| /// directory this component is in. |
| fn add_v2_component_leaf(self, name: &str, id: &str, component_type: &str) -> Self; |
| |
| fn add_v2_component_chain(self, name: &str, id: &str, component_type: &str) -> Self; |
| } |
| |
| impl ComponentBuilder for &mut io_test::TestDirentTree { |
| fn add_v1_component_leaf(self, name: &str, job_id: &str, merkleroot: Option<&str>) -> Self { |
| let base_dir = self |
| .add_dir(name.clone()) |
| .add_dir(job_id.clone()) |
| .add_file("job-id", job_id.clone()) |
| .add_file("url", format!("{}.cmx", name).as_ref()) |
| .add_file("name", name.clone()); |
| if let Some(merkleroot) = merkleroot { |
| base_dir.add_dir("in").add_dir("pkg").add_file("meta", merkleroot); |
| } |
| self |
| } |
| |
| fn add_v2_component_leaf(self, name: &str, id: &str, component_type: &str) -> Self { |
| self.add_v2_component_chain(name, id, component_type); |
| self |
| } |
| |
| fn add_v2_component_chain(self, name: &str, id: &str, component_type: &str) -> Self { |
| self.add_dir(name.clone()) |
| .add_file("url", format!("{}.cm", name).as_ref()) |
| .add_file("id", id) |
| .add_file("component_type", component_type) |
| .add_dir("children") |
| } |
| } |
| |
| fn make_v1_hub_tree(root: &mut io_test::TestDirentTree) { |
| root.add_file("job-id", "999") |
| .add_file("name", "app") |
| .add_dir("c") |
| .add_v1_component_leaf("sysmgr", "123", Some("12345")) |
| .add_v1_component_leaf("tiles", "1234", None); |
| |
| let realm = root.add_dir("r").add_dir("realm").add_dir("456"); |
| realm.add_dir("r"); |
| realm |
| .add_file("name", "realm") |
| .add_file("job-id", "456") |
| .add_dir("c") |
| .add_v1_component_leaf("foo", "4567", None); |
| } |
| |
| // Root is special as it has no self-named directory. |
| fn hub_root_setup(root: &mut io_test::TestDirentTree) -> &mut io_test::TestDirentTree { |
| root.add_file("url", "root.cm").add_file("id", "1").add_file("component_type", "fun"); |
| root.add_dir("children") |
| } |
| |
| #[fuchsia_async::run_singlethreaded(test)] |
| async fn test_hub_tree() { |
| // Intended hub topo: |
| // |
| // root -| |
| // | |
| // |-----> bootstrap ---> appmgr --------|----> sysmgr.cmx (m) |
| // | | |
| // | |----> tiles.cmx |
| // | | |
| // | |----> realm ---> foo.cmx |
| // |-----> console ----> driver_manager |
| // |
| let mut root = io_test::TestDirentTree::root(); |
| let root_component = hub_root_setup(&mut root); |
| #[rustfmt::skip] |
| root_component |
| .add_v2_component_chain("console", "3", "fabulous") |
| .add_v2_component_leaf("driver_manager", "7", "crunchy"); |
| let appmgr = |
| root_component.add_v2_component_chain("bootstrap", "2", "spicy").add_dir("appmgr"); |
| |
| // Appmgr is a little special for its setup. |
| appmgr.add_dir("children"); |
| appmgr |
| .add_file("id", "8") |
| .add_file("url", V1_ROOT_COMPONENT) |
| .add_file("component_type", "extra_special"); |
| let v1_hub_root = appmgr.add_dir("exec").add_dir("out").add_dir("hub"); |
| make_v1_hub_tree(v1_hub_root); |
| |
| let root = io_test::setup_fake_directory(root).to_component_v2().await.unwrap(); |
| assert_eq!(root.url, "root.cm"); |
| assert_eq!(root.id, "1"); |
| assert_eq!(root.component_type, "fun"); |
| assert_eq!(root.children.len(), 2); |
| let bootstrap = root |
| .children |
| .iter() |
| .find(|c| c.as_v2().unwrap().url == "bootstrap.cm") |
| .unwrap() |
| .as_v2() |
| .unwrap(); |
| assert_eq!(bootstrap.id, "2"); |
| assert_eq!(bootstrap.component_type, "spicy"); |
| assert_eq!(bootstrap.children.len(), 1); |
| let appmgr = bootstrap.children[0].as_v2().unwrap(); |
| assert_eq!(appmgr.id, "8"); |
| assert_eq!(appmgr.url, V1_ROOT_COMPONENT); |
| assert_eq!(appmgr.component_type, "extra_special"); |
| assert_eq!(appmgr.children.len(), 1); |
| let app_realm = appmgr.children[0].as_v1().unwrap(); |
| assert_eq!(app_realm.id, 999); |
| assert_eq!(app_realm.name, "app"); |
| assert_eq!(app_realm.components.len(), 2); |
| assert_eq!(app_realm.realms.len(), 1); |
| let sysmgr = app_realm.components.iter().find(|c| c.name == "sysmgr").unwrap(); |
| assert_eq!(sysmgr.url, "sysmgr.cmx"); |
| assert_eq!(sysmgr.id, 123); |
| assert_eq!(sysmgr.merkleroot, Some("12345".to_owned())); |
| assert_eq!(sysmgr.children.len(), 0); |
| let tiles = app_realm.components.iter().find(|c| c.name == "tiles").unwrap(); |
| assert_eq!(tiles.url, "tiles.cmx"); |
| assert_eq!(tiles.id, 1234); |
| assert_eq!(tiles.merkleroot, None); |
| assert_eq!(tiles.children.len(), 0); |
| let subrealm = &app_realm.realms[0]; |
| assert_eq!(subrealm.name, "realm"); |
| assert_eq!(subrealm.id, 456); |
| assert_eq!(subrealm.realms.len(), 0); |
| assert_eq!(subrealm.components.len(), 1); |
| let foo = &subrealm.components[0]; |
| assert_eq!(foo.name, "foo"); |
| assert_eq!(foo.url, "foo.cmx"); |
| assert_eq!(foo.id, 4567); |
| assert_eq!(foo.merkleroot, None); |
| assert_eq!(foo.children.len(), 0); |
| let console = root |
| .children |
| .iter() |
| .find(|c| c.as_v2().unwrap().url == "console.cm") |
| .unwrap() |
| .as_v2() |
| .unwrap(); |
| assert_eq!(console.id, "3"); |
| assert_eq!(console.component_type, "fabulous"); |
| assert_eq!(console.children.len(), 1); |
| let driver_manager = console.children[0].as_v2().unwrap(); |
| assert_eq!(driver_manager.id, "7"); |
| assert_eq!(driver_manager.url, "driver_manager.cm"); |
| assert_eq!(driver_manager.component_type, "crunchy"); |
| } |
| } |
