| // Copyright 2022 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 { |
| anyhow::{self, Context}, |
| base_resolver_config::Config, |
| fidl::endpoints::{ClientEnd, Proxy}, |
| fidl_fuchsia_component_decl as fdecl, |
| fidl_fuchsia_component_resolution::{ |
| self as fresolution, ResolverRequest, ResolverRequestStream, |
| }, |
| fidl_fuchsia_io as fio, |
| fidl_fuchsia_pkg::PackageCacheMarker, |
| fidl_fuchsia_pkg_ext::BasePackageIndex, |
| fuchsia_component::{client::connect_to_protocol, server::ServiceFs}, |
| fuchsia_pkg::{ |
| transitional::{context_bytes_from_subpackages_map, subpackages_map_from_context_bytes}, |
| PackageDirectory, |
| }, |
| fuchsia_url::{ComponentUrl, PackageUrl}, |
| futures::prelude::*, |
| log::*, |
| }; |
| |
| pub(crate) async fn main() -> anyhow::Result<()> { |
| info!("started"); |
| |
| // Record configuration to inspect |
| let config = Config::take_from_startup_handle(); |
| let inspector = fuchsia_inspect::component::inspector(); |
| inspector.root().record_child("config", |config_node| config.record_inspect(config_node)); |
| |
| let mut service_fs = ServiceFs::new_local(); |
| service_fs.dir("svc").add_fidl_service(Services::BaseResolver); |
| service_fs.take_and_serve_directory_handle().context("failed to serve outgoing namespace")?; |
| let () = service_fs |
| .for_each_concurrent(None, |request| async { |
| match request { |
| Services::BaseResolver(stream) => { |
| serve(stream, &config) |
| .unwrap_or_else(|e| { |
| error!("failed to serve base resolver request: {:#}", e) |
| }) |
| .await |
| } |
| } |
| }) |
| .await; |
| |
| Ok(()) |
| } |
| |
| enum Services { |
| BaseResolver(ResolverRequestStream), |
| } |
| |
| async fn serve(mut stream: ResolverRequestStream, config: &Config) -> anyhow::Result<()> { |
| let pkg_cache = |
| connect_to_protocol::<PackageCacheMarker>().context("error connecting to package cache")?; |
| let base_package_index = BasePackageIndex::from_proxy(&pkg_cache) |
| .await |
| .context("failed to load base package index")?; |
| let packages_dir = fuchsia_fs::open_directory_in_namespace( |
| "/pkgfs/packages", |
| fio::OpenFlags::RIGHT_READABLE | fio::OpenFlags::RIGHT_EXECUTABLE, |
| ) |
| .context("failed to open /pkgfs/packages")?; |
| while let Some(request) = |
| stream.try_next().await.context("failed to read request from FIDL stream")? |
| { |
| match request { |
| ResolverRequest::Resolve { component_url, responder } => { |
| let mut result = |
| resolve_component(&component_url, &packages_dir).await.map_err(|err| { |
| let fidl_err = (&err).into(); |
| error!( |
| "failed to resolve component URL {}: {:#}", |
| &component_url, |
| anyhow::anyhow!(err) |
| ); |
| fidl_err |
| }); |
| responder.send(&mut result).context("failed sending response")?; |
| } |
| ResolverRequest::ResolveWithContext { component_url, context, responder } => { |
| if config.enable_subpackages { |
| let mut result = resolve_component_with_context( |
| &component_url, |
| &context, |
| &packages_dir, |
| &base_package_index, |
| ) |
| .await |
| .map_err(|err| { |
| let fidl_err = (&err).into(); |
| error!( |
| "failed to resolve component URL {} with context {:?}: {:#}", |
| &component_url, |
| &context, |
| anyhow::anyhow!(err) |
| ); |
| fidl_err |
| }); |
| responder.send(&mut result).context("failed sending response")?; |
| } else { |
| error!( |
| "base-resolver ResolveWithContext is disabled. Config value `enable_subpackages` is false. Cannot resolve component URL {:?} with context {:?}", |
| component_url, |
| context |
| ); |
| responder |
| .send(&mut Err(fresolution::ResolverError::Internal)) |
| .context("failed sending response")?; |
| } |
| } |
| }; |
| } |
| Ok(()) |
| } |
| |
| async fn resolve_component( |
| component_url: &str, |
| packages_dir: &fio::DirectoryProxy, |
| ) -> Result<fresolution::Component, crate::ResolverError> { |
| resolve_component_async(component_url, None, packages_dir, None).await |
| } |
| |
| async fn resolve_component_with_context( |
| component_url: &str, |
| context: &Vec<u8>, |
| packages_dir: &fio::DirectoryProxy, |
| base_package_index: &BasePackageIndex, |
| ) -> Result<fresolution::Component, crate::ResolverError> { |
| resolve_component_async(component_url, Some(context), packages_dir, Some(base_package_index)) |
| .await |
| } |
| |
| async fn resolve_component_async( |
| component_url_str: &str, |
| some_incoming_context: Option<&Vec<u8>>, |
| packages_dir: &fio::DirectoryProxy, |
| some_base_package_index: Option<&BasePackageIndex>, |
| ) -> Result<fresolution::Component, crate::ResolverError> { |
| let component_url = ComponentUrl::parse(component_url_str)?; |
| let package = resolve_package_async( |
| component_url.package_url(), |
| some_incoming_context, |
| packages_dir, |
| some_base_package_index, |
| ) |
| .await?; |
| |
| let data = mem_util::open_file_data(&package.dir, &component_url.resource()) |
| .await |
| .map_err(crate::ResolverError::ComponentNotFound)?; |
| let raw_bytes = mem_util::bytes_from_data(&data).map_err(crate::ResolverError::ReadManifest)?; |
| let decl: fdecl::Component = fidl::encoding::decode_persistent(&raw_bytes[..]) |
| .map_err(crate::ResolverError::ParsingManifest)?; |
| |
| let config_values = if let Some(config_decl) = decl.config.as_ref() { |
| // if we have a config declaration, we need to read the value file from the package dir |
| let strategy = |
| config_decl.value_source.as_ref().ok_or(crate::ResolverError::InvalidConfigSource)?; |
| let config_path = match strategy { |
| fdecl::ConfigValueSource::PackagePath(path) => path, |
| other => return Err(crate::ResolverError::UnsupportedConfigSource(other.to_owned())), |
| }; |
| Some( |
| mem_util::open_file_data(&package.dir, &config_path) |
| .await |
| .map_err(crate::ResolverError::ConfigValuesNotFound)?, |
| ) |
| } else { |
| None |
| }; |
| |
| let package_dir = ClientEnd::new( |
| package.dir.into_channel().expect("could not convert proxy to channel").into_zx_channel(), |
| ); |
| Ok(fresolution::Component { |
| url: Some(component_url_str.to_string()), |
| resolution_context: Some(package.context), |
| decl: Some(data), |
| package: Some(fresolution::Package { |
| url: Some(component_url.package_url().to_string()), |
| directory: Some(package_dir), |
| ..fresolution::Package::EMPTY |
| }), |
| config_values, |
| ..fresolution::Component::EMPTY |
| }) |
| } |
| |
| #[derive(Debug)] |
| struct ResolvedPackage { |
| dir: fio::DirectoryProxy, |
| context: Vec<u8>, |
| } |
| |
| async fn resolve_package_async( |
| package_url: &PackageUrl, |
| some_incoming_context: Option<&Vec<u8>>, |
| packages_dir: &fio::DirectoryProxy, |
| some_base_package_index: Option<&BasePackageIndex>, |
| ) -> Result<ResolvedPackage, crate::ResolverError> { |
| let (package_name, some_variant) = match package_url { |
| PackageUrl::Relative(relative) => { |
| let context = some_incoming_context.ok_or_else(|| { |
| crate::ResolverError::RelativeUrlMissingContext(package_url.to_string()) |
| })?; |
| // TODO(fxbug.dev/101492): Update base-resolver to use blobfs directly, |
| // and allow subpackage lookup to resolve subpackages from blobfs via |
| // the blobid (package hash). Then base-resolver will no longer need |
| // access to pkgfs-packages or to the package index (from PackageCache). |
| let base_package_index = |
| some_base_package_index.ok_or_else(|| crate::ResolverError::Internal)?; |
| let subpackage_hashes = subpackages_map_from_context_bytes(context) |
| .map_err(|err| crate::ResolverError::ReadingContext(err))?; |
| let hash = subpackage_hashes.get(relative).ok_or_else(|| { |
| crate::ResolverError::SubpackageNotFound(anyhow::format_err!( |
| "Subpackage '{}' not found in context: {:?}", |
| relative, |
| subpackage_hashes |
| )) |
| })?; |
| let absolute = base_package_index.get_url(&(*hash).into()).ok_or_else(|| { |
| crate::ResolverError::SubpackageNotInBase(anyhow::format_err!( |
| "Subpackage '{}' with hash '{}' is not in base", |
| relative, |
| hash |
| )) |
| })?; |
| (absolute.name(), absolute.variant()) |
| } |
| PackageUrl::Absolute(absolute) => { |
| if absolute.host() != "fuchsia.com" { |
| return Err(crate::ResolverError::UnsupportedRepo); |
| } |
| if absolute.hash().is_some() { |
| return Err(crate::ResolverError::PackageHashNotSupported); |
| } |
| (absolute.name(), absolute.variant()) |
| } |
| }; |
| // Package contents are available at `packages/$PACKAGE_NAME/0`. |
| let dir = fuchsia_fs::directory::open_directory( |
| packages_dir, |
| &format!("{}/{}", package_name.as_ref(), some_variant.map(|v| v.as_ref()).unwrap_or("0")), |
| fio::OpenFlags::RIGHT_READABLE | fio::OpenFlags::RIGHT_EXECUTABLE, |
| ) |
| .await |
| .map_err(crate::ResolverError::PackageNotFound)?; |
| let package_dir = PackageDirectory::from_proxy(dir); |
| let context = fabricate_package_context(&package_dir) |
| .map_err(|err| crate::ResolverError::CreatingContext(anyhow::anyhow!(err))) |
| .await?; |
| Ok(ResolvedPackage { dir: package_dir.into_proxy(), context }) |
| } |
| |
| async fn fabricate_package_context(package_dir: &PackageDirectory) -> anyhow::Result<Vec<u8>> { |
| let meta = package_dir.meta_subpackages().await?; |
| Ok(context_bytes_from_subpackages_map(&meta.into_subpackages())?.unwrap_or(vec![])) |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use { |
| super::*, |
| assert_matches::assert_matches, |
| fidl::encoding::encode_persistent_with_context, |
| fidl::endpoints::{create_proxy, ServerEnd}, |
| fidl::prelude::*, |
| fidl_fuchsia_component_config as fconfig, fidl_fuchsia_component_decl as fdecl, |
| fidl_fuchsia_mem as fmem, |
| fidl_fuchsia_pkg_ext::BlobId, |
| fuchsia_hash::Hash, |
| fuchsia_pkg::MetaSubpackages, |
| fuchsia_url::{RelativePackageUrl, UnpinnedAbsolutePackageUrl}, |
| fuchsia_zircon::Status, |
| maplit::hashmap, |
| std::{iter::FromIterator, str::FromStr, sync::Arc}, |
| }; |
| |
| const SUBPACKAGE_NAME: &'static str = "my_subpackage"; |
| const SUBPACKAGE_HASH: &'static str = |
| "facefacefacefacefacefacefacefacefacefacefacefacefacefacefaceface"; |
| const OTHER_PACKAGE_HASH: &'static str = |
| "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"; |
| |
| /// A DirectoryEntry implementation that checks whether an expected set of flags |
| /// are set in the Open request. |
| struct FlagVerifier(fio::OpenFlags); |
| |
| impl vfs::directory::entry::DirectoryEntry for FlagVerifier { |
| fn open( |
| self: Arc<Self>, |
| _scope: vfs::execution_scope::ExecutionScope, |
| flags: fio::OpenFlags, |
| _mode: u32, |
| _path: vfs::path::Path, |
| server_end: ServerEnd<fio::NodeMarker>, |
| ) { |
| let status = if flags & self.0 != self.0 { Status::INVALID_ARGS } else { Status::OK }; |
| let stream = server_end.into_stream().expect("failed to create stream"); |
| let control_handle = stream.control_handle(); |
| control_handle |
| .send_on_open_( |
| status.into_raw(), |
| Some(&mut fio::NodeInfo::Directory(fio::DirectoryObject {})), |
| ) |
| .expect("failed to send OnOpen event"); |
| control_handle.shutdown_with_epitaph(status); |
| } |
| |
| fn entry_info(&self) -> vfs::directory::entry::EntryInfo { |
| vfs::directory::entry::EntryInfo::new(fio::INO_UNKNOWN, fio::DirentType::Directory) |
| } |
| } |
| |
| /// Serve a pseudo_dir with `RIGHT_EXECUTABLE` permissions, which can |
| /// emulate `/pkgfs/packages` for tests. |
| fn serve_executable_dir( |
| pseudo_dir: Arc<dyn vfs::directory::entry::DirectoryEntry>, |
| ) -> fio::DirectoryProxy { |
| let (proxy, server_end) = create_proxy::<fio::DirectoryMarker>() |
| .expect("failed to create DirectoryProxy/Server pair"); |
| let () = pseudo_dir.open( |
| vfs::execution_scope::ExecutionScope::new(), |
| fio::OpenFlags::RIGHT_READABLE | fio::OpenFlags::RIGHT_EXECUTABLE, |
| 0, |
| vfs::path::Path::dot(), |
| ServerEnd::new(server_end.into_channel()), |
| ); |
| proxy |
| } |
| |
| #[fuchsia::test] |
| async fn fails_to_resolve_package_unsupported_repo() { |
| let packages_dir = serve_executable_dir(vfs::pseudo_directory! {}); |
| assert_matches!( |
| resolve_component("fuchsia-pkg://fuchsia.ca/test-package#meta/foo.cm", &packages_dir) |
| .await, |
| Err(crate::ResolverError::UnsupportedRepo) |
| ); |
| } |
| |
| #[fuchsia::test] |
| async fn fails_to_resolve_component_invalid_url() { |
| let packages_dir = serve_executable_dir(vfs::pseudo_directory! {}); |
| assert_matches!( |
| resolve_component("fuchsia://fuchsia.com/foo#meta/bar.cm", &packages_dir).await, |
| Err(crate::ResolverError::InvalidUrl(_)) |
| ); |
| assert_matches!( |
| resolve_component("fuchsia-pkg://fuchsia.com/foo", &packages_dir).await, |
| Err(crate::ResolverError::InvalidUrl(_)) |
| ); |
| assert_matches!( |
| resolve_component("fuchsia-pkg://fuchsia.com/#meta/bar.cm", &packages_dir).await, |
| Err(crate::ResolverError::InvalidUrl(_)) |
| ); |
| assert_matches!( |
| resolve_component("fuchsia-pkg://fuchsia.ca/foo#meta/bar.cm", &packages_dir).await, |
| Err(crate::ResolverError::UnsupportedRepo) |
| ); |
| |
| let url_with_hash = concat!( |
| "fuchsia-pkg://fuchsia.com/test-package", |
| "?hash=f241b31d5913b66c90a44d44537d6bec62672e1f05dbc4c4f22b863b01c68749", |
| "#meta/test.cm" |
| ); |
| assert_matches!( |
| resolve_component(url_with_hash, &packages_dir).await, |
| Err(crate::ResolverError::PackageHashNotSupported) |
| ); |
| } |
| |
| #[fuchsia::test] |
| async fn fails_to_resolve_component_package_not_found() { |
| let packages_dir = serve_executable_dir(build_fake_packages_dir()); |
| assert_matches!( |
| resolve_component( |
| "fuchsia-pkg://fuchsia.com/missing-package#meta/foo.cm", |
| &packages_dir |
| ) |
| .await, |
| Err(crate::ResolverError::PackageNotFound(_)) |
| ); |
| } |
| |
| #[fuchsia::test] |
| async fn fails_to_resolve_component_missing_manifest() { |
| let packages_dir = serve_executable_dir(build_fake_packages_dir()); |
| assert_matches!( |
| resolve_component("fuchsia-pkg://fuchsia.com/test-package#meta/bar.cm", &packages_dir) |
| .await, |
| Err(crate::ResolverError::ComponentNotFound(_)) |
| ); |
| } |
| |
| #[fuchsia::test] |
| async fn resolves_component_vmo_manifest() { |
| let packages_dir = serve_executable_dir(build_fake_packages_dir()); |
| assert_matches!( |
| resolve_component("fuchsia-pkg://fuchsia.com/test-package#meta/vmo.cm", &packages_dir) |
| .await, |
| Ok(fresolution::Component { decl: Some(fmem::Data::Buffer(_)), .. }) |
| ); |
| } |
| |
| #[fuchsia::test] |
| async fn resolves_component_file_manifest() { |
| let packages_dir = serve_executable_dir(build_fake_packages_dir()); |
| assert_matches!( |
| resolve_component("fuchsia-pkg://fuchsia.com/test-package#meta/foo.cm", &packages_dir) |
| .await, |
| Ok(fresolution::Component { |
| decl: Some(fidl_fuchsia_mem::Data::Buffer(fidl_fuchsia_mem::Buffer { .. })), |
| .. |
| }) |
| ); |
| } |
| |
| #[fuchsia::test] |
| async fn resolves_component_in_subpackage() { |
| let parent_component_url = "fuchsia-pkg://fuchsia.com/test-package#meta/foo.cm"; |
| let subpackaged_component_url = SUBPACKAGE_NAME.to_string() + "#meta/subfoo.cm"; |
| |
| // Set up the base package index with the subpackage's hash that will |
| // be requested |
| let subpackage_as_base_package_url: UnpinnedAbsolutePackageUrl = |
| "fuchsia-pkg://fuchsia.com/toplevel-subpackage".parse().unwrap(); |
| let subpackage_blob_id = BlobId::parse(SUBPACKAGE_HASH).unwrap(); |
| let other_package_as_base_package_url: UnpinnedAbsolutePackageUrl = |
| "fuchsia-pkg://fuchsia.com/some-other-package".parse().unwrap(); |
| let other_package_blob_id = BlobId::parse(OTHER_PACKAGE_HASH).unwrap(); |
| let index = hashmap! { |
| subpackage_as_base_package_url => subpackage_blob_id, |
| other_package_as_base_package_url => other_package_blob_id, |
| }; |
| let base_package_index = BasePackageIndex::create_mock(index); |
| |
| let packages_dir = serve_executable_dir(build_fake_packages_dir()); |
| let parent_component = resolve_component(parent_component_url, &packages_dir) |
| .await |
| .expect("failed to resolve parent_component"); |
| |
| assert_matches!(parent_component.resolution_context, Some(..)); |
| assert_matches!( |
| resolve_component_with_context( |
| &subpackaged_component_url, |
| parent_component.resolution_context.as_ref().unwrap(), |
| &packages_dir, |
| &base_package_index, |
| ) |
| .await, |
| Ok(fresolution::Component { decl: Some(..), .. }), |
| "Could not resolve subpackaged component '{}' from context '{:?}'", |
| subpackaged_component_url, |
| parent_component.resolution_context |
| ); |
| } |
| |
| #[fuchsia::test] |
| async fn fails_to_resolve_component_in_subpackage_not_in_base() { |
| let parent_component_url = "fuchsia-pkg://fuchsia.com/test-package#meta/foo.cm"; |
| let subpackaged_component_url = SUBPACKAGE_NAME.to_string() + "#meta/other_subfoo.cm"; |
| |
| // Set up the base package index WITHOUT the subpackage's hash that will |
| // be requested |
| let other_package_as_base_package_url: UnpinnedAbsolutePackageUrl = |
| "fuchsia-pkg://fuchsia.com/some-other-package".parse().unwrap(); |
| let other_package_blob_id = BlobId::parse(OTHER_PACKAGE_HASH).unwrap(); |
| let index = hashmap! { |
| other_package_as_base_package_url => other_package_blob_id, |
| }; |
| let base_package_index = BasePackageIndex::create_mock(index); |
| assert!(base_package_index.contains_package(&other_package_blob_id)); |
| |
| let packages_dir = serve_executable_dir(build_fake_packages_dir()); |
| let parent_component = resolve_component(parent_component_url, &packages_dir) |
| .await |
| .expect("failed to resolve parent_component"); |
| |
| assert_matches!(parent_component.resolution_context, Some(..)); |
| assert_matches!( |
| resolve_component_with_context( |
| &subpackaged_component_url, |
| parent_component.resolution_context.as_ref().unwrap(), |
| &packages_dir, |
| &base_package_index, |
| ) |
| .await, |
| Err(crate::ResolverError::SubpackageNotInBase(..)) |
| ); |
| } |
| |
| #[fuchsia::test] |
| async fn fails_to_resolve_subpackage_name_not_in_parent_subpackages() { |
| let parent_component_url = "fuchsia-pkg://fuchsia.com/test-package#meta/foo.cm"; |
| let subpackaged_component_url = "subpackage_not_in_parent#meta/other_subfoo.cm"; |
| |
| // Set up the base package index WITHOUT the subpackage's hash that will |
| // be requested |
| let other_package_as_base_package_url: UnpinnedAbsolutePackageUrl = |
| "fuchsia-pkg://fuchsia.com/some-other-package".parse().unwrap(); |
| let other_package_blob_id = BlobId::parse(OTHER_PACKAGE_HASH).unwrap(); |
| let index = hashmap! { |
| other_package_as_base_package_url => other_package_blob_id, |
| }; |
| let base_package_index = BasePackageIndex::create_mock(index); |
| assert!(base_package_index.contains_package(&other_package_blob_id)); |
| |
| let packages_dir = serve_executable_dir(build_fake_packages_dir()); |
| let parent_component = resolve_component(parent_component_url, &packages_dir) |
| .await |
| .expect("failed to resolve parent_component"); |
| |
| assert_matches!(parent_component.resolution_context, Some(..)); |
| assert_matches!( |
| resolve_component_with_context( |
| &subpackaged_component_url, |
| parent_component.resolution_context.as_ref().unwrap(), |
| &packages_dir, |
| &base_package_index, |
| ) |
| .await, |
| Err(crate::ResolverError::SubpackageNotFound(..)) |
| ); |
| } |
| |
| #[fuchsia::test] |
| async fn resolves_component_with_config() { |
| let packages_dir = serve_executable_dir(build_fake_packages_dir()); |
| let component = resolve_component( |
| "fuchsia-pkg://fuchsia.com/test-package#meta/foo-with-config.cm", |
| &packages_dir, |
| ) |
| .await |
| .unwrap(); |
| assert_matches!( |
| component, |
| fresolution::Component { decl: Some(..), config_values: Some(..), .. } |
| ); |
| } |
| |
| #[fuchsia::test] |
| async fn fails_to_resolve_component_missing_config_values() { |
| let packages_dir = serve_executable_dir(build_fake_packages_dir()); |
| let error = resolve_component( |
| "fuchsia-pkg://fuchsia.com/test-package#meta/foo-without-config.cm", |
| &packages_dir, |
| ) |
| .await |
| .unwrap_err(); |
| assert_matches!(error, crate::ResolverError::ConfigValuesNotFound(..)); |
| } |
| |
| #[fuchsia::test] |
| async fn fails_to_resolve_component_bad_config_source() { |
| let packages_dir = serve_executable_dir(build_fake_packages_dir()); |
| let error = resolve_component( |
| "fuchsia-pkg://fuchsia.com/test-package#meta/foo-with-bad-config.cm", |
| &packages_dir, |
| ) |
| .await |
| .unwrap_err(); |
| assert_matches!(error, crate::ResolverError::InvalidConfigSource); |
| } |
| |
| fn build_fake_packages_dir() -> Arc<dyn vfs::directory::entry::DirectoryEntry> { |
| let subpackage = build_fake_subpackage_dir(); |
| let parent_package = build_fake_package_dir(); |
| vfs::pseudo_directory! { |
| "test-package" => vfs::pseudo_directory! { |
| "0" => parent_package, |
| }, |
| "toplevel-subpackage" => vfs::pseudo_directory! { |
| "0" => subpackage, |
| }, |
| } |
| } |
| |
| fn build_fake_package_dir() -> Arc<dyn vfs::directory::entry::DirectoryEntry> { |
| let cm_bytes = encode_persistent_with_context( |
| &fidl::encoding::Context { wire_format_version: fidl::encoding::WireFormatVersion::V2 }, |
| &mut fdecl::Component::EMPTY.clone(), |
| ) |
| .expect("failed to encode ComponentDecl FIDL"); |
| |
| let subpackages = MetaSubpackages::from_iter(vec![( |
| RelativePackageUrl::parse(SUBPACKAGE_NAME).unwrap(), |
| Hash::from_str(SUBPACKAGE_HASH).unwrap(), |
| )]); |
| |
| vfs::pseudo_directory! { |
| "meta" => vfs::pseudo_directory! { |
| "fuchsia.pkg" => vfs::pseudo_directory! { |
| "subpackages" => vfs::file::vmo::asynchronous::read_only_const(&serde_json::to_vec(&subpackages).unwrap()), |
| }, |
| "foo.cm" => vfs::file::vmo::asynchronous::read_only_const(&cm_bytes), |
| "foo-with-config.cm" => vfs::file::vmo::asynchronous::read_only_const( |
| &encode_persistent_with_context( |
| &fidl::encoding::Context { |
| wire_format_version: fidl::encoding::WireFormatVersion::V2 |
| }, |
| &mut fdecl::Component { |
| config: Some(fdecl::ConfigSchema { |
| value_source: Some( |
| fdecl::ConfigValueSource::PackagePath( |
| "meta/foo-with-config.cvf".to_string(), |
| ), |
| ), |
| ..fdecl::ConfigSchema::EMPTY |
| }), |
| ..fdecl::Component::EMPTY |
| } |
| ).unwrap() |
| ), |
| "foo-with-config.cvf" => vfs::file::vmo::asynchronous::read_only_const( |
| &encode_persistent_with_context( |
| &fidl::encoding::Context { |
| wire_format_version: fidl::encoding::WireFormatVersion::V2 |
| }, |
| &mut fconfig::ValuesData { |
| ..fconfig::ValuesData::EMPTY |
| } |
| ).unwrap() |
| ), |
| "foo-with-bad-config.cm" => vfs::file::vmo::asynchronous::read_only_const( |
| &encode_persistent_with_context( |
| &fidl::encoding::Context { |
| wire_format_version: fidl::encoding::WireFormatVersion::V2 |
| }, |
| &mut fdecl::Component { |
| config: Some(fdecl::ConfigSchema { |
| ..fdecl::ConfigSchema::EMPTY |
| }), |
| ..fdecl::Component::EMPTY |
| } |
| ).unwrap() |
| ), |
| "foo-without-config.cm" => vfs::file::vmo::asynchronous::read_only_const( |
| &encode_persistent_with_context( |
| &fidl::encoding::Context { |
| wire_format_version: fidl::encoding::WireFormatVersion::V2 |
| }, |
| &mut fdecl::Component { |
| config: Some(fdecl::ConfigSchema { |
| value_source: Some( |
| fdecl::ConfigValueSource::PackagePath( |
| "doesnt-exist.cvf".to_string(), |
| ), |
| ), |
| ..fdecl::ConfigSchema::EMPTY |
| }), |
| ..fdecl::Component::EMPTY |
| } |
| ).unwrap() |
| ), |
| "vmo.cm" => vfs::file::vmo::asynchronous::read_only_const(&cm_bytes), |
| } |
| } |
| } |
| |
| fn build_fake_subpackage_dir() -> Arc<dyn vfs::directory::entry::DirectoryEntry> { |
| let cm_bytes = encode_persistent_with_context( |
| &fidl::encoding::Context { wire_format_version: fidl::encoding::WireFormatVersion::V2 }, |
| &mut fdecl::Component::EMPTY.clone(), |
| ) |
| .expect("failed to encode ComponentDecl FIDL"); |
| |
| vfs::pseudo_directory! { |
| "meta" => vfs::pseudo_directory! { |
| "subfoo.cm" => vfs::file::vmo::asynchronous::read_only_const(&cm_bytes), |
| } |
| } |
| } |
| } |
