| // 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 { |
| anyhow::{anyhow, Context}, |
| fidl::endpoints::{create_proxy, ClientEnd, Proxy}, |
| fidl_fuchsia_component_decl as fdecl, fidl_fuchsia_component_resolution as fresolution, |
| fidl_fuchsia_io as fio, |
| fidl_fuchsia_pkg::{PackageResolverMarker, PackageResolverProxy}, |
| 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, Hash, PackageUrl, RelativePackageUrl, RepositoryUrl}, |
| futures::prelude::*, |
| log::*, |
| std::collections::HashMap, |
| thiserror::Error, |
| }; |
| |
| enum IncomingService { |
| Resolver(fresolution::ResolverRequestStream), |
| } |
| |
| #[fuchsia::main] |
| async fn main() -> anyhow::Result<()> { |
| info!("started"); |
| let mut service_fs = ServiceFs::new_local(); |
| service_fs.dir("svc").add_fidl_service(IncomingService::Resolver); |
| |
| service_fs.take_and_serve_directory_handle().context("failed to serve outgoing namespace")?; |
| |
| service_fs |
| .for_each_concurrent(None, |request| async { |
| if let Err(err) = match request { |
| IncomingService::Resolver(stream) => serve(stream).await, |
| } { |
| error!("failed to serve resolve request: {:#}", err); |
| } |
| }) |
| .await; |
| |
| Ok(()) |
| } |
| |
| async fn serve(mut stream: fresolution::ResolverRequestStream) -> anyhow::Result<()> { |
| let package_resolver = connect_to_protocol::<PackageResolverMarker>() |
| .context("failed to connect to PackageResolver service")?; |
| while let Some(request) = |
| stream.try_next().await.context("failed to read request from FIDL stream")? |
| { |
| match request { |
| fresolution::ResolverRequest::Resolve { component_url, responder } => { |
| let mut result = |
| resolve_component_without_context(&component_url, &package_resolver) |
| .await |
| .map_err(|err| { |
| let fidl_err = (&err).into(); |
| warn!( |
| "failed to resolve component URL {}: {:#}", |
| component_url, |
| anyhow!(err) |
| ); |
| fidl_err |
| }); |
| responder.send(&mut result).context("failed sending response")?; |
| } |
| fresolution::ResolverRequest::ResolveWithContext { |
| component_url, |
| context, |
| responder, |
| } => { |
| let mut result = |
| resolve_component_with_context(&component_url, &context, &package_resolver) |
| .await |
| .map_err(|err| { |
| let fidl_err = (&err).into(); |
| warn!( |
| "failed to resolve component URL {} with context {:?}: {:#}", |
| component_url, |
| context, |
| anyhow!(err) |
| ); |
| fidl_err |
| }); |
| responder.send(&mut result).context("failed sending response")?; |
| } |
| } |
| } |
| Ok(()) |
| } |
| |
| async fn resolve_component_without_context( |
| component_url: &str, |
| package_resolver: &PackageResolverProxy, |
| ) -> Result<fresolution::Component, ResolverError> { |
| resolve_component(component_url, None, package_resolver).await |
| } |
| |
| async fn resolve_component_with_context( |
| component_url: &str, |
| context: &Vec<u8>, |
| package_resolver: &PackageResolverProxy, |
| ) -> Result<fresolution::Component, ResolverError> { |
| resolve_component(component_url, Some(context), package_resolver).await |
| } |
| |
| async fn resolve_component( |
| component_url_str: &str, |
| some_incoming_context: Option<&Vec<u8>>, |
| package_resolver: &PackageResolverProxy, |
| ) -> Result<fresolution::Component, ResolverError> { |
| let component_url = ComponentUrl::parse(component_url_str)?; |
| let package = |
| resolve_package_async(component_url.package_url(), some_incoming_context, package_resolver) |
| .await?; |
| |
| // Read the component manifest (.cm file) from the package directory. |
| let data = mem_util::open_file_data(&package.dir, component_url.resource()) |
| .await |
| .map_err(ResolverError::ManifestNotFound)?; |
| let raw_bytes = mem_util::bytes_from_data(&data).map_err(ResolverError::ReadingManifest)?; |
| let decl: fdecl::Component = fidl::encoding::decode_persistent(&raw_bytes[..]) |
| .map_err(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(ResolverError::MissingConfigSource)?; |
| let config_path = match strategy { |
| fdecl::ConfigValueSource::PackagePath(path) => path, |
| other => return Err(ResolverError::UnsupportedConfigStrategy(other.to_owned())), |
| }; |
| Some( |
| mem_util::open_file_data(&package.dir, &config_path) |
| .await |
| .map_err(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>>, |
| package_resolver: &PackageResolverProxy, |
| ) -> Result<ResolvedPackage, ResolverError> { |
| let (proxy, server_end) = |
| create_proxy::<fio::DirectoryMarker>().expect("failed to create channel pair"); |
| let package_dir = PackageDirectory::from_proxy(proxy); |
| |
| let package_context = match package_url { |
| PackageUrl::Relative(relative) => { |
| let context = some_incoming_context |
| .ok_or_else(|| ResolverError::RelativeUrlMissingContext(package_url.to_string()))?; |
| // TODO(fxbug.dev/100060): Replace with `package_resolver.resolve_with_context` when |
| // available. |
| transitional::resolve_with_context( |
| package_resolver, |
| &package_dir, |
| relative, |
| context, |
| server_end, |
| ) |
| .await |
| } |
| PackageUrl::Absolute(absolute) => { |
| // TODO(fxbug.dev/100060): Replace with `package_resolver.resolve` when available. |
| transitional::resolve(package_resolver, &package_dir, absolute, server_end).await |
| } |
| } |
| .map_err(ResolverError::IoError)? |
| .map_err(|err| match err { |
| fidl_fuchsia_pkg::ResolveError::PackageNotFound => ResolverError::PackageNotFound, |
| fidl_fuchsia_pkg::ResolveError::RepoNotFound |
| | fidl_fuchsia_pkg::ResolveError::UnavailableBlob |
| | fidl_fuchsia_pkg::ResolveError::UnavailableRepoMetadata => ResolverError::Unavailable, |
| fidl_fuchsia_pkg::ResolveError::NoSpace => ResolverError::NoSpace, |
| _ => ResolverError::Internal, |
| })?; |
| Ok(ResolvedPackage { dir: package_dir.into_proxy(), context: package_context }) |
| } |
| |
| /// Implements the expected behavior of future Rust bindings for the upcoming |
| /// iteration of the FIDL API for `fuchsia.pkg.PackageResolver`, once updated to |
| /// support subpackages, by wrapping the existing API. Once the new version is |
| /// implemented, this module will be removed. |
| mod transitional { |
| use {super::*, fidl::endpoints::ServerEnd, fuchsia_url::AbsolutePackageUrl}; |
| |
| pub async fn resolve( |
| package_resolver: &PackageResolverProxy, |
| package_dir: &PackageDirectory, |
| package_url: &AbsolutePackageUrl, |
| dir_server_end: ServerEnd<fio::DirectoryMarker>, |
| ) -> Result<Result<Vec<u8>, fidl_fuchsia_pkg::ResolveError>, fidl::Error> { |
| let result = package_resolver.resolve(&package_url.to_string(), dir_server_end).await?; |
| if let Err(err) = result { |
| // The proxy call returned (outer result Ok), but it returned an Err (inner result) |
| return Ok(Err(err)); |
| } |
| let result = fabricate_package_context(package_url.repository(), package_dir) |
| .await |
| .map_err(|err: anyhow::Error| { |
| error!("failed to fabricate package context: {:#}", err); |
| fidl_fuchsia_pkg::ResolveError::Internal |
| }); |
| Ok(result) |
| } |
| |
| pub async fn resolve_with_context( |
| package_resolver: &PackageResolverProxy, |
| package_dir: &PackageDirectory, |
| package_url: &RelativePackageUrl, |
| context: &Vec<u8>, |
| dir_server_end: ServerEnd<fio::DirectoryMarker>, |
| ) -> Result<Result<Vec<u8>, fidl_fuchsia_pkg::ResolveError>, fidl::Error> { |
| let (repo, hash) = match get_subpackage_repo_and_hash(package_url, context) { |
| Ok(v) => v, |
| Err(err) => { |
| error!("failed to parse package context: {:?}", err); |
| return Ok(Err(fidl_fuchsia_pkg::ResolveError::Internal)); |
| } |
| }; |
| // TODO(fxbug.dev/100060): |
| // This URL format (containing only the package hash with no absolute |
| // package name) is a placeholder and not expected to actually be |
| // accepted by the package resolver. We can add the package name, but, |
| // but that would mean we would need to be able to get the package name |
| // from the "subpackages" meta file, which is NOT part of the current |
| // RFC spec. (The subpackage name does not need to match the absolute |
| // package name. It's a parent package-specific internal name.). So |
| // there are three choices: |
| // 1. Leave it as-is and don't expect universe resolver to work until |
| // either option 2 or 3 is done. (This is what I'm doing for now, |
| // until we decide if we have to do 2 or can go directly to 3.) |
| // 2. Add the absolute package name to the subpackages file format |
| // (for now), and to the package resolver URL below. |
| // 3. Implement package resolver's "ResolveWithContext()" and move the |
| // logic for looking up subpackages to package resolver instead, |
| // where it actually belongs (according to the RFC). |
| let pinned_subpackage_url = format!("{}/?hash={}", repo, hash); |
| if let Err(err) = package_resolver.resolve(&pinned_subpackage_url, dir_server_end).await { |
| return Err(err); |
| } |
| match fabricate_package_context(&repo, package_dir).await { |
| Ok(package_context) => Ok(Ok(package_context)), |
| Err(err) => { |
| error!( |
| "failed to fabricate package context: {:#}, given package_url={}", |
| err, package_url |
| ); |
| Ok(Err(fidl_fuchsia_pkg::ResolveError::Internal)) |
| } |
| } |
| } |
| |
| fn get_subpackage_repo_and_hash( |
| subpackage: &RelativePackageUrl, |
| context: &Vec<u8>, |
| ) -> anyhow::Result<(RepositoryUrl, Hash)> { |
| let info = PackageResolutionInfo::from_package_context(context)?; |
| Ok(( |
| info.repo, |
| info.subpackage_hashes |
| .get(&subpackage) |
| .ok_or_else(|| anyhow::format_err!("subpackage {} not found", subpackage))? |
| .clone(), |
| )) |
| } |
| |
| async fn fabricate_package_context( |
| repo: &RepositoryUrl, |
| package_dir: &PackageDirectory, |
| ) -> anyhow::Result<Vec<u8>> { |
| let meta = package_dir.meta_subpackages().await?; |
| PackageResolutionInfo::new(repo.clone(), meta.into_subpackages()).into_package_context() |
| } |
| } |
| |
| #[derive(Debug, Clone, PartialEq, Eq)] |
| pub struct PackageResolutionInfo { |
| pub repo: RepositoryUrl, |
| pub subpackage_hashes: HashMap<RelativePackageUrl, Hash>, |
| } |
| |
| impl PackageResolutionInfo { |
| pub fn new(repo: RepositoryUrl, subpackage_hashes: HashMap<RelativePackageUrl, Hash>) -> Self { |
| Self { repo, subpackage_hashes } |
| } |
| |
| pub fn from_package_context(context: &Vec<u8>) -> Result<Self, anyhow::Error> { |
| let mut parts = context.split(|&b| b == b'\0'); |
| let repo = RepositoryUrl::parse_host( |
| String::from_utf8( |
| parts |
| .next() |
| .ok_or_else(|| anyhow::format_err!("Empty resolution context bytes"))? |
| .to_vec(), |
| ) |
| .with_context(|| { |
| format!( |
| "Error extracting package URL host from resolution context bytes: {:?}", |
| context |
| ) |
| })?, |
| )?; |
| |
| let subpackage_hashes = parts |
| .next() |
| .map(|bytes| { |
| subpackages_map_from_context_bytes(&bytes.to_vec()).with_context(|| { |
| format!( |
| "Error extracting subpackages JSON from resolution context bytes: {:?}", |
| bytes |
| ) |
| }) |
| }) |
| .transpose()? |
| .unwrap_or_default(); |
| Ok(Self { repo, subpackage_hashes }) |
| } |
| |
| pub fn into_package_context(self) -> anyhow::Result<Vec<u8>> { |
| let Self { repo, subpackage_hashes } = self; |
| let mut resolution_context = repo.host().as_bytes().to_vec(); |
| if let Some(mut context_bytes) = context_bytes_from_subpackages_map(&subpackage_hashes)? { |
| resolution_context.push(b'\0'); |
| resolution_context.append(&mut context_bytes); |
| } |
| Ok(resolution_context) |
| } |
| } |
| |
| #[derive(Error, Debug)] |
| enum ResolverError { |
| #[error("an unexpected error occurred")] |
| Internal, |
| |
| #[error("invalid component URL")] |
| InvalidUrl(#[from] fuchsia_url::errors::ParseError), |
| |
| #[error("manifest not found")] |
| ManifestNotFound(#[source] mem_util::FileError), |
| |
| #[error("config values not found")] |
| ConfigValuesNotFound(#[source] mem_util::FileError), |
| |
| #[error("package not found")] |
| PackageNotFound, |
| |
| #[error("IO error")] |
| IoError(#[source] fidl::Error), |
| |
| #[error("failed to deal with fuchsia.mem.Data")] |
| ReadingManifest(#[source] mem_util::DataError), |
| |
| #[error("failed to parse compiled manifest to check for config")] |
| ParsingManifest(#[source] fidl::Error), |
| |
| #[error("insufficient space to store package")] |
| NoSpace, |
| |
| #[error("the component's package is temporarily unavailable")] |
| Unavailable, |
| |
| #[error("component has config fields but does not have a config value lookup strategy")] |
| MissingConfigSource, |
| |
| #[error("unsupported config value resolution strategy {_0:?}")] |
| UnsupportedConfigStrategy(fdecl::ConfigValueSource), |
| |
| #[error("failed to create the resolution context")] |
| CreatingContext(#[from] anyhow::Error), |
| |
| #[error("a context is required to resolve relative url: {0}")] |
| RelativeUrlMissingContext(String), |
| } |
| |
| impl From<&ResolverError> for fresolution::ResolverError { |
| fn from(err: &ResolverError) -> fresolution::ResolverError { |
| use {fresolution::ResolverError as ferr, ResolverError::*}; |
| match err { |
| Internal => ferr::Internal, |
| InvalidUrl(_) => ferr::InvalidArgs, |
| ManifestNotFound { .. } => ferr::ManifestNotFound, |
| ConfigValuesNotFound { .. } => ferr::ConfigValuesNotFound, |
| PackageNotFound => ferr::PackageNotFound, |
| ReadingManifest(_) | IoError(_) => ferr::Io, |
| NoSpace => ferr::NoSpace, |
| Unavailable => ferr::ResourceUnavailable, |
| ParsingManifest(..) | MissingConfigSource | UnsupportedConfigStrategy(..) => { |
| ferr::InvalidManifest |
| } |
| CreatingContext(_) => ferr::Internal, |
| RelativeUrlMissingContext(_) => ferr::Internal, |
| } |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use { |
| super::*, |
| anyhow::Error, |
| assert_matches::assert_matches, |
| fidl::{encoding::encode_persistent_with_context, endpoints::ServerEnd}, |
| fidl_fuchsia_component_config as fconfig, fidl_fuchsia_component_decl as fdecl, |
| fidl_fuchsia_component_resolution::ResolverMarker, |
| fidl_fuchsia_io as fio, fidl_fuchsia_mem as fmem, |
| fidl_fuchsia_pkg::{PackageResolverRequest, PackageResolverRequestStream}, |
| fuchsia_async as fasync, |
| fuchsia_component::server as fserver, |
| fuchsia_component_test::{ |
| Capability, ChildOptions, LocalComponentHandles, RealmBuilder, Ref, Route, |
| }, |
| fuchsia_hash::Hash, |
| fuchsia_pkg::MetaSubpackages, |
| fuchsia_zircon::Vmo, |
| futures::{channel::mpsc, join, lock::Mutex}, |
| std::{boxed::Box, iter::FromIterator, str::FromStr, sync::Arc}, |
| vfs::{ |
| directory::entry::DirectoryEntry, |
| execution_scope::ExecutionScope, |
| file::{vmo::asynchronous::read_only_static, vmo::asynchronous::NewVmo}, |
| path::Path, |
| pseudo_directory, |
| }, |
| }; |
| |
| async fn resolve_package( |
| package_url: &PackageUrl, |
| package_resolver: &PackageResolverProxy, |
| ) -> Result<ResolvedPackage, ResolverError> { |
| resolve_package_async(package_url, None, package_resolver).await |
| } |
| |
| async fn mock_pkg_resolver( |
| trigger: Arc<Mutex<Option<mpsc::Sender<Result<(), Error>>>>>, |
| handles: LocalComponentHandles, |
| ) -> Result<(), Error> { |
| let mut fs = fserver::ServiceFs::new(); |
| fs.dir("svc").add_fidl_service( |
| move |mut req_stream: fidl_fuchsia_pkg::PackageResolverRequestStream| { |
| let tx = trigger.clone(); |
| fasync::Task::local(async move { |
| while let Some(fidl_fuchsia_pkg::PackageResolverRequest::Resolve { |
| responder, |
| .. |
| }) = |
| req_stream.try_next().await.expect("Serving package resolver stream failed") |
| { |
| responder |
| .send(&mut Err(fidl_fuchsia_pkg::ResolveError::PackageNotFound)) |
| .expect("failed sending package resolver response to client"); |
| |
| { |
| let mut lock = tx.lock().await; |
| let mut c = lock.take().unwrap(); |
| c.send(Ok(())).await.expect("failed sending oneshot to test"); |
| lock.replace(c); |
| } |
| } |
| }) |
| .detach(); |
| }, |
| ); |
| |
| fs.serve_connection(handles.outgoing_dir.into_channel())?; |
| fs.collect::<()>().await; |
| Ok(()) |
| } |
| |
| async fn package_requester( |
| trigger: Arc<Mutex<Option<mpsc::Sender<Result<(), Error>>>>>, |
| url: String, |
| handles: LocalComponentHandles, |
| ) -> Result<(), Error> { |
| let resolver_proxy = handles.connect_to_protocol::<ResolverMarker>()?; |
| let _ = resolver_proxy.resolve(&url).await?; |
| fasync::Task::local(async move { |
| let mut lock = trigger.lock().await; |
| let mut c = lock.take().unwrap(); |
| c.send(Ok(())).await.expect("sending oneshot from package requester failed"); |
| lock.replace(c); |
| }) |
| .detach(); |
| Ok(()) |
| } |
| |
| #[fasync::run_singlethreaded(test)] |
| // Test that the default configuration which forwards requests to |
| // PackageResolver works properly. |
| async fn test_using_pkg_resolver() { |
| let (sender, mut receiver) = mpsc::channel(2); |
| let tx = Arc::new(Mutex::new(Some(sender))); |
| let resolver_url = |
| "fuchsia-pkg://fuchsia.com/universe-resolver-unittests#meta/universe-resolver-for-test.cm" |
| .to_string(); |
| let requested_url = |
| "fuchsia-pkg://fuchsia.com/test-pkg-request#meta/test-component.cm".to_string(); |
| let builder = RealmBuilder::new().await.expect("Failed to create test realm builder"); |
| let universe_resolver = builder |
| .add_child("universe-resolver", resolver_url, ChildOptions::new()) |
| .await |
| .expect("Failed add universe-resolver to test topology"); |
| let fake_pkg_resolver = builder |
| .add_local_child( |
| "fake-pkg-resolver", |
| { |
| let sender = tx.clone(); |
| move |handles: LocalComponentHandles| { |
| Box::pin(mock_pkg_resolver(sender.clone(), handles)) |
| } |
| }, |
| ChildOptions::new(), |
| ) |
| .await |
| .expect("Failed adding base resolver mock"); |
| let requesting_component = builder |
| .add_local_child( |
| "requesting-component", |
| { |
| let sender = tx.clone(); |
| move |handles: LocalComponentHandles| { |
| Box::pin(package_requester(sender.clone(), requested_url.clone(), handles)) |
| } |
| }, |
| ChildOptions::new().eager(), |
| ) |
| .await |
| .expect("Failed adding mock request component"); |
| builder |
| .add_route( |
| Route::new() |
| .capability(Capability::protocol_by_name("fuchsia.pkg.PackageResolver")) |
| .from(&fake_pkg_resolver) |
| .to(&universe_resolver), |
| ) |
| .await |
| .expect("Failed adding resolver route from fake-base-resolver to universe-resolver"); |
| builder |
| .add_route( |
| Route::new() |
| .capability(Capability::protocol_by_name( |
| "fuchsia.component.resolution.Resolver", |
| )) |
| .from(&universe_resolver) |
| .to(&requesting_component), |
| ) |
| .await |
| .expect("Failed adding resolver route from universe-resolver to requesting-component"); |
| builder |
| .add_route( |
| Route::new() |
| .capability(Capability::protocol_by_name("fuchsia.logger.LogSink")) |
| .from(Ref::parent()) |
| .to(&universe_resolver) |
| .to(&fake_pkg_resolver) |
| .to(&requesting_component), |
| ) |
| .await |
| .expect("Failed adding LogSink route to test components"); |
| let _test_topo = builder.build().await.unwrap(); |
| |
| receiver.next().await.expect("Unexpected error waiting for response").expect("error sent"); |
| receiver.next().await.expect("Unexpected error waiting for response").expect("error sent"); |
| } |
| |
| #[fuchsia::test] |
| async fn resolve_package_succeeds() { |
| let (proxy, mut server) = |
| fidl::endpoints::create_proxy_and_stream::<PackageResolverMarker>().unwrap(); |
| let server = async move { |
| let fs = pseudo_directory! { |
| "test_file" => read_only_static(b"foo"), |
| }; |
| while let Some(request) = server.try_next().await.unwrap() { |
| match request { |
| PackageResolverRequest::Resolve { package_url, dir, responder } => { |
| assert_eq!( |
| package_url, "fuchsia-pkg://fuchsia.com/test", |
| "unexpected package URL" |
| ); |
| fs.clone().open( |
| ExecutionScope::new(), |
| fio::OpenFlags::RIGHT_READABLE, |
| fio::MODE_TYPE_DIRECTORY, |
| Path::dot(), |
| ServerEnd::new(dir.into_channel()), |
| ); |
| responder.send(&mut Ok(())).unwrap(); |
| } |
| _ => panic!("unexpected API call"), |
| } |
| } |
| }; |
| let client = async move { |
| let result = |
| resolve_package(&"fuchsia-pkg://fuchsia.com/test".parse().unwrap(), &proxy).await; |
| let package = result.expect("package resolver failed unexpectedly"); |
| let file = fuchsia_fs::directory::open_file( |
| &package.dir, |
| "test_file", |
| fio::OpenFlags::RIGHT_READABLE, |
| ) |
| .await |
| .expect("failed to open 'test_file' from package resolver directory"); |
| let contents = fuchsia_fs::file::read(&file) |
| .await |
| .expect("failed to read 'test_file' contents from package resolver directory"); |
| assert_eq!(&contents, b"foo"); |
| }; |
| join!(server, client); |
| } |
| |
| #[fuchsia::test] |
| async fn resolve_component_succeeds() { |
| let (proxy, mut server) = |
| fidl::endpoints::create_proxy_and_stream::<PackageResolverMarker>().unwrap(); |
| let server = async move { |
| 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 fs = pseudo_directory! { |
| "meta" => pseudo_directory!{ |
| "test.cm" => read_only_static(cm_bytes), |
| }, |
| }; |
| while let Some(request) = server.try_next().await.unwrap() { |
| match request { |
| PackageResolverRequest::Resolve { package_url, dir, responder } => { |
| assert_eq!( |
| package_url, "fuchsia-pkg://fuchsia.com/test", |
| "unexpected package URL" |
| ); |
| fs.clone().open( |
| ExecutionScope::new(), |
| fio::OpenFlags::RIGHT_READABLE, |
| fio::MODE_TYPE_DIRECTORY, |
| Path::dot(), |
| ServerEnd::new(dir.into_channel()), |
| ); |
| responder.send(&mut Ok(())).unwrap(); |
| } |
| _ => panic!("unexpected API call"), |
| } |
| } |
| }; |
| let client = async move { |
| assert_matches!( |
| resolve_component_without_context( |
| "fuchsia-pkg://fuchsia.com/test#meta/test.cm", |
| &proxy |
| ) |
| .await, |
| Ok(fresolution::Component { |
| decl: Some(fidl_fuchsia_mem::Data::Buffer(fidl_fuchsia_mem::Buffer { .. })), |
| .. |
| }) |
| ); |
| }; |
| join!(server, client); |
| } |
| |
| #[fuchsia::test] |
| async fn resolve_component_succeeds_with_hash() { |
| let (proxy, mut server) = |
| fidl::endpoints::create_proxy_and_stream::<PackageResolverMarker>().unwrap(); |
| let server = async move { |
| 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 fs = pseudo_directory! { |
| "meta" => pseudo_directory!{ |
| "test.cm" => read_only_static(cm_bytes), |
| }, |
| }; |
| while let Some(request) = server.try_next().await.unwrap() { |
| match request { |
| PackageResolverRequest::Resolve { package_url, dir, responder } => { |
| assert_eq!(package_url, "fuchsia-pkg://fuchsia.com/test?hash=9e3a3f63c018e2a4db0ef93903a87714f036e3e8ff982a7a2020eca86cc4677c", "unexpected package URL"); |
| fs.clone().open( |
| ExecutionScope::new(), |
| fio::OpenFlags::RIGHT_READABLE, |
| fio::MODE_TYPE_DIRECTORY, |
| Path::dot(), |
| ServerEnd::new(dir.into_channel()), |
| ); |
| responder.send(&mut Ok(())).unwrap(); |
| } |
| _ => panic!("unexpected API call"), |
| } |
| } |
| }; |
| let client = async move { |
| assert_matches!(resolve_component_without_context("fuchsia-pkg://fuchsia.com/test?hash=9e3a3f63c018e2a4db0ef93903a87714f036e3e8ff982a7a2020eca86cc4677c#meta/test.cm", &proxy).await, Ok(_)); |
| }; |
| join!(server, client); |
| } |
| |
| #[fuchsia::test] |
| async fn resolve_component_succeeds_with_vmo_manifest() { |
| let (proxy, mut server) = |
| fidl::endpoints::create_proxy_and_stream::<PackageResolverMarker>().unwrap(); |
| let server = async move { |
| let fs = pseudo_directory! { |
| "meta" => pseudo_directory!{ |
| "test.cm" => vfs::file::vmo::read_only(|| async move { |
| 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 capacity = cm_bytes.len() as u64; |
| let vmo = Vmo::create(capacity)?; |
| vmo.write(&cm_bytes, 0).expect("failed to write manifest bytes to vmo"); |
| Ok(NewVmo { vmo, size: capacity, capacity }) |
| }), |
| }, |
| }; |
| while let Some(request) = server.try_next().await.unwrap() { |
| match request { |
| PackageResolverRequest::Resolve { dir, responder, .. } => { |
| fs.clone().open( |
| ExecutionScope::new(), |
| fio::OpenFlags::RIGHT_READABLE, |
| fio::MODE_TYPE_DIRECTORY, |
| Path::dot(), |
| ServerEnd::new(dir.into_channel()), |
| ); |
| responder.send(&mut Ok(())).unwrap(); |
| } |
| _ => panic!("unexpected API call"), |
| } |
| } |
| }; |
| let client = async move { |
| assert_matches!( |
| resolve_component_without_context( |
| "fuchsia-pkg://fuchsia.com/test#meta/test.cm", |
| &proxy |
| ) |
| .await, |
| Ok(fresolution::Component { decl: Some(fmem::Data::Buffer(_)), .. }) |
| ); |
| }; |
| join!(server, client); |
| } |
| |
| #[fuchsia::test] |
| async fn resolves_component_in_subpackage_succeeds() { |
| let parent_package_url = "fuchsia-pkg://fuchsia.com/toplevel-package"; |
| let parent_component_url = parent_package_url.to_owned() + "#meta/foo.cm"; |
| let subpackage_name = "my_subpackage"; |
| let subpackaged_component_fragment = "#meta/subfoo.cm"; |
| let subpackaged_component_relative_url = |
| subpackage_name.to_owned() + subpackaged_component_fragment; |
| let subpackage_hash = "facefacefacefacefacefacefacefacefacefacefacefacefacefacefaceface"; |
| let subpackage_hash_query_url = |
| format!("fuchsia-pkg://fuchsia.com/?hash={}", subpackage_hash); |
| let subpackages = MetaSubpackages::from_iter(vec![( |
| RelativePackageUrl::parse(subpackage_name).unwrap(), |
| Hash::from_str(subpackage_hash).unwrap(), |
| )]); |
| |
| let (proxy, mut server) = |
| fidl::endpoints::create_proxy_and_stream::<PackageResolverMarker>().unwrap(); |
| let server = async move { |
| 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 parent_package_fs = pseudo_directory! { |
| "meta" => pseudo_directory!{ |
| "foo.cm" => read_only_static(cm_bytes.clone()), |
| "fuchsia.pkg" => pseudo_directory!{ |
| "subpackages" => vfs::file::vmo::asynchronous::read_only_const(&serde_json::to_vec(&subpackages).unwrap()), |
| }, |
| }, |
| }; |
| let subpackage_fs = pseudo_directory! { |
| "meta" => pseudo_directory!{ |
| "subfoo.cm" => read_only_static(cm_bytes.clone()), |
| }, |
| }; |
| let mut package_urls_to_resolve = |
| vec![parent_package_url.to_owned(), subpackage_hash_query_url.to_owned()]; |
| let mut packages = vec![parent_package_fs, subpackage_fs]; |
| while let Some(request) = server.try_next().await.unwrap() { |
| match request { |
| PackageResolverRequest::Resolve { package_url, dir, responder } => { |
| let expected = package_urls_to_resolve.remove(0); |
| assert_eq!(package_url, expected, "unexpected package URL"); |
| let fs = packages.remove(0); |
| fs.open( |
| ExecutionScope::new(), |
| fio::OpenFlags::RIGHT_READABLE, |
| fio::MODE_TYPE_DIRECTORY, |
| Path::dot(), |
| ServerEnd::new(dir.into_channel()), |
| ); |
| responder.send(&mut Ok(())).unwrap(); |
| } |
| _ => panic!("unexpected API call"), |
| } |
| } |
| }; |
| let client = async move { |
| let parent_component = resolve_component_without_context(&parent_component_url, &proxy) |
| .await |
| .expect("failed to resolve parent_component"); |
| let resolution_context_repr = |
| parent_component.resolution_context.clone().map(|context_bytes| { |
| let mut parts = context_bytes.split(|b| *b == b'\0'); |
| let host = String::from_utf8(parts.next().unwrap_or(&[]).to_vec()) |
| .unwrap_or_else(|e| format!("{:?}({:?})", e, context_bytes)); |
| let subpackages = String::from_utf8(parts.next().unwrap_or(&[]).to_vec()) |
| .unwrap_or_else(|e| format!("{:?}({:?})", e, context_bytes)); |
| format!("host: {}, subpackages: {}", host, subpackages) |
| }); |
| assert_matches!(parent_component.resolution_context, Some(..)); |
| assert_matches!( |
| resolve_component_with_context( |
| &subpackaged_component_relative_url, |
| parent_component.resolution_context.as_ref().unwrap(), |
| &proxy |
| ) |
| .await, |
| Ok(fresolution::Component { |
| decl: Some(fidl_fuchsia_mem::Data::Buffer(fidl_fuchsia_mem::Buffer { .. })), |
| .. |
| }), |
| "Could not resolve subpackaged component '{}' from context '{:?}'", |
| subpackaged_component_relative_url, |
| resolution_context_repr |
| ); |
| }; |
| join!(server, client); |
| } |
| |
| #[fuchsia::test] |
| async fn resolve_component_fails_bad_connection() { |
| let (proxy, server) = |
| fidl::endpoints::create_proxy_and_stream::<PackageResolverMarker>().unwrap(); |
| drop(server); |
| assert_matches!( |
| resolve_component_without_context( |
| "fuchsia-pkg://fuchsia.com/test#meta/test.cm", |
| &proxy |
| ) |
| .await, |
| Err(ResolverError::IoError(_)) |
| ); |
| } |
| |
| #[fuchsia::test] |
| async fn resolve_component_fails_with_package_resolver_failure() { |
| let (proxy, mut server) = |
| fidl::endpoints::create_proxy_and_stream::<PackageResolverMarker>().unwrap(); |
| let server = async move { |
| while let Some(request) = server.try_next().await.unwrap() { |
| match request { |
| PackageResolverRequest::Resolve { responder, .. } => { |
| responder.send(&mut Err(fidl_fuchsia_pkg::ResolveError::NoSpace)).unwrap(); |
| } |
| _ => panic!("unexpected API call"), |
| } |
| } |
| }; |
| let client = async move { |
| assert_matches!( |
| resolve_component_without_context( |
| "fuchsia-pkg://fuchsia.com/test#meta/test.cm", |
| &proxy |
| ) |
| .await, |
| Err(ResolverError::NoSpace) |
| ); |
| }; |
| join!(server, client); |
| } |
| |
| #[fuchsia::test] |
| async fn resolve_component_fails_with_component_not_found() { |
| let (proxy, mut server) = |
| fidl::endpoints::create_proxy_and_stream::<PackageResolverMarker>().unwrap(); |
| let server = async move { |
| let fs = pseudo_directory! {}; |
| while let Some(request) = server.try_next().await.unwrap() { |
| match request { |
| PackageResolverRequest::Resolve { dir, responder, .. } => { |
| fs.clone().open( |
| ExecutionScope::new(), |
| fio::OpenFlags::RIGHT_READABLE, |
| fio::MODE_TYPE_DIRECTORY, |
| Path::dot(), |
| ServerEnd::new(dir.into_channel()), |
| ); |
| responder.send(&mut Ok(())).unwrap(); |
| } |
| _ => panic!("unexpected API call"), |
| } |
| } |
| }; |
| let client = async move { |
| assert_matches!( |
| resolve_component_without_context( |
| "fuchsia-pkg://fuchsia.com/test#meta/test.cm", |
| &proxy |
| ) |
| .await, |
| Err(ResolverError::ManifestNotFound(..)) |
| ); |
| }; |
| join!(server, client); |
| } |
| |
| fn spawn_pkg_resolver( |
| fs: Arc<impl vfs::directory::entry::DirectoryEntry>, |
| mut server: PackageResolverRequestStream, |
| ) -> fasync::Task<()> { |
| fasync::Task::spawn(async move { |
| while let Some(request) = server.try_next().await.unwrap() { |
| match request { |
| PackageResolverRequest::Resolve { package_url, dir, responder } => { |
| assert_eq!( |
| package_url, "fuchsia-pkg://fuchsia.com/test", |
| "unexpected package URL" |
| ); |
| fs.clone().open( |
| ExecutionScope::new(), |
| fio::OpenFlags::RIGHT_READABLE, |
| fio::MODE_TYPE_DIRECTORY, |
| Path::dot(), |
| ServerEnd::new(dir.into_channel()), |
| ); |
| responder.send(&mut Ok(())).unwrap(); |
| } |
| _ => panic!("unexpected API call"), |
| } |
| } |
| }) |
| } |
| |
| #[fuchsia::test] |
| async fn resolve_component_succeeds_with_config() { |
| let (proxy, server) = |
| fidl::endpoints::create_proxy_and_stream::<PackageResolverMarker>().unwrap(); |
| let cm_bytes = 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/test_with_config.cvf".to_string(), |
| )), |
| ..fdecl::ConfigSchema::EMPTY |
| }), |
| ..fdecl::Component::EMPTY |
| }, |
| ) |
| .expect("failed to encode ComponentDecl FIDL"); |
| let cvf_bytes = encode_persistent_with_context( |
| &fidl::encoding::Context { wire_format_version: fidl::encoding::WireFormatVersion::V2 }, |
| &mut fconfig::ValuesData { ..fconfig::ValuesData::EMPTY }, |
| ) |
| .expect("failed to encode ValuesData FIDL"); |
| let fs = pseudo_directory! { |
| "meta" => pseudo_directory! { |
| "test_with_config.cm" => read_only_static(cm_bytes), |
| "test_with_config.cvf" => read_only_static(cvf_bytes), |
| }, |
| }; |
| let _pkg_resolver = spawn_pkg_resolver(fs, server); |
| assert_matches!( |
| resolve_component_without_context( |
| "fuchsia-pkg://fuchsia.com/test#meta/test_with_config.cm", |
| &proxy |
| ) |
| .await |
| .unwrap(), |
| fresolution::Component { |
| decl: Some(fidl_fuchsia_mem::Data::Buffer(fidl_fuchsia_mem::Buffer { .. })), |
| config_values: Some(fidl_fuchsia_mem::Data::Buffer( |
| fidl_fuchsia_mem::Buffer { .. } |
| )), |
| .. |
| } |
| ); |
| } |
| |
| #[fuchsia::test] |
| async fn resolve_component_fails_missing_config_value_file() { |
| let (proxy, server) = |
| fidl::endpoints::create_proxy_and_stream::<PackageResolverMarker>().unwrap(); |
| let cm_bytes = 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/test_with_config.cvf".to_string(), |
| )), |
| ..fdecl::ConfigSchema::EMPTY |
| }), |
| ..fdecl::Component::EMPTY |
| }, |
| ) |
| .expect("failed to encode ComponentDecl FIDL"); |
| let fs = pseudo_directory! { |
| "meta" => pseudo_directory! { |
| "test_with_config.cm" => read_only_static(cm_bytes), |
| }, |
| }; |
| let _pkg_resolver = spawn_pkg_resolver(fs, server); |
| assert_matches!( |
| resolve_component_without_context( |
| "fuchsia-pkg://fuchsia.com/test#meta/test_with_config.cm", |
| &proxy |
| ) |
| .await |
| .unwrap_err(), |
| ResolverError::ConfigValuesNotFound(_) |
| ); |
| } |
| |
| #[fuchsia::test] |
| async fn resolve_component_fails_bad_config_strategy() { |
| let (proxy, server) = |
| fidl::endpoints::create_proxy_and_stream::<PackageResolverMarker>().unwrap(); |
| let cm_bytes = 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 |
| }, |
| ) |
| .expect("failed to encode ComponentDecl FIDL"); |
| let cvf_bytes = encode_persistent_with_context( |
| &fidl::encoding::Context { wire_format_version: fidl::encoding::WireFormatVersion::V2 }, |
| &mut fconfig::ValuesData { ..fconfig::ValuesData::EMPTY }, |
| ) |
| .expect("failed to encode ValuesData FIDL"); |
| let fs = pseudo_directory! { |
| "meta" => pseudo_directory! { |
| "test_with_config.cm" => read_only_static(cm_bytes), |
| "test_with_config.cvf" => read_only_static(cvf_bytes), |
| }, |
| }; |
| let _pkg_resolver = spawn_pkg_resolver(fs, server); |
| assert_matches!( |
| resolve_component_without_context( |
| "fuchsia-pkg://fuchsia.com/test#meta/test_with_config.cm", |
| &proxy |
| ) |
| .await |
| .unwrap_err(), |
| ResolverError::MissingConfigSource |
| ); |
| } |
| |
| #[test] |
| fn test_package_resolution_info() { |
| let mut subpackages_map = HashMap::default(); |
| subpackages_map.insert( |
| RelativePackageUrl::parse("subpackage_name").unwrap(), |
| Hash::from_str("facefacefacefacefacefacefacefacefacefacefacefacefacefacefaceface") |
| .unwrap(), |
| ); |
| let info = PackageResolutionInfo::new( |
| RepositoryUrl::parse_host("fuchsia.com".to_string()).unwrap(), |
| subpackages_map, |
| ); |
| let package_context = info.clone().into_package_context().unwrap(); |
| let info2 = PackageResolutionInfo::from_package_context(&package_context).unwrap(); |
| assert_eq!(info, info2); |
| } |
| } |
