| // 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::{self, Context}, |
| argh::FromArgs, |
| fidl::endpoints::{create_proxy, ClientEnd, Proxy}, |
| fidl_fuchsia_io::{self as fio, DirectoryMarker, DirectoryProxy}, |
| fidl_fuchsia_mem as fmem, |
| fidl_fuchsia_pkg::{PackageResolverMarker, PackageResolverProxy}, |
| fidl_fuchsia_sys2::{ |
| self as fsys, ComponentResolverMarker, ComponentResolverRequest, |
| ComponentResolverRequestStream, |
| }, |
| fuchsia_component::{client::connect_to_service, server::ServiceFs}, |
| fuchsia_url::{errors::ParseError as PkgUrlParseError, pkg_url::PkgUrl}, |
| fuchsia_zircon::Status, |
| futures::prelude::*, |
| log::*, |
| thiserror::Error, |
| }; |
| |
| #[derive(FromArgs, Debug)] |
| #[argh(description = "Controls for universe resolver")] |
| struct Args { |
| #[argh( |
| switch, |
| description = "if true the fuchsia.pkg.PkgResolver protocol provided to \ |
| this component is used, otherwise the fuchsia.sys2.ComponentResolver \ |
| protocol (assumed to come from base-resolver) is used" |
| )] |
| enable_ephemeral_components: bool, |
| } |
| |
| #[fuchsia::component] |
| async fn main() -> anyhow::Result<()> { |
| info!("started"); |
| let args: Args = argh::from_env(); |
| let mut service_fs = ServiceFs::new_local(); |
| service_fs.dir("svc").add_fidl_service(|stream: ComponentResolverRequestStream| stream); |
| service_fs.take_and_serve_directory_handle().context("failed to serve outgoing namespace")?; |
| service_fs |
| .for_each_concurrent(None, |stream| { |
| let all = args.enable_ephemeral_components; |
| async move { |
| let r = if all { serve(stream).await } else { forward_to_base(stream).await }; |
| |
| match r { |
| Ok(()) => {} |
| Err(err) => error!("failed to serve resolve request: {:?}", err), |
| } |
| } |
| }) |
| .await; |
| |
| Ok(()) |
| } |
| |
| async fn forward_to_base(mut stream: ComponentResolverRequestStream) -> anyhow::Result<()> { |
| let base_resolver = connect_to_service::<ComponentResolverMarker>() |
| .context("failed to connect to base package resolver")?; |
| |
| while let Some(ComponentResolverRequest::Resolve { component_url, responder }) = |
| stream.try_next().await.context("failed to read request from FIDL stream")? |
| { |
| match base_resolver.resolve(&component_url).await { |
| Ok(Ok(r)) => responder.send(&mut Ok(r)), |
| Ok(Err(e)) => responder.send(&mut Err(e)), |
| Err(err) => { |
| info!("universe resolver got FIDL error forward request to base resolver for component URL {}: {}", &component_url, &err); |
| responder.send(&mut Err(fsys::ResolverError::Internal)) |
| } |
| } |
| .context("failed to send response")?; |
| } |
| Ok(()) |
| } |
| |
| async fn serve(mut stream: ComponentResolverRequestStream) -> anyhow::Result<()> { |
| let package_resolver = connect_to_service::<PackageResolverMarker>() |
| .context("failed to connect to PackageResolver service")?; |
| while let Some(ComponentResolverRequest::Resolve { component_url, responder }) = |
| stream.try_next().await.context("failed to read request from FIDL stream")? |
| { |
| match resolve_component(&component_url, &package_resolver).await { |
| Ok(result) => responder.send(&mut Ok(result)), |
| Err(err) => { |
| info!("failed to resolve component URL {}: {}", &component_url, &err); |
| responder.send(&mut Err(err.into())) |
| } |
| } |
| .context("failed sending response")?; |
| } |
| Ok(()) |
| } |
| |
| async fn resolve_component( |
| component_url: &str, |
| package_resolver: &PackageResolverProxy, |
| ) -> Result<fsys::Component, ResolverError> { |
| let package_url = PkgUrl::parse(component_url)?; |
| let cm_path = package_url |
| .resource() |
| .ok_or_else(|| ResolverError::InvalidUrl(PkgUrlParseError::InvalidResourcePath))?; |
| let package_dir = resolve_package(&package_url, package_resolver).await?; |
| |
| // Read the component manifest (.cm file) from the package directory. |
| let cm_file = io_util::directory::open_file(&package_dir, cm_path, fio::OPEN_RIGHT_READABLE) |
| .await |
| .map_err(ResolverError::ComponentNotFound)?; |
| |
| let (status, buffer) = |
| cm_file.get_buffer(fio::VMO_FLAG_READ).await.map_err(ResolverError::IoError)?; |
| Status::ok(status).map_err(ResolverError::VmoFailure)?; |
| let data = match buffer { |
| Some(buffer) => fmem::Data::Buffer(*buffer), |
| None => fmem::Data::Bytes( |
| io_util::file::read(&cm_file).await.map_err(ResolverError::ReadManifest)?, |
| ), |
| }; |
| |
| let package_dir = ClientEnd::new( |
| package_dir.into_channel().expect("could not convert proxy to channel").into_zx_channel(), |
| ); |
| Ok(fsys::Component { |
| resolved_url: Some(component_url.into()), |
| decl: Some(data), |
| package: Some(fsys::Package { |
| package_url: Some(package_url.root_url().to_string()), |
| package_dir: Some(package_dir), |
| ..fsys::Package::EMPTY |
| }), |
| ..fsys::Component::EMPTY |
| }) |
| } |
| |
| async fn resolve_package( |
| package_url: &PkgUrl, |
| package_resolver: &PackageResolverProxy, |
| ) -> Result<DirectoryProxy, ResolverError> { |
| let package_url = package_url.root_url(); |
| let selectors = Vec::new(); |
| let (proxy, server_end) = |
| create_proxy::<DirectoryMarker>().expect("failed to create channel pair"); |
| package_resolver |
| .resolve(&package_url.to_string(), &mut selectors.into_iter(), server_end) |
| .await |
| .map_err(ResolverError::IoError)? |
| .map_err(Status::from_raw) |
| .map_err(|err| match err { |
| Status::NOT_FOUND => ResolverError::PackageNotFound, |
| Status::ADDRESS_UNREACHABLE | Status::UNAVAILABLE => ResolverError::Unavailable, |
| Status::NO_SPACE => ResolverError::NoSpace, |
| _ => ResolverError::Internal, |
| })?; |
| Ok(proxy) |
| } |
| |
| #[derive(Error, Debug)] |
| enum ResolverError { |
| #[error("an unexpected error ocurred")] |
| Internal, |
| #[error("invalid component URL: {}", .0)] |
| InvalidUrl(#[from] PkgUrlParseError), |
| #[error("component not found: {}", .0)] |
| ComponentNotFound(#[source] io_util::node::OpenError), |
| #[error("package not found")] |
| PackageNotFound, |
| #[error("read manifest error: {}", .0)] |
| ReadManifest(#[source] io_util::file::ReadError), |
| #[error("IO error: {}", .0)] |
| IoError(#[source] fidl::Error), |
| #[error("failed to get manifest VMO: {}", .0)] |
| VmoFailure(#[source] Status), |
| #[error("insufficient space to store package")] |
| NoSpace, |
| #[error("the component's package is temporarily unavailable")] |
| Unavailable, |
| } |
| |
| impl From<ResolverError> for fsys::ResolverError { |
| fn from(err: ResolverError) -> fsys::ResolverError { |
| match err { |
| ResolverError::Internal => fsys::ResolverError::Internal, |
| ResolverError::InvalidUrl(_) => fsys::ResolverError::InvalidArgs, |
| ResolverError::ComponentNotFound(_) => fsys::ResolverError::ManifestNotFound, |
| ResolverError::PackageNotFound => fsys::ResolverError::PackageNotFound, |
| ResolverError::ReadManifest(_) |
| | ResolverError::VmoFailure(_) |
| | ResolverError::IoError(_) => fsys::ResolverError::Io, |
| ResolverError::NoSpace => fsys::ResolverError::NoSpace, |
| ResolverError::Unavailable => fsys::ResolverError::ResourceUnavailable, |
| } |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use { |
| super::*, |
| anyhow::Error, |
| fidl::{encoding::encode_persistent, endpoints::ServerEnd}, |
| fidl_fuchsia_mem, |
| fidl_fuchsia_pkg::{self as fpkg, PackageResolverRequest}, |
| fidl_fuchsia_sys2::{self as fsys, ComponentResolverMarker}, |
| fuchsia_async as fasync, |
| fuchsia_component::server as fserver, |
| fuchsia_component_test::{ |
| builder::{Capability, CapabilityRoute, ComponentSource, RealmBuilder, RouteEndpoint}, |
| mock::{Mock, MockHandles}, |
| }, |
| fuchsia_zircon as zx, |
| fuchsia_zircon::Vmo, |
| futures::{channel::mpsc, join, lock::Mutex}, |
| matches::assert_matches, |
| std::{boxed::Box, sync::Arc}, |
| vfs::{ |
| directory::entry::DirectoryEntry, |
| execution_scope::ExecutionScope, |
| file::{vmo::asynchronous::read_only_static, vmo::asynchronous::NewVmo}, |
| path::Path, |
| pseudo_directory, |
| }, |
| }; |
| |
| async fn mock_pkg_resolver( |
| trigger: Arc<Mutex<Option<mpsc::Sender<Result<(), Error>>>>>, |
| handles: MockHandles, |
| ) -> Result<(), Error> { |
| let mut fs = fserver::ServiceFs::new(); |
| fs.dir("svc").add_fidl_service( |
| move |mut req_stream: fpkg::PackageResolverRequestStream| { |
| let tx = trigger.clone(); |
| fasync::Task::local(async move { |
| while let Some(fpkg::PackageResolverRequest::Resolve { responder, .. }) = |
| req_stream.try_next().await.expect("Serving package resolver stream failed") |
| { |
| responder |
| .send(&mut Err(zx::Status::NOT_FOUND.into_raw())) |
| .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: MockHandles, |
| ) -> Result<(), Error> { |
| let resolver_proxy = handles.connect_to_service::<ComponentResolverMarker>()?; |
| 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 mut builder = RealmBuilder::new().await.expect("Failed to create test realm builder"); |
| builder |
| .add_component("universe-resolver", ComponentSource::url(resolver_url)) |
| .await |
| .expect("Failed add universe-resolver to test topology") |
| .add_component( |
| "fake-pkg-resolver", |
| ComponentSource::Mock(Mock::new({ |
| let sender = tx.clone(); |
| move |mock_handles: MockHandles| { |
| Box::pin(mock_pkg_resolver(sender.clone(), mock_handles)) |
| } |
| })), |
| ) |
| .await |
| .expect("Failed adding base resolver mock") |
| .add_eager_component( |
| "requesting-component", |
| ComponentSource::Mock(Mock::new({ |
| let sender = tx.clone(); |
| move |mock_handles: MockHandles| { |
| Box::pin(package_requester( |
| sender.clone(), |
| requested_url.clone(), |
| mock_handles, |
| )) |
| } |
| })), |
| ) |
| .await |
| .expect("Failed adding mock request component") |
| .add_route(CapabilityRoute { |
| capability: Capability::protocol("fuchsia.pkg.PackageResolver"), |
| source: RouteEndpoint::component("fake-pkg-resolver"), |
| targets: vec![RouteEndpoint::component("universe-resolver")], |
| }) |
| .expect("Failed adding resolver route from fake-base-resolver to universe-resolver") |
| .add_route(CapabilityRoute { |
| capability: Capability::protocol("fuchsia.sys2.ComponentResolver"), |
| source: RouteEndpoint::component("universe-resolver"), |
| targets: vec![RouteEndpoint::component("requesting-component")], |
| }) |
| .expect("Failed adding resolver route from universe-resolver to requesting-component") |
| .add_route(CapabilityRoute { |
| capability: Capability::protocol("fuchsia.logger.LogSink"), |
| source: RouteEndpoint::AboveRoot, |
| targets: vec![ |
| RouteEndpoint::component("universe-resolver"), |
| RouteEndpoint::component("fake-pkg-resolver"), |
| RouteEndpoint::component("requesting-component"), |
| ], |
| }) |
| .expect("Failed adding LogSink route to test components"); |
| let _test_topo = builder.build().create().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"); |
| } |
| |
| async fn mock_base_resolver( |
| trigger: Arc<Mutex<Option<mpsc::Sender<Result<(), Error>>>>>, |
| handles: MockHandles, |
| ) -> Result<(), Error> { |
| let mut fs = fserver::ServiceFs::new(); |
| fs.dir("svc").add_fidl_service( |
| move |mut req_stream: fsys::ComponentResolverRequestStream| { |
| let tx = trigger.clone(); |
| fasync::Task::local(async move { |
| while let Some(fsys::ComponentResolverRequest::Resolve { responder, .. }) = |
| req_stream |
| .try_next() |
| .await |
| .expect("Serving component resolver stream failed") |
| { |
| responder |
| .send(&mut Err(fsys::ResolverError::PackageNotFound)) |
| .expect("failed sending resolve 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(()) |
| } |
| |
| #[fasync::run_singlethreaded(test)] |
| // Test configuration where use of package resolver is disabled and |
| // requests are forwarded to the base resolver. |
| async fn test_using_base_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-base-only-for-test.cm" |
| .to_string(); |
| let requested_url = |
| "fuchsia-pkg://fuchsia.com/test-pkg-request#meta/test-component.cm".to_string(); |
| let mut builder = RealmBuilder::new().await.expect("Failed to create test realm builder"); |
| builder |
| .add_component("universe-resolver", ComponentSource::url(resolver_url)) |
| .await |
| .expect("Failed add universe-resolver to test topology") |
| .add_component( |
| "fake-base-resolver", |
| ComponentSource::Mock(Mock::new({ |
| let sender = tx.clone(); |
| move |mock_handles: MockHandles| { |
| Box::pin(mock_base_resolver(sender.clone(), mock_handles)) |
| } |
| })), |
| ) |
| .await |
| .expect("Failed adding base resolver mock") |
| .add_eager_component( |
| "requesting-component", |
| ComponentSource::Mock(Mock::new({ |
| let sender = tx.clone(); |
| move |mock_handles: MockHandles| { |
| Box::pin(package_requester( |
| sender.clone(), |
| requested_url.clone(), |
| mock_handles, |
| )) |
| } |
| })), |
| ) |
| .await |
| .expect("Failed adding mock request component") |
| .add_route(CapabilityRoute { |
| capability: Capability::protocol("fuchsia.sys2.ComponentResolver"), |
| source: RouteEndpoint::component("fake-base-resolver"), |
| targets: vec![RouteEndpoint::component("universe-resolver")], |
| }) |
| .expect("Failed adding resolver route from fake-base-resolver to universe-resolver") |
| .add_route(CapabilityRoute { |
| capability: Capability::protocol("fuchsia.sys2.ComponentResolver"), |
| source: RouteEndpoint::component("universe-resolver"), |
| targets: vec![RouteEndpoint::component("requesting-component")], |
| }) |
| .expect("Failed adding resolver route from universe-resolver to requesting-component") |
| .add_route(CapabilityRoute { |
| capability: Capability::protocol("fuchsia.logger.LogSink"), |
| source: RouteEndpoint::AboveRoot, |
| targets: vec![ |
| RouteEndpoint::component("universe-resolver"), |
| RouteEndpoint::component("fake-base-resolver"), |
| RouteEndpoint::component("requesting-component"), |
| ], |
| }) |
| .expect("Failed adding LogSink route to test components"); |
| let _test_topo = builder.build().create().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, selectors, dir, responder } => { |
| assert_eq!( |
| package_url, "fuchsia-pkg://fuchsia.com/test", |
| "unexpected package URL" |
| ); |
| assert!( |
| selectors.is_empty(), |
| "Call to Resolve should not contain any selectors" |
| ); |
| fs.clone().open( |
| ExecutionScope::new(), |
| fio::OPEN_RIGHT_READABLE, |
| fio::MODE_TYPE_DIRECTORY, |
| Path::empty(), |
| ServerEnd::new(dir.into_channel()), |
| ); |
| responder.send(&mut Ok(())).unwrap(); |
| } |
| _ => panic!("unexpected API call"), |
| } |
| } |
| }; |
| let client = async move { |
| let result = resolve_package( |
| &PkgUrl::new_package("fuchsia.com".into(), "/test".into(), None).unwrap(), |
| &proxy, |
| ) |
| .await; |
| let directory = result.expect("package resolver failed unexpectedly"); |
| let file = |
| io_util::directory::open_file(&directory, "test_file", fio::OPEN_RIGHT_READABLE) |
| .await |
| .expect("failed to open 'test_file' from package resolver directory"); |
| let contents = io_util::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(&mut fsys::ComponentDecl::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, selectors, dir, responder } => { |
| assert_eq!( |
| package_url, "fuchsia-pkg://fuchsia.com/test", |
| "unexpected package URL" |
| ); |
| assert!( |
| selectors.is_empty(), |
| "Call to Resolve should not contain any selectors" |
| ); |
| fs.clone().open( |
| ExecutionScope::new(), |
| fio::OPEN_RIGHT_READABLE, |
| fio::MODE_TYPE_DIRECTORY, |
| Path::empty(), |
| ServerEnd::new(dir.into_channel()), |
| ); |
| responder.send(&mut Ok(())).unwrap(); |
| } |
| _ => panic!("unexpected API call"), |
| } |
| } |
| }; |
| let client = async move { |
| assert_matches!( |
| resolve_component("fuchsia-pkg://fuchsia.com/test#meta/test.cm", &proxy).await, |
| Ok(fsys::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(&mut fsys::ComponentDecl::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, selectors, dir, responder } => { |
| assert_eq!(package_url, "fuchsia-pkg://fuchsia.com/test?hash=9e3a3f63c018e2a4db0ef93903a87714f036e3e8ff982a7a2020eca86cc4677c", "unexpected package URL"); |
| assert!( |
| selectors.is_empty(), |
| "Call to Resolve should not contain any selectors" |
| ); |
| fs.clone().open( |
| ExecutionScope::new(), |
| fio::OPEN_RIGHT_READABLE, |
| fio::MODE_TYPE_DIRECTORY, |
| Path::empty(), |
| ServerEnd::new(dir.into_channel()), |
| ); |
| responder.send(&mut Ok(())).unwrap(); |
| } |
| _ => panic!("unexpected API call"), |
| } |
| } |
| }; |
| let client = async move { |
| assert_matches!(resolve_component("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(&mut fsys::ComponentDecl::EMPTY.clone()) |
| .expect("failed to encode ComponentDecl FIDL"); |
| let capacity = cm_bytes.len() as u64; |
| let vmo = Vmo::create(capacity)?; |
| 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::OPEN_RIGHT_READABLE, |
| fio::MODE_TYPE_DIRECTORY, |
| Path::empty(), |
| ServerEnd::new(dir.into_channel()), |
| ); |
| responder.send(&mut Ok(())).unwrap(); |
| } |
| _ => panic!("unexpected API call"), |
| } |
| } |
| }; |
| let client = async move { |
| assert_matches!( |
| resolve_component("fuchsia-pkg://fuchsia.com/test#meta/test.cm", &proxy).await, |
| Ok(fsys::Component { decl: Some(fmem::Data::Buffer(_)), .. }) |
| ); |
| }; |
| 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("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(Status::NO_SPACE.into_raw())).unwrap(); |
| } |
| _ => panic!("unexpected API call"), |
| } |
| } |
| }; |
| let client = async move { |
| assert_matches!( |
| resolve_component("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::OPEN_RIGHT_READABLE, |
| fio::MODE_TYPE_DIRECTORY, |
| Path::empty(), |
| ServerEnd::new(dir.into_channel()), |
| ); |
| responder.send(&mut Ok(())).unwrap(); |
| } |
| _ => panic!("unexpected API call"), |
| } |
| } |
| }; |
| let client = async move { |
| assert_matches!( |
| resolve_component("fuchsia-pkg://fuchsia.com/test#meta/test.cm", &proxy).await, |
| Err(ResolverError::ComponentNotFound(_)) |
| ); |
| }; |
| join!(server, client); |
| } |
| } |
