| // Copyright 2019 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 { |
| cm_fidl_validator, cm_types, fidl_fuchsia_data as fdata, fidl_fuchsia_io2 as fio2, |
| fidl_fuchsia_sys2 as fsys, |
| std::collections::HashMap, |
| std::convert::{From, TryFrom, TryInto}, |
| std::fmt, |
| std::path::PathBuf, |
| std::str::FromStr, |
| thiserror::Error, |
| }; |
| |
| pub mod data; |
| |
| /// Converts a fidl object into its corresponding native representation. |
| pub trait FidlIntoNative<T> { |
| fn fidl_into_native(self) -> T; |
| } |
| |
| pub trait NativeIntoFidl<T> { |
| fn native_into_fidl(self) -> T; |
| } |
| |
| /// Generates `FidlIntoNative` and `NativeIntoFidl` implementations for a basic type from |
| /// `Option<type>` that respectively unwraps the Option and wraps the internal value in a `Some()`. |
| macro_rules! fidl_translations_opt_type { |
| ($into_type:ty) => { |
| impl FidlIntoNative<$into_type> for Option<$into_type> { |
| fn fidl_into_native(self) -> $into_type { |
| self.unwrap() |
| } |
| } |
| impl NativeIntoFidl<Option<$into_type>> for $into_type { |
| fn native_into_fidl(self) -> Option<$into_type> { |
| Some(self) |
| } |
| } |
| }; |
| } |
| |
| /// Generates `FidlIntoNative` and `NativeIntoFidl` implementations that leaves the input unchanged. |
| macro_rules! fidl_translations_identical { |
| ($into_type:ty) => { |
| impl FidlIntoNative<$into_type> for $into_type { |
| fn fidl_into_native(self) -> $into_type { |
| self |
| } |
| } |
| impl NativeIntoFidl<$into_type> for $into_type { |
| fn native_into_fidl(self) -> Self { |
| self |
| } |
| } |
| }; |
| } |
| |
| /// Generates a struct with a `FidlIntoNative` implementation that calls `fidl_into_native()` on |
| /// each field. |
| /// - `into_type` is the name of the struct and the into type for the conversion. |
| /// - `into_ident` must be identical to `into_type`. |
| /// - `from_type` is the from type for the conversion. |
| /// - `from_path` must be identical to `from_type`. |
| /// - `field: type` form a list of fields and their types for the generated struct. |
| macro_rules! fidl_into_struct { |
| ($into_type:ty, $into_ident:ident, $from_type:ty, $from_path:path, |
| { $( $field:ident: $type:ty, )+ } ) => { |
| #[derive(Debug, Clone, PartialEq)] |
| pub struct $into_ident { |
| $( |
| pub $field: $type, |
| )+ |
| } |
| |
| impl FidlIntoNative<$into_type> for $from_type { |
| fn fidl_into_native(self) -> $into_type { |
| $into_ident { $( $field: self.$field.fidl_into_native(), )+ } |
| } |
| } |
| |
| impl NativeIntoFidl<$from_type> for $into_type { |
| fn native_into_fidl(self) -> $from_type { |
| use $from_path as from_ident; |
| from_ident { $( $field: self.$field.native_into_fidl(), )+ } |
| } |
| } |
| } |
| } |
| |
| /// Generates an enum with a `FidlIntoNative` implementation that calls `fidl_into_native()` on each |
| /// field. |
| /// - `into_type` is the name of the enum and the into type for the conversion. |
| /// - `into_ident` must be identical to `into_type`. |
| /// - `from_type` is the from type for the conversion. |
| /// - `from_ident` must be identical to `from_type`. |
| /// - `variant(type)` form a list of variants and their types for the generated enum. |
| macro_rules! fidl_into_enum { |
| ($into_type:ty, $into_ident:ident, $from_type:ty, $from_path:path, |
| { $( $variant:ident($type:ty), )+ } ) => { |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum $into_ident { |
| $( |
| $variant($type), |
| )+ |
| } |
| |
| impl FidlIntoNative<$into_type> for $from_type { |
| fn fidl_into_native(self) -> $into_type { |
| use $from_path as from_ident; |
| match self { |
| $( |
| from_ident::$variant(e) => $into_ident::$variant(e.fidl_into_native()), |
| )+ |
| from_ident::__UnknownVariant {..} => { panic!("invalid variant") } |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<$from_type> for $into_type { |
| fn native_into_fidl(self) -> $from_type { |
| use $from_path as from_ident; |
| match self { |
| $( |
| $into_ident::$variant(e) => from_ident::$variant(e.native_into_fidl()), |
| )+ |
| } |
| } |
| } |
| } |
| } |
| |
| /// Generates `FidlIntoNative` and `NativeIntoFidl` implementations between `Vec` and |
| /// `Option<Vec>`. |
| /// - `into_type` is the name of the struct and the into type for the conversion. |
| /// - `from_type` is the from type for the conversion. |
| macro_rules! fidl_into_vec { |
| ($into_type:ty, $from_type:ty) => { |
| impl FidlIntoNative<Vec<$into_type>> for Option<Vec<$from_type>> { |
| fn fidl_into_native(self) -> Vec<$into_type> { |
| if let Some(from) = self { |
| from.into_iter().map(|e: $from_type| e.fidl_into_native()).collect() |
| } else { |
| vec![] |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<Option<Vec<$from_type>>> for Vec<$into_type> { |
| fn native_into_fidl(self) -> Option<Vec<$from_type>> { |
| if self.is_empty() { |
| None |
| } else { |
| Some(self.into_iter().map(|e: $into_type| e.native_into_fidl()).collect()) |
| } |
| } |
| } |
| }; |
| } |
| |
| #[derive(Debug, PartialEq, Default)] |
| pub struct ComponentDecl { |
| pub program: Option<fdata::Dictionary>, |
| pub uses: Vec<UseDecl>, |
| pub exposes: Vec<ExposeDecl>, |
| pub offers: Vec<OfferDecl>, |
| pub children: Vec<ChildDecl>, |
| pub collections: Vec<CollectionDecl>, |
| pub storage: Vec<StorageDecl>, |
| pub facets: Option<fsys::Object>, |
| pub runners: Vec<RunnerDecl>, |
| pub environments: Vec<EnvironmentDecl>, |
| pub resolvers: Vec<ResolverDecl>, |
| } |
| |
| impl FidlIntoNative<ComponentDecl> for fsys::ComponentDecl { |
| fn fidl_into_native(self) -> ComponentDecl { |
| // When transforming ExposeDecl::Service and OfferDecl::Service from |
| // FIDL to native, we aggregate the declarations by target. |
| let mut exposes = vec![]; |
| if let Some(e) = self.exposes { |
| let mut services: HashMap<(ExposeTarget, CapabilityPath), Vec<_>> = HashMap::new(); |
| for expose in e.into_iter() { |
| match expose { |
| fsys::ExposeDecl::Service(s) => services |
| .entry((s.target.fidl_into_native(), s.target_path.fidl_into_native())) |
| .or_default() |
| .push(ServiceSource::<ExposeServiceSource> { |
| source: s.source.fidl_into_native(), |
| source_path: s.source_path.fidl_into_native(), |
| }), |
| fsys::ExposeDecl::Protocol(ls) => { |
| exposes.push(ExposeDecl::Protocol(ls.fidl_into_native())) |
| } |
| fsys::ExposeDecl::Directory(d) => { |
| exposes.push(ExposeDecl::Directory(d.fidl_into_native())) |
| } |
| fsys::ExposeDecl::Runner(r) => { |
| exposes.push(ExposeDecl::Runner(r.fidl_into_native())) |
| } |
| fsys::ExposeDecl::Resolver(r) => { |
| exposes.push(ExposeDecl::Resolver(r.fidl_into_native())) |
| } |
| fsys::ExposeDecl::__UnknownVariant { .. } => panic!("invalid variant"), |
| } |
| } |
| for ((target, target_path), sources) in services.into_iter() { |
| exposes.push(ExposeDecl::Service(ExposeServiceDecl { |
| sources, |
| target, |
| target_path, |
| })) |
| } |
| } |
| let mut offers = vec![]; |
| if let Some(o) = self.offers { |
| let mut services: HashMap<(OfferTarget, CapabilityPath), Vec<_>> = HashMap::new(); |
| for offer in o.into_iter() { |
| match offer { |
| fsys::OfferDecl::Service(s) => services |
| .entry((s.target.fidl_into_native(), s.target_path.fidl_into_native())) |
| .or_default() |
| .push(ServiceSource::<OfferServiceSource> { |
| source: s.source.fidl_into_native(), |
| source_path: s.source_path.fidl_into_native(), |
| }), |
| fsys::OfferDecl::Protocol(ls) => { |
| offers.push(OfferDecl::Protocol(ls.fidl_into_native())) |
| } |
| fsys::OfferDecl::Directory(d) => { |
| offers.push(OfferDecl::Directory(d.fidl_into_native())) |
| } |
| fsys::OfferDecl::Storage(s) => { |
| offers.push(OfferDecl::Storage(s.fidl_into_native())) |
| } |
| fsys::OfferDecl::Runner(s) => { |
| offers.push(OfferDecl::Runner(s.fidl_into_native())) |
| } |
| fsys::OfferDecl::Resolver(r) => { |
| offers.push(OfferDecl::Resolver(r.fidl_into_native())) |
| } |
| fsys::OfferDecl::__UnknownVariant { .. } => panic!("invalid variant"), |
| } |
| } |
| for ((target, target_path), sources) in services.into_iter() { |
| offers.push(OfferDecl::Service(OfferServiceDecl { sources, target, target_path })) |
| } |
| } |
| ComponentDecl { |
| program: self.program.fidl_into_native(), |
| uses: self.uses.fidl_into_native(), |
| exposes, |
| offers, |
| children: self.children.fidl_into_native(), |
| collections: self.collections.fidl_into_native(), |
| storage: self.storage.fidl_into_native(), |
| facets: self.facets.fidl_into_native(), |
| runners: self.runners.fidl_into_native(), |
| environments: self.environments.fidl_into_native(), |
| resolvers: self.resolvers.fidl_into_native(), |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<fsys::ComponentDecl> for ComponentDecl { |
| fn native_into_fidl(self) -> fsys::ComponentDecl { |
| // When transforming ExposeDecl::Service and OfferDecl::Service from |
| // native to FIDL, we disaggregate the declarations. |
| let mut exposes = vec![]; |
| for expose in self.exposes.into_iter() { |
| match expose { |
| ExposeDecl::Service(s) => { |
| for es in s.sources.into_iter() { |
| exposes.push(fsys::ExposeDecl::Service(fsys::ExposeServiceDecl { |
| source: es.source.native_into_fidl(), |
| source_path: es.source_path.native_into_fidl(), |
| target: s.target.clone().native_into_fidl(), |
| target_path: s.target_path.clone().native_into_fidl(), |
| })) |
| } |
| } |
| ExposeDecl::Protocol(ls) => { |
| exposes.push(fsys::ExposeDecl::Protocol(ls.native_into_fidl())) |
| } |
| ExposeDecl::Directory(d) => { |
| exposes.push(fsys::ExposeDecl::Directory(d.native_into_fidl())) |
| } |
| ExposeDecl::Runner(r) => { |
| exposes.push(fsys::ExposeDecl::Runner(r.native_into_fidl())) |
| } |
| ExposeDecl::Resolver(r) => { |
| exposes.push(fsys::ExposeDecl::Resolver(r.native_into_fidl())) |
| } |
| } |
| } |
| let mut offers = vec![]; |
| for offer in self.offers.into_iter() { |
| match offer { |
| OfferDecl::Service(s) => { |
| for os in s.sources.into_iter() { |
| offers.push(fsys::OfferDecl::Service(fsys::OfferServiceDecl { |
| source: os.source.native_into_fidl(), |
| source_path: os.source_path.native_into_fidl(), |
| target: s.target.clone().native_into_fidl(), |
| target_path: s.target_path.clone().native_into_fidl(), |
| })) |
| } |
| } |
| OfferDecl::Protocol(ls) => { |
| offers.push(fsys::OfferDecl::Protocol(ls.native_into_fidl())) |
| } |
| OfferDecl::Directory(d) => { |
| offers.push(fsys::OfferDecl::Directory(d.native_into_fidl())) |
| } |
| OfferDecl::Storage(s) => { |
| offers.push(fsys::OfferDecl::Storage(s.native_into_fidl())) |
| } |
| OfferDecl::Runner(s) => offers.push(fsys::OfferDecl::Runner(s.native_into_fidl())), |
| OfferDecl::Resolver(r) => { |
| offers.push(fsys::OfferDecl::Resolver(r.native_into_fidl())) |
| } |
| } |
| } |
| fsys::ComponentDecl { |
| program: self.program.native_into_fidl(), |
| uses: self.uses.native_into_fidl(), |
| exposes: if exposes.is_empty() { None } else { Some(exposes) }, |
| offers: if offers.is_empty() { None } else { Some(offers) }, |
| children: self.children.native_into_fidl(), |
| collections: self.collections.native_into_fidl(), |
| storage: self.storage.native_into_fidl(), |
| facets: self.facets.native_into_fidl(), |
| runners: self.runners.native_into_fidl(), |
| environments: self.environments.native_into_fidl(), |
| resolvers: self.resolvers.native_into_fidl(), |
| } |
| } |
| } |
| |
| impl Clone for ComponentDecl { |
| fn clone(&self) -> Self { |
| ComponentDecl { |
| program: data::clone_option_dictionary(&self.program), |
| uses: self.uses.clone(), |
| exposes: self.exposes.clone(), |
| offers: self.offers.clone(), |
| children: self.children.clone(), |
| collections: self.collections.clone(), |
| storage: self.storage.clone(), |
| facets: data::clone_option_object(&self.facets), |
| runners: self.runners.clone(), |
| environments: self.environments.clone(), |
| resolvers: self.resolvers.clone(), |
| } |
| } |
| } |
| |
| impl ComponentDecl { |
| /// Returns the `StorageDecl` corresponding to `storage_name`. |
| pub fn find_storage_source<'a>(&'a self, storage_name: &str) -> Option<&'a StorageDecl> { |
| self.storage.iter().find(|s| &s.name == storage_name) |
| } |
| |
| /// Returns the `CollectionDecl` corresponding to `collection_name`. |
| pub fn find_collection<'a>(&'a self, collection_name: &str) -> Option<&'a CollectionDecl> { |
| self.collections.iter().find(|c| c.name == collection_name) |
| } |
| |
| /// Returns the `RunnerDecl` corresponding to `runner_name`. |
| pub fn find_runner_source<'a>(&'a self, runner_name: &str) -> Option<&'a RunnerDecl> { |
| self.runners.iter().find(|s| &s.name == runner_name) |
| } |
| |
| /// Indicates whether the capability specified by `target_path` is exposed to the framework. |
| pub fn is_protocol_exposed_to_framework(&self, target_path: &CapabilityPath) -> bool { |
| self.exposes.iter().any(|expose| match expose { |
| ExposeDecl::Protocol(ls) => { |
| ls.target == ExposeTarget::Framework && ls.target_path == *target_path |
| } |
| _ => false, |
| }) |
| } |
| |
| /// Indicates whether the capability specified by `target_path` is requested. |
| pub fn uses_protocol_from_framework(&self, target_path: &CapabilityPath) -> bool { |
| self.uses.iter().any(|use_decl| match use_decl { |
| UseDecl::Protocol(ls) => { |
| ls.source == UseSource::Framework && ls.target_path == *target_path |
| } |
| _ => false, |
| }) |
| } |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum ExposeDecl { |
| Service(ExposeServiceDecl), |
| Protocol(ExposeProtocolDecl), |
| Directory(ExposeDirectoryDecl), |
| Runner(ExposeRunnerDecl), |
| Resolver(ExposeResolverDecl), |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub struct ExposeServiceDecl { |
| pub sources: Vec<ServiceSource<ExposeServiceSource>>, |
| pub target: ExposeTarget, |
| pub target_path: CapabilityPath, |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum OfferDecl { |
| Service(OfferServiceDecl), |
| Protocol(OfferProtocolDecl), |
| Directory(OfferDirectoryDecl), |
| Storage(OfferStorageDecl), |
| Runner(OfferRunnerDecl), |
| Resolver(OfferResolverDecl), |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub struct OfferServiceDecl { |
| pub sources: Vec<ServiceSource<OfferServiceSource>>, |
| pub target: OfferTarget, |
| pub target_path: CapabilityPath, |
| } |
| |
| fidl_into_enum!(UseDecl, UseDecl, fsys::UseDecl, fsys::UseDecl, |
| { |
| Service(UseServiceDecl), |
| Protocol(UseProtocolDecl), |
| Directory(UseDirectoryDecl), |
| Storage(UseStorageDecl), |
| Runner(UseRunnerDecl), |
| }); |
| fidl_into_struct!(UseServiceDecl, UseServiceDecl, fsys::UseServiceDecl, fsys::UseServiceDecl, |
| { |
| source: UseSource, |
| source_path: CapabilityPath, |
| target_path: CapabilityPath, |
| }); |
| fidl_into_struct!(UseProtocolDecl, UseProtocolDecl, fsys::UseProtocolDecl, fsys::UseProtocolDecl, |
| { |
| source: UseSource, |
| source_path: CapabilityPath, |
| target_path: CapabilityPath, |
| }); |
| fidl_into_struct!(UseDirectoryDecl, UseDirectoryDecl, fsys::UseDirectoryDecl, |
| fsys::UseDirectoryDecl, |
| { |
| source: UseSource, |
| source_path: CapabilityPath, |
| target_path: CapabilityPath, |
| rights: fio2::Operations, |
| subdir: Option<PathBuf>, |
| }); |
| fidl_into_struct!(UseRunnerDecl, UseRunnerDecl, fsys::UseRunnerDecl, |
| fsys::UseRunnerDecl, |
| { |
| source_name: CapabilityName, |
| }); |
| |
| fidl_into_struct!(ExposeProtocolDecl, ExposeProtocolDecl, fsys::ExposeProtocolDecl, |
| fsys::ExposeProtocolDecl, |
| { |
| source: ExposeSource, |
| source_path: CapabilityPath, |
| target: ExposeTarget, |
| target_path: CapabilityPath, |
| }); |
| fidl_into_struct!(ExposeDirectoryDecl, ExposeDirectoryDecl, fsys::ExposeDirectoryDecl, |
| fsys::ExposeDirectoryDecl, |
| { |
| source: ExposeSource, |
| source_path: CapabilityPath, |
| target: ExposeTarget, |
| target_path: CapabilityPath, |
| rights: Option<fio2::Operations>, |
| subdir: Option<PathBuf>, |
| }); |
| fidl_into_struct!(ExposeResolverDecl, ExposeResolverDecl, fsys::ExposeResolverDecl, |
| fsys::ExposeResolverDecl, |
| { |
| source: ExposeSource, |
| source_name: CapabilityName, |
| target: ExposeTarget, |
| target_name: CapabilityName, |
| }); |
| fidl_into_struct!(ExposeRunnerDecl, ExposeRunnerDecl, fsys::ExposeRunnerDecl, |
| fsys::ExposeRunnerDecl, |
| { |
| source: ExposeSource, |
| source_name: CapabilityName, |
| target: ExposeTarget, |
| target_name: CapabilityName, |
| }); |
| fidl_into_struct!(StorageDecl, StorageDecl, fsys::StorageDecl, |
| fsys::StorageDecl, |
| { |
| name: String, |
| source: StorageDirectorySource, |
| source_path: CapabilityPath, |
| }); |
| fidl_into_struct!(OfferProtocolDecl, OfferProtocolDecl, fsys::OfferProtocolDecl, |
| fsys::OfferProtocolDecl, |
| { |
| source: OfferServiceSource, |
| source_path: CapabilityPath, |
| target: OfferTarget, |
| target_path: CapabilityPath, |
| dependency_type: DependencyType, |
| }); |
| fidl_into_struct!(OfferDirectoryDecl, OfferDirectoryDecl, fsys::OfferDirectoryDecl, |
| fsys::OfferDirectoryDecl, |
| { |
| source: OfferDirectorySource, |
| source_path: CapabilityPath, |
| target: OfferTarget, |
| target_path: CapabilityPath, |
| rights: Option<fio2::Operations>, |
| subdir: Option<PathBuf>, |
| dependency_type: DependencyType, |
| }); |
| fidl_into_struct!(OfferResolverDecl, OfferResolverDecl, fsys::OfferResolverDecl, |
| fsys::OfferResolverDecl, |
| { |
| source: OfferResolverSource, |
| source_name: CapabilityName, |
| target: OfferTarget, |
| target_name: CapabilityName, |
| }); |
| fidl_into_struct!(OfferRunnerDecl, OfferRunnerDecl, fsys::OfferRunnerDecl, |
| fsys::OfferRunnerDecl, |
| { |
| source: OfferRunnerSource, |
| source_name: CapabilityName, |
| target: OfferTarget, |
| target_name: CapabilityName, |
| }); |
| fidl_into_struct!(ChildDecl, ChildDecl, fsys::ChildDecl, fsys::ChildDecl, |
| { |
| name: String, |
| url: String, |
| startup: fsys::StartupMode, |
| environment: Option<String>, |
| }); |
| |
| fidl_into_struct!(CollectionDecl, CollectionDecl, fsys::CollectionDecl, fsys::CollectionDecl, |
| { |
| name: String, |
| durability: fsys::Durability, |
| }); |
| fidl_into_struct!(ResolverDecl, ResolverDecl, fsys::ResolverDecl, fsys::ResolverDecl, |
| { |
| name: String, |
| source_path: CapabilityPath, |
| }); |
| fidl_into_struct!(RunnerDecl, RunnerDecl, fsys::RunnerDecl, fsys::RunnerDecl, |
| { |
| name: String, |
| source: RunnerSource, |
| source_path: CapabilityPath, |
| }); |
| fidl_into_struct!(EnvironmentDecl, EnvironmentDecl, fsys::EnvironmentDecl, fsys::EnvironmentDecl, |
| { |
| name: String, |
| extends: fsys::EnvironmentExtends, |
| }); |
| |
| fidl_into_vec!(UseDecl, fsys::UseDecl); |
| fidl_into_vec!(ChildDecl, fsys::ChildDecl); |
| fidl_into_vec!(CollectionDecl, fsys::CollectionDecl); |
| fidl_into_vec!(StorageDecl, fsys::StorageDecl); |
| fidl_into_vec!(ResolverDecl, fsys::ResolverDecl); |
| fidl_into_vec!(RunnerDecl, fsys::RunnerDecl); |
| fidl_into_vec!(EnvironmentDecl, fsys::EnvironmentDecl); |
| fidl_translations_opt_type!(String); |
| fidl_translations_opt_type!(fsys::StartupMode); |
| fidl_translations_opt_type!(fsys::Durability); |
| fidl_translations_opt_type!(fsys::Object); |
| fidl_translations_opt_type!(fdata::Dictionary); |
| fidl_translations_opt_type!(fio2::Operations); |
| fidl_translations_opt_type!(fsys::EnvironmentExtends); |
| fidl_translations_identical!(Option<fio2::Operations>); |
| fidl_translations_identical!(Option<fsys::Object>); |
| fidl_translations_identical!(Option<fdata::Dictionary>); |
| fidl_translations_identical!(Option<String>); |
| |
| /// A path to a capability. |
| #[derive(Debug, Clone, PartialEq, Eq, Hash)] |
| pub struct CapabilityPath { |
| /// The directory containing the last path element, e.g. `/svc/foo` in `/svc/foo/bar`. |
| pub dirname: String, |
| /// The last path element: e.g. `bar` in `/svc/foo/bar`. |
| pub basename: String, |
| } |
| |
| impl CapabilityPath { |
| pub fn to_path_buf(&self) -> PathBuf { |
| PathBuf::from(self.to_string()) |
| } |
| |
| /// Splits the path according to "/", ignoring empty path components |
| pub fn split(&self) -> Vec<String> { |
| self.to_string().split("/").map(|s| s.to_string()).filter(|s| !s.is_empty()).collect() |
| } |
| } |
| |
| impl FromStr for CapabilityPath { |
| type Err = Error; |
| |
| fn from_str(path: &str) -> Result<CapabilityPath, Error> { |
| cm_types::Path::validate(path) |
| .map_err(|_| Error::InvalidCapabilityPath { raw: path.to_string() })?; |
| let idx = path.rfind('/').expect("path validation is wrong"); |
| Ok(CapabilityPath { |
| dirname: if idx == 0 { "/".to_string() } else { path[0..idx].to_string() }, |
| basename: path[idx + 1..].to_string(), |
| }) |
| } |
| } |
| |
| impl TryFrom<&str> for CapabilityPath { |
| type Error = Error; |
| |
| fn try_from(path: &str) -> Result<CapabilityPath, Error> { |
| Self::from_str(path) |
| } |
| } |
| |
| impl fmt::Display for CapabilityPath { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| if &self.dirname == "/" { |
| write!(f, "/{}", self.basename) |
| } else { |
| write!(f, "{}/{}", self.dirname, self.basename) |
| } |
| } |
| } |
| |
| impl UseDecl { |
| pub fn path(&self) -> Option<&CapabilityPath> { |
| let path = match self { |
| UseDecl::Service(d) => &d.target_path, |
| UseDecl::Protocol(d) => &d.target_path, |
| UseDecl::Directory(d) => &d.target_path, |
| UseDecl::Storage(UseStorageDecl::Data(p)) => &p, |
| UseDecl::Storage(UseStorageDecl::Cache(p)) => &p, |
| UseDecl::Storage(UseStorageDecl::Meta) | UseDecl::Runner(_) => { |
| // Meta storage and runners don't show up in the namespace; no capability path. |
| return None; |
| } |
| }; |
| Some(path) |
| } |
| } |
| |
| /// A named capability. |
| /// |
| /// Unlike a `CapabilityPath`, a `CapabilityName` doesn't encode any form |
| /// of hierarchy. |
| #[derive(Debug, Clone, PartialEq, Eq, Hash)] |
| pub struct CapabilityName(pub String); |
| |
| impl CapabilityName { |
| pub fn str(&self) -> &str { |
| &self.0 |
| } |
| } |
| |
| impl From<&str> for CapabilityName { |
| fn from(name: &str) -> CapabilityName { |
| CapabilityName(name.to_string()) |
| } |
| } |
| |
| impl fmt::Display for CapabilityName { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| <String as fmt::Display>::fmt(&self.0, f) |
| } |
| } |
| |
| // TODO: Runners and third parties can use this to parse `facets`. |
| impl FidlIntoNative<Option<HashMap<String, Value>>> for Option<fsys::Object> { |
| fn fidl_into_native(self) -> Option<HashMap<String, Value>> { |
| self.map(|o| from_fidl_obj(o)) |
| } |
| } |
| |
| impl FidlIntoNative<Option<HashMap<String, DictionaryValue>>> for Option<fdata::Dictionary> { |
| fn fidl_into_native(self) -> Option<HashMap<String, DictionaryValue>> { |
| self.map(|d| from_fidl_dict(d)) |
| } |
| } |
| |
| impl FidlIntoNative<CapabilityPath> for Option<String> { |
| fn fidl_into_native(self) -> CapabilityPath { |
| let s: &str = &self.unwrap(); |
| s.try_into().expect("invalid capability path") |
| } |
| } |
| |
| impl NativeIntoFidl<Option<String>> for CapabilityPath { |
| fn native_into_fidl(self) -> Option<String> { |
| Some(self.to_string()) |
| } |
| } |
| |
| impl FidlIntoNative<Option<PathBuf>> for Option<String> { |
| fn fidl_into_native(self) -> Option<PathBuf> { |
| self.map(|p| PathBuf::from(p)) |
| } |
| } |
| |
| impl NativeIntoFidl<Option<String>> for Option<PathBuf> { |
| fn native_into_fidl(self) -> Option<String> { |
| self.map(|p| p.to_str().expect("invalid utf8").to_string()) |
| } |
| } |
| |
| impl FidlIntoNative<CapabilityName> for Option<String> { |
| fn fidl_into_native(self) -> CapabilityName { |
| let s: &str = &self.unwrap(); |
| s.into() |
| } |
| } |
| |
| impl NativeIntoFidl<Option<String>> for CapabilityName { |
| fn native_into_fidl(self) -> Option<String> { |
| Some(self.to_string()) |
| } |
| } |
| |
| impl FidlIntoNative<bool> for Option<bool> { |
| fn fidl_into_native(self) -> bool { |
| self.unwrap() |
| } |
| } |
| |
| impl NativeIntoFidl<Option<bool>> for bool { |
| fn native_into_fidl(self) -> Option<bool> { |
| Some(self) |
| } |
| } |
| |
| #[derive(Debug, PartialEq)] |
| pub enum Value { |
| Bit(bool), |
| Inum(i64), |
| Fnum(f64), |
| Str(String), |
| Vec(Vec<Value>), |
| Obj(HashMap<String, Value>), |
| Null, |
| } |
| |
| #[derive(Debug, PartialEq)] |
| pub enum DictionaryValue { |
| Str(String), |
| StrVec(Vec<String>), |
| Null, |
| } |
| |
| impl FidlIntoNative<Value> for Option<Box<fsys::Value>> { |
| fn fidl_into_native(self) -> Value { |
| match self { |
| Some(v) => match *v { |
| fsys::Value::Bit(b) => Value::Bit(b), |
| fsys::Value::Inum(i) => Value::Inum(i), |
| fsys::Value::Fnum(f) => Value::Fnum(f), |
| fsys::Value::Str(s) => Value::Str(s), |
| fsys::Value::Vec(v) => Value::Vec(from_fidl_vec(v)), |
| fsys::Value::Obj(d) => Value::Obj(from_fidl_obj(d)), |
| }, |
| None => Value::Null, |
| } |
| } |
| } |
| |
| impl FidlIntoNative<DictionaryValue> for Option<Box<fdata::DictionaryValue>> { |
| fn fidl_into_native(self) -> DictionaryValue { |
| match self { |
| Some(v) => match *v { |
| fdata::DictionaryValue::Str(s) => DictionaryValue::Str(s), |
| fdata::DictionaryValue::StrVec(ss) => DictionaryValue::StrVec(ss), |
| }, |
| None => DictionaryValue::Null, |
| } |
| } |
| } |
| |
| fn from_fidl_vec(vec: fsys::Vector) -> Vec<Value> { |
| vec.values.into_iter().map(|v| v.fidl_into_native()).collect() |
| } |
| |
| fn from_fidl_obj(obj: fsys::Object) -> HashMap<String, Value> { |
| obj.entries.into_iter().map(|e| (e.key, e.value.fidl_into_native())).collect() |
| } |
| |
| fn from_fidl_dict(dict: fdata::Dictionary) -> HashMap<String, DictionaryValue> { |
| match dict.entries { |
| Some(entries) => entries.into_iter().map(|e| (e.key, e.value.fidl_into_native())).collect(), |
| _ => HashMap::new(), |
| } |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum UseStorageDecl { |
| Data(CapabilityPath), |
| Cache(CapabilityPath), |
| Meta, |
| } |
| |
| impl FidlIntoNative<UseStorageDecl> for fsys::UseStorageDecl { |
| fn fidl_into_native(self) -> UseStorageDecl { |
| match self.type_.unwrap() { |
| fsys::StorageType::Data => { |
| UseStorageDecl::Data(self.target_path.unwrap().as_str().try_into().unwrap()) |
| } |
| fsys::StorageType::Cache => { |
| UseStorageDecl::Cache(self.target_path.unwrap().as_str().try_into().unwrap()) |
| } |
| fsys::StorageType::Meta => UseStorageDecl::Meta, |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<fsys::UseStorageDecl> for UseStorageDecl { |
| fn native_into_fidl(self) -> fsys::UseStorageDecl { |
| match self { |
| UseStorageDecl::Data(p) => fsys::UseStorageDecl { |
| type_: Some(fsys::StorageType::Data), |
| target_path: p.native_into_fidl(), |
| }, |
| UseStorageDecl::Cache(p) => fsys::UseStorageDecl { |
| type_: Some(fsys::StorageType::Cache), |
| target_path: p.native_into_fidl(), |
| }, |
| UseStorageDecl::Meta => { |
| fsys::UseStorageDecl { type_: Some(fsys::StorageType::Meta), target_path: None } |
| } |
| } |
| } |
| } |
| |
| impl UseStorageDecl { |
| pub fn type_(&self) -> fsys::StorageType { |
| match self { |
| UseStorageDecl::Data(_) => fsys::StorageType::Data, |
| UseStorageDecl::Cache(_) => fsys::StorageType::Cache, |
| UseStorageDecl::Meta => fsys::StorageType::Meta, |
| } |
| } |
| |
| pub fn path<'a>(&'a self) -> Option<&'a CapabilityPath> { |
| match self { |
| UseStorageDecl::Data(p) => Some(p), |
| UseStorageDecl::Cache(p) => Some(p), |
| UseStorageDecl::Meta => None, |
| } |
| } |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum OfferStorageDecl { |
| Data(OfferStorage), |
| Cache(OfferStorage), |
| Meta(OfferStorage), |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub struct OfferStorage { |
| pub source: OfferStorageSource, |
| pub target: OfferTarget, |
| } |
| |
| impl FidlIntoNative<OfferStorageDecl> for fsys::OfferStorageDecl { |
| fn fidl_into_native(self) -> OfferStorageDecl { |
| match self.type_.unwrap() { |
| fsys::StorageType::Data => OfferStorageDecl::Data(OfferStorage { |
| source: self.source.fidl_into_native(), |
| target: self.target.fidl_into_native(), |
| }), |
| fsys::StorageType::Cache => OfferStorageDecl::Cache(OfferStorage { |
| source: self.source.fidl_into_native(), |
| target: self.target.fidl_into_native(), |
| }), |
| fsys::StorageType::Meta => OfferStorageDecl::Meta(OfferStorage { |
| source: self.source.fidl_into_native(), |
| target: self.target.fidl_into_native(), |
| }), |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<fsys::OfferStorageDecl> for OfferStorageDecl { |
| fn native_into_fidl(self) -> fsys::OfferStorageDecl { |
| let type_ = self.type_(); |
| let (source, target) = match self { |
| OfferStorageDecl::Data(OfferStorage { source, target }) => (source, target), |
| OfferStorageDecl::Cache(OfferStorage { source, target }) => (source, target), |
| OfferStorageDecl::Meta(OfferStorage { source, target }) => (source, target), |
| }; |
| fsys::OfferStorageDecl { |
| type_: Some(type_), |
| source: source.native_into_fidl(), |
| target: target.native_into_fidl(), |
| } |
| } |
| } |
| |
| impl OfferStorageDecl { |
| pub fn type_(&self) -> fsys::StorageType { |
| match self { |
| OfferStorageDecl::Data(..) => fsys::StorageType::Data, |
| OfferStorageDecl::Cache(..) => fsys::StorageType::Cache, |
| OfferStorageDecl::Meta(..) => fsys::StorageType::Meta, |
| } |
| } |
| |
| pub fn source(&self) -> &OfferStorageSource { |
| match self { |
| OfferStorageDecl::Data(OfferStorage { source, .. }) => source, |
| OfferStorageDecl::Cache(OfferStorage { source, .. }) => source, |
| OfferStorageDecl::Meta(OfferStorage { source, .. }) => source, |
| } |
| } |
| |
| pub fn target(&self) -> &OfferTarget { |
| match self { |
| OfferStorageDecl::Data(OfferStorage { target, .. }) => target, |
| OfferStorageDecl::Cache(OfferStorage { target, .. }) => target, |
| OfferStorageDecl::Meta(OfferStorage { target, .. }) => target, |
| } |
| } |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum UseSource { |
| Realm, |
| Framework, |
| } |
| |
| impl FidlIntoNative<UseSource> for Option<fsys::Ref> { |
| fn fidl_into_native(self) -> UseSource { |
| match self.unwrap() { |
| fsys::Ref::Realm(_) => UseSource::Realm, |
| fsys::Ref::Framework(_) => UseSource::Framework, |
| _ => panic!("invalid UseSource variant"), |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<Option<fsys::Ref>> for UseSource { |
| fn native_into_fidl(self) -> Option<fsys::Ref> { |
| Some(match self { |
| UseSource::Realm => fsys::Ref::Realm(fsys::RealmRef {}), |
| UseSource::Framework => fsys::Ref::Framework(fsys::FrameworkRef {}), |
| }) |
| } |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum ExposeSource { |
| Self_, |
| Child(String), |
| Framework, |
| } |
| |
| impl FidlIntoNative<ExposeSource> for Option<fsys::Ref> { |
| fn fidl_into_native(self) -> ExposeSource { |
| match self.unwrap() { |
| fsys::Ref::Self_(_) => ExposeSource::Self_, |
| fsys::Ref::Child(c) => ExposeSource::Child(c.name), |
| fsys::Ref::Framework(_) => ExposeSource::Framework, |
| _ => panic!("invalid ExposeSource variant"), |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<Option<fsys::Ref>> for ExposeSource { |
| fn native_into_fidl(self) -> Option<fsys::Ref> { |
| Some(match self { |
| ExposeSource::Self_ => fsys::Ref::Self_(fsys::SelfRef {}), |
| ExposeSource::Child(child_name) => { |
| fsys::Ref::Child(fsys::ChildRef { name: child_name, collection: None }) |
| } |
| ExposeSource::Framework => fsys::Ref::Framework(fsys::FrameworkRef {}), |
| }) |
| } |
| } |
| |
| #[derive(Debug, Clone, PartialEq, Eq, Hash)] |
| pub enum ExposeTarget { |
| Realm, |
| Framework, |
| } |
| |
| impl FidlIntoNative<ExposeTarget> for Option<fsys::Ref> { |
| fn fidl_into_native(self) -> ExposeTarget { |
| match self { |
| Some(dest) => match dest { |
| fsys::Ref::Realm(_) => ExposeTarget::Realm, |
| fsys::Ref::Framework(_) => ExposeTarget::Framework, |
| _ => panic!("invalid ExposeTarget variant"), |
| }, |
| None => ExposeTarget::Realm, |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<Option<fsys::Ref>> for ExposeTarget { |
| fn native_into_fidl(self) -> Option<fsys::Ref> { |
| Some(match self { |
| ExposeTarget::Realm => fsys::Ref::Realm(fsys::RealmRef {}), |
| ExposeTarget::Framework => fsys::Ref::Framework(fsys::FrameworkRef {}), |
| }) |
| } |
| } |
| |
| /// A source for a service. |
| #[derive(Debug, Clone, PartialEq)] |
| pub struct ServiceSource<T> { |
| /// The provider of the service, relative to a component. |
| pub source: T, |
| /// The path at which the service is accessible. |
| pub source_path: CapabilityPath, |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum DependencyType { |
| Strong, |
| WeakForMigration, |
| } |
| |
| impl FidlIntoNative<DependencyType> for Option<fsys::DependencyType> { |
| fn fidl_into_native(self) -> DependencyType { |
| match self.unwrap() { |
| fsys::DependencyType::Strong => DependencyType::Strong, |
| fsys::DependencyType::WeakForMigration => DependencyType::WeakForMigration, |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<Option<fsys::DependencyType>> for DependencyType { |
| fn native_into_fidl(self) -> Option<fsys::DependencyType> { |
| Some(match self { |
| DependencyType::Strong => fsys::DependencyType::Strong, |
| DependencyType::WeakForMigration => fsys::DependencyType::WeakForMigration, |
| }) |
| } |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum OfferServiceSource { |
| Realm, |
| Self_, |
| Child(String), |
| } |
| |
| impl FidlIntoNative<OfferServiceSource> for Option<fsys::Ref> { |
| fn fidl_into_native(self) -> OfferServiceSource { |
| match self.unwrap() { |
| fsys::Ref::Realm(_) => OfferServiceSource::Realm, |
| fsys::Ref::Self_(_) => OfferServiceSource::Self_, |
| fsys::Ref::Child(c) => OfferServiceSource::Child(c.name), |
| _ => panic!("invalid OfferServiceSource variant"), |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<Option<fsys::Ref>> for OfferServiceSource { |
| fn native_into_fidl(self) -> Option<fsys::Ref> { |
| Some(match self { |
| OfferServiceSource::Realm => fsys::Ref::Realm(fsys::RealmRef {}), |
| OfferServiceSource::Self_ => fsys::Ref::Self_(fsys::SelfRef {}), |
| OfferServiceSource::Child(child_name) => { |
| fsys::Ref::Child(fsys::ChildRef { name: child_name, collection: None }) |
| } |
| }) |
| } |
| } |
| |
| /// The valid sources of a service protocol's expose declaration. |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum ExposeServiceSource { |
| /// The service is exposed from the component manager itself. |
| Framework, |
| /// The service is exposed by the component itself. |
| Self_, |
| /// The service is exposed by a named child component. |
| Child(String), |
| } |
| |
| impl FidlIntoNative<ExposeServiceSource> for Option<fsys::Ref> { |
| fn fidl_into_native(self) -> ExposeServiceSource { |
| match self.unwrap() { |
| fsys::Ref::Framework(_) => ExposeServiceSource::Framework, |
| fsys::Ref::Self_(_) => ExposeServiceSource::Self_, |
| fsys::Ref::Child(c) => ExposeServiceSource::Child(c.name), |
| _ => panic!("invalid ExposeServiceSource variant"), |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<Option<fsys::Ref>> for ExposeServiceSource { |
| fn native_into_fidl(self) -> Option<fsys::Ref> { |
| Some(match self { |
| ExposeServiceSource::Framework => fsys::Ref::Framework(fsys::FrameworkRef {}), |
| ExposeServiceSource::Self_ => fsys::Ref::Self_(fsys::SelfRef {}), |
| ExposeServiceSource::Child(child_name) => { |
| fsys::Ref::Child(fsys::ChildRef { name: child_name, collection: None }) |
| } |
| }) |
| } |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum StorageDirectorySource { |
| Realm, |
| Self_, |
| Child(String), |
| } |
| |
| impl FidlIntoNative<StorageDirectorySource> for Option<fsys::Ref> { |
| fn fidl_into_native(self) -> StorageDirectorySource { |
| match self.unwrap() { |
| fsys::Ref::Realm(_) => StorageDirectorySource::Realm, |
| fsys::Ref::Self_(_) => StorageDirectorySource::Self_, |
| fsys::Ref::Child(c) => StorageDirectorySource::Child(c.name), |
| _ => panic!("invalid OfferDirectorySource variant"), |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<Option<fsys::Ref>> for StorageDirectorySource { |
| fn native_into_fidl(self) -> Option<fsys::Ref> { |
| Some(match self { |
| StorageDirectorySource::Realm => fsys::Ref::Realm(fsys::RealmRef {}), |
| StorageDirectorySource::Self_ => fsys::Ref::Self_(fsys::SelfRef {}), |
| StorageDirectorySource::Child(child_name) => { |
| fsys::Ref::Child(fsys::ChildRef { name: child_name, collection: None }) |
| } |
| }) |
| } |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum RunnerSource { |
| Realm, |
| Self_, |
| Child(String), |
| } |
| |
| impl FidlIntoNative<RunnerSource> for Option<fsys::Ref> { |
| fn fidl_into_native(self) -> RunnerSource { |
| match self.unwrap() { |
| fsys::Ref::Realm(_) => RunnerSource::Realm, |
| fsys::Ref::Self_(_) => RunnerSource::Self_, |
| fsys::Ref::Child(c) => RunnerSource::Child(c.name), |
| _ => panic!("invalid RunnerSource variant"), |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<Option<fsys::Ref>> for RunnerSource { |
| fn native_into_fidl(self) -> Option<fsys::Ref> { |
| Some(match self { |
| RunnerSource::Realm => fsys::Ref::Realm(fsys::RealmRef {}), |
| RunnerSource::Self_ => fsys::Ref::Self_(fsys::SelfRef {}), |
| RunnerSource::Child(child_name) => { |
| fsys::Ref::Child(fsys::ChildRef { name: child_name, collection: None }) |
| } |
| }) |
| } |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum OfferDirectorySource { |
| Realm, |
| Self_, |
| Framework, |
| Child(String), |
| } |
| |
| impl FidlIntoNative<OfferDirectorySource> for Option<fsys::Ref> { |
| fn fidl_into_native(self) -> OfferDirectorySource { |
| match self.unwrap() { |
| fsys::Ref::Realm(_) => OfferDirectorySource::Realm, |
| fsys::Ref::Self_(_) => OfferDirectorySource::Self_, |
| fsys::Ref::Framework(_) => OfferDirectorySource::Framework, |
| fsys::Ref::Child(c) => OfferDirectorySource::Child(c.name), |
| _ => panic!("invalid OfferDirectorySource variant"), |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<Option<fsys::Ref>> for OfferDirectorySource { |
| fn native_into_fidl(self) -> Option<fsys::Ref> { |
| Some(match self { |
| OfferDirectorySource::Realm => fsys::Ref::Realm(fsys::RealmRef {}), |
| OfferDirectorySource::Self_ => fsys::Ref::Self_(fsys::SelfRef {}), |
| OfferDirectorySource::Framework => fsys::Ref::Framework(fsys::FrameworkRef {}), |
| OfferDirectorySource::Child(child_name) => { |
| fsys::Ref::Child(fsys::ChildRef { name: child_name, collection: None }) |
| } |
| }) |
| } |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum OfferStorageSource { |
| Realm, |
| Storage(String), |
| } |
| |
| impl FidlIntoNative<OfferStorageSource> for Option<fsys::Ref> { |
| fn fidl_into_native(self) -> OfferStorageSource { |
| match self.unwrap() { |
| fsys::Ref::Realm(_) => OfferStorageSource::Realm, |
| fsys::Ref::Storage(c) => OfferStorageSource::Storage(c.name), |
| _ => panic!("invalid OfferStorageSource variant"), |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<Option<fsys::Ref>> for OfferStorageSource { |
| fn native_into_fidl(self) -> Option<fsys::Ref> { |
| Some(match self { |
| OfferStorageSource::Realm => fsys::Ref::Realm(fsys::RealmRef {}), |
| OfferStorageSource::Storage(name) => fsys::Ref::Storage(fsys::StorageRef { name }), |
| }) |
| } |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum OfferRunnerSource { |
| Realm, |
| Self_, |
| Child(String), |
| } |
| |
| impl FidlIntoNative<OfferRunnerSource> for Option<fsys::Ref> { |
| fn fidl_into_native(self) -> OfferRunnerSource { |
| match self.unwrap() { |
| fsys::Ref::Realm(_) => OfferRunnerSource::Realm, |
| fsys::Ref::Self_(_) => OfferRunnerSource::Self_, |
| fsys::Ref::Child(c) => OfferRunnerSource::Child(c.name), |
| _ => panic!("invalid OfferRunnerSource variant"), |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<Option<fsys::Ref>> for OfferRunnerSource { |
| fn native_into_fidl(self) -> Option<fsys::Ref> { |
| Some(match self { |
| OfferRunnerSource::Realm => fsys::Ref::Realm(fsys::RealmRef {}), |
| OfferRunnerSource::Self_ => fsys::Ref::Self_(fsys::SelfRef {}), |
| OfferRunnerSource::Child(child_name) => { |
| fsys::Ref::Child(fsys::ChildRef { name: child_name, collection: None }) |
| } |
| }) |
| } |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum OfferResolverSource { |
| Realm, |
| Self_, |
| Child(String), |
| } |
| |
| impl FidlIntoNative<OfferResolverSource> for Option<fsys::Ref> { |
| fn fidl_into_native(self) -> OfferResolverSource { |
| match self.unwrap() { |
| fsys::Ref::Realm(_) => OfferResolverSource::Realm, |
| fsys::Ref::Self_(_) => OfferResolverSource::Self_, |
| fsys::Ref::Child(c) => OfferResolverSource::Child(c.name), |
| _ => panic!("invalid OfferResolverSource variant"), |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<Option<fsys::Ref>> for OfferResolverSource { |
| fn native_into_fidl(self) -> Option<fsys::Ref> { |
| Some(match self { |
| OfferResolverSource::Realm => fsys::Ref::Realm(fsys::RealmRef {}), |
| OfferResolverSource::Self_ => fsys::Ref::Self_(fsys::SelfRef {}), |
| OfferResolverSource::Child(child_name) => { |
| fsys::Ref::Child(fsys::ChildRef { name: child_name, collection: None }) |
| } |
| }) |
| } |
| } |
| |
| #[derive(Debug, Clone, PartialEq, Eq, Hash)] |
| pub enum OfferTarget { |
| Child(String), |
| Collection(String), |
| } |
| |
| impl FidlIntoNative<OfferTarget> for fsys::Ref { |
| fn fidl_into_native(self) -> OfferTarget { |
| match self { |
| fsys::Ref::Child(c) => OfferTarget::Child(c.name), |
| fsys::Ref::Collection(c) => OfferTarget::Collection(c.name), |
| _ => panic!("invalid OfferTarget variant"), |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<fsys::Ref> for OfferTarget { |
| fn native_into_fidl(self) -> fsys::Ref { |
| match self { |
| OfferTarget::Child(child_name) => { |
| fsys::Ref::Child(fsys::ChildRef { name: child_name, collection: None }) |
| } |
| OfferTarget::Collection(collection_name) => { |
| fsys::Ref::Collection(fsys::CollectionRef { name: collection_name }) |
| } |
| } |
| } |
| } |
| |
| impl FidlIntoNative<OfferTarget> for Option<fsys::Ref> { |
| fn fidl_into_native(self) -> OfferTarget { |
| self.unwrap().fidl_into_native() |
| } |
| } |
| |
| impl NativeIntoFidl<Option<fsys::Ref>> for OfferTarget { |
| fn native_into_fidl(self) -> Option<fsys::Ref> { |
| Some(self.native_into_fidl()) |
| } |
| } |
| |
| /// Converts the contents of a CM-FIDL declaration and produces the equivalent CM-Rust |
| /// struct. |
| /// This function applies cm_fidl_validator to check correctness. |
| impl TryFrom<fsys::ComponentDecl> for ComponentDecl { |
| type Error = Error; |
| |
| fn try_from(decl: fsys::ComponentDecl) -> Result<Self, Self::Error> { |
| cm_fidl_validator::validate(&decl).map_err(|err| Error::Validate { err })?; |
| Ok(decl.fidl_into_native()) |
| } |
| } |
| |
| // Converts the contents of a CM-Rust declaration into a CM_FIDL declaration |
| impl TryFrom<ComponentDecl> for fsys::ComponentDecl { |
| type Error = Error; |
| fn try_from(decl: ComponentDecl) -> Result<Self, Self::Error> { |
| Ok(decl.native_into_fidl()) |
| } |
| } |
| |
| /// Errors produced by cm_rust. |
| #[derive(Debug, Error)] |
| pub enum Error { |
| #[error("Fidl validation failed: {}", err)] |
| Validate { |
| #[source] |
| err: cm_fidl_validator::ErrorList, |
| }, |
| #[error("Invalid capability path: {}", raw)] |
| InvalidCapabilityPath { raw: String }, |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| |
| macro_rules! test_try_from_decl { |
| ( |
| $( |
| $test_name:ident => { |
| input = $input:expr, |
| result = $result:expr, |
| }, |
| )+ |
| ) => { |
| $( |
| #[test] |
| fn $test_name() { |
| { |
| let res = ComponentDecl::try_from($input).expect("try_from failed"); |
| assert_eq!(res, $result); |
| } |
| { |
| let res = fsys::ComponentDecl::try_from($result).expect("try_from failed"); |
| assert_eq!(res, $input); |
| } |
| } |
| )+ |
| } |
| } |
| |
| macro_rules! test_fidl_into_and_from { |
| ( |
| $( |
| $test_name:ident => { |
| input = $input:expr, |
| input_type = $input_type:ty, |
| result = $result:expr, |
| result_type = $result_type:ty, |
| }, |
| )+ |
| ) => { |
| $( |
| #[test] |
| fn $test_name() { |
| { |
| let res: Vec<$result_type> = |
| $input.into_iter().map(|e| e.fidl_into_native()).collect(); |
| assert_eq!(res, $result); |
| } |
| { |
| let res: Vec<$input_type> = |
| $result.into_iter().map(|e| e.native_into_fidl()).collect(); |
| assert_eq!(res, $input); |
| } |
| } |
| )+ |
| } |
| } |
| |
| macro_rules! test_fidl_into { |
| ( |
| $( |
| $test_name:ident => { |
| input = $input:expr, |
| result = $result:expr, |
| }, |
| )+ |
| ) => { |
| $( |
| #[test] |
| fn $test_name() { |
| test_fidl_into_helper($input, $result); |
| } |
| )+ |
| } |
| } |
| |
| fn test_fidl_into_helper<T, U>(input: T, expected_res: U) |
| where |
| T: FidlIntoNative<U>, |
| U: std::cmp::PartialEq + std::fmt::Debug, |
| { |
| let res: U = input.fidl_into_native(); |
| assert_eq!(res, expected_res); |
| } |
| |
| macro_rules! test_capability_path { |
| ( |
| $( |
| $test_name:ident => { |
| input = $input:expr, |
| result = $result:expr, |
| }, |
| )+ |
| ) => { |
| $( |
| #[test] |
| fn $test_name() { |
| test_capability_path_helper($input, $result); |
| } |
| )+ |
| } |
| } |
| |
| fn test_capability_path_helper(input: &str, result: Result<CapabilityPath, Error>) { |
| let res = CapabilityPath::try_from(input); |
| assert_eq!(format!("{:?}", res), format!("{:?}", result)); |
| if let Ok(p) = res { |
| assert_eq!(&p.to_string(), input); |
| } |
| } |
| |
| test_try_from_decl! { |
| try_from_empty => { |
| input = fsys::ComponentDecl { |
| program: None, |
| uses: None, |
| exposes: None, |
| offers: None, |
| children: None, |
| collections: None, |
| facets: None, |
| storage: None, |
| runners: None, |
| environments: None, |
| resolvers: None, |
| }, |
| result = ComponentDecl { |
| program: None, |
| uses: vec![], |
| exposes: vec![], |
| offers: vec![], |
| children: vec![], |
| collections: vec![], |
| storage: vec![], |
| facets: None, |
| runners: vec![], |
| environments: vec![], |
| resolvers: vec![], |
| }, |
| }, |
| try_from_all => { |
| input = fsys::ComponentDecl { |
| program: Some(fdata::Dictionary{entries: Some(vec![ |
| fdata::DictionaryEntry { |
| key: "args".to_string(), |
| value: Some(Box::new(fdata::DictionaryValue::StrVec(vec!["foo".to_string(), "bar".to_string()]))), |
| }, |
| fdata::DictionaryEntry { |
| key: "binary".to_string(), |
| value: Some(Box::new(fdata::DictionaryValue::Str("bin/app".to_string()))), |
| }, |
| ])}), |
| uses: Some(vec![ |
| fsys::UseDecl::Service(fsys::UseServiceDecl { |
| source: Some(fsys::Ref::Realm(fsys::RealmRef {})), |
| source_path: Some("/svc/netstack".to_string()), |
| target_path: Some("/svc/mynetstack".to_string()), |
| }), |
| fsys::UseDecl::Protocol(fsys::UseProtocolDecl { |
| source: Some(fsys::Ref::Realm(fsys::RealmRef {})), |
| source_path: Some("/svc/legacy_netstack".to_string()), |
| target_path: Some("/svc/legacy_mynetstack".to_string()), |
| }), |
| fsys::UseDecl::Directory(fsys::UseDirectoryDecl { |
| source: Some(fsys::Ref::Framework(fsys::FrameworkRef {})), |
| source_path: Some("/data/dir".to_string()), |
| target_path: Some("/data".to_string()), |
| rights: Some(fio2::Operations::Connect), |
| subdir: Some("foo/bar".to_string()), |
| }), |
| fsys::UseDecl::Storage(fsys::UseStorageDecl { |
| type_: Some(fsys::StorageType::Cache), |
| target_path: Some("/cache".to_string()), |
| }), |
| fsys::UseDecl::Storage(fsys::UseStorageDecl { |
| type_: Some(fsys::StorageType::Meta), |
| target_path: None, |
| }), |
| fsys::UseDecl::Runner(fsys::UseRunnerDecl { |
| source_name: Some("myrunner".to_string()), |
| }), |
| ]), |
| exposes: Some(vec![ |
| fsys::ExposeDecl::Protocol(fsys::ExposeProtocolDecl { |
| source: Some(fsys::Ref::Child(fsys::ChildRef { |
| name: "netstack".to_string(), |
| collection: None, |
| })), |
| source_path: Some("/svc/legacy_netstack".to_string()), |
| target_path: Some("/svc/legacy_mynetstack".to_string()), |
| target: Some(fsys::Ref::Realm(fsys::RealmRef {})), |
| }), |
| fsys::ExposeDecl::Directory(fsys::ExposeDirectoryDecl { |
| source: Some(fsys::Ref::Child(fsys::ChildRef { |
| name: "netstack".to_string(), |
| collection: None, |
| })), |
| source_path: Some("/data/dir".to_string()), |
| target_path: Some("/data".to_string()), |
| target: Some(fsys::Ref::Framework(fsys::FrameworkRef {})), |
| rights: Some(fio2::Operations::Connect), |
| subdir: Some("foo/bar".to_string()), |
| }), |
| fsys::ExposeDecl::Runner(fsys::ExposeRunnerDecl { |
| source: Some(fsys::Ref::Child(fsys::ChildRef { |
| name: "netstack".to_string(), |
| collection: None, |
| })), |
| source_name: Some("elf".to_string()), |
| target: Some(fsys::Ref::Realm(fsys::RealmRef {})), |
| target_name: Some("elf".to_string()), |
| }), |
| fsys::ExposeDecl::Resolver(fsys::ExposeResolverDecl{ |
| source: Some(fsys::Ref::Child(fsys::ChildRef { |
| name: "netstack".to_string(), |
| collection: None, |
| })), |
| source_name: Some("pkg".to_string()), |
| target: Some(fsys::Ref::Realm(fsys::RealmRef{})), |
| target_name: Some("pkg".to_string()), |
| }), |
| fsys::ExposeDecl::Service(fsys::ExposeServiceDecl { |
| source: Some(fsys::Ref::Child(fsys::ChildRef { |
| name: "netstack".to_string(), |
| collection: None, |
| })), |
| source_path: Some("/svc/netstack1".to_string()), |
| target_path: Some("/svc/mynetstack".to_string()), |
| target: Some(fsys::Ref::Realm(fsys::RealmRef {})), |
| }), |
| fsys::ExposeDecl::Service(fsys::ExposeServiceDecl { |
| source: Some(fsys::Ref::Child(fsys::ChildRef { |
| name: "netstack".to_string(), |
| collection: None, |
| })), |
| source_path: Some("/svc/netstack2".to_string()), |
| target_path: Some("/svc/mynetstack".to_string()), |
| target: Some(fsys::Ref::Realm(fsys::RealmRef {})), |
| }), |
| ]), |
| offers: Some(vec![ |
| fsys::OfferDecl::Protocol(fsys::OfferProtocolDecl { |
| source: Some(fsys::Ref::Realm(fsys::RealmRef {})), |
| source_path: Some("/svc/legacy_netstack".to_string()), |
| target: Some(fsys::Ref::Child( |
| fsys::ChildRef { |
| name: "echo".to_string(), |
| collection: None, |
| } |
| )), |
| target_path: Some("/svc/legacy_mynetstack".to_string()), |
| dependency_type: Some(fsys::DependencyType::WeakForMigration), |
| }), |
| fsys::OfferDecl::Directory(fsys::OfferDirectoryDecl { |
| source: Some(fsys::Ref::Realm(fsys::RealmRef {})), |
| source_path: Some("/data/dir".to_string()), |
| target: Some(fsys::Ref::Collection( |
| fsys::CollectionRef { name: "modular".to_string() } |
| )), |
| target_path: Some("/data".to_string()), |
| rights: Some(fio2::Operations::Connect), |
| subdir: None, |
| dependency_type: Some(fsys::DependencyType::Strong), |
| }), |
| fsys::OfferDecl::Storage(fsys::OfferStorageDecl { |
| type_: Some(fsys::StorageType::Cache), |
| source: Some(fsys::Ref::Storage(fsys::StorageRef { |
| name: "memfs".to_string(), |
| })), |
| target: Some(fsys::Ref::Collection( |
| fsys::CollectionRef { name: "modular".to_string() } |
| )), |
| }), |
| fsys::OfferDecl::Runner(fsys::OfferRunnerDecl { |
| source: Some(fsys::Ref::Realm(fsys::RealmRef {})), |
| source_name: Some("elf".to_string()), |
| target: Some(fsys::Ref::Child( |
| fsys::ChildRef { |
| name: "echo".to_string(), |
| collection: None, |
| } |
| )), |
| target_name: Some("elf2".to_string()), |
| }), |
| fsys::OfferDecl::Resolver(fsys::OfferResolverDecl{ |
| source: Some(fsys::Ref::Realm(fsys::RealmRef{})), |
| source_name: Some("pkg".to_string()), |
| target: Some(fsys::Ref::Child( |
| fsys::ChildRef { |
| name: "echo".to_string(), |
| collection: None, |
| } |
| )), |
| target_name: Some("pkg".to_string()), |
| }), |
| fsys::OfferDecl::Service(fsys::OfferServiceDecl { |
| source: Some(fsys::Ref::Realm(fsys::RealmRef {})), |
| source_path: Some("/svc/netstack1".to_string()), |
| target: Some(fsys::Ref::Child( |
| fsys::ChildRef { |
| name: "echo".to_string(), |
| collection: None, |
| } |
| )), |
| target_path: Some("/svc/mynetstack".to_string()), |
| }), |
| fsys::OfferDecl::Service(fsys::OfferServiceDecl { |
| source: Some(fsys::Ref::Realm(fsys::RealmRef {})), |
| source_path: Some("/svc/netstack2".to_string()), |
| target: Some(fsys::Ref::Child( |
| fsys::ChildRef { |
| name: "echo".to_string(), |
| collection: None, |
| } |
| )), |
| target_path: Some("/svc/mynetstack".to_string()), |
| }), |
| ]), |
| children: Some(vec![ |
| fsys::ChildDecl { |
| name: Some("netstack".to_string()), |
| url: Some("fuchsia-pkg://fuchsia.com/netstack#meta/netstack.cm" |
| .to_string()), |
| startup: Some(fsys::StartupMode::Lazy), |
| environment: None, |
| }, |
| fsys::ChildDecl { |
| name: Some("echo".to_string()), |
| url: Some("fuchsia-pkg://fuchsia.com/echo#meta/echo.cm" |
| .to_string()), |
| startup: Some(fsys::StartupMode::Eager), |
| environment: Some("test_env".to_string()), |
| }, |
| ]), |
| collections: Some(vec![ |
| fsys::CollectionDecl { |
| name: Some("modular".to_string()), |
| durability: Some(fsys::Durability::Persistent), |
| }, |
| fsys::CollectionDecl { |
| name: Some("tests".to_string()), |
| durability: Some(fsys::Durability::Transient), |
| }, |
| ]), |
| facets: Some(fsys::Object{entries: vec![ |
| fsys::Entry{ |
| key: "author".to_string(), |
| value: Some(Box::new(fsys::Value::Str("Fuchsia".to_string()))), |
| }, |
| ]}), |
| storage: Some(vec![ |
| fsys::StorageDecl { |
| name: Some("memfs".to_string()), |
| source_path: Some("/memfs".to_string()), |
| source: Some(fsys::Ref::Realm(fsys::RealmRef {})), |
| } |
| ]), |
| runners: Some(vec![ |
| fsys::RunnerDecl { |
| name: Some("elf".to_string()), |
| source_path: Some("/elf".to_string()), |
| source: Some(fsys::Ref::Self_(fsys::SelfRef {})), |
| } |
| ]), |
| resolvers: Some(vec![ |
| fsys::ResolverDecl { |
| name: Some("pkg".to_string()), |
| source_path: Some("/pkg_resolver".to_string()), |
| } |
| ]), |
| environments: Some(vec![ |
| fsys::EnvironmentDecl { |
| name: Some("test_env".to_string()), |
| extends: Some(fsys::EnvironmentExtends::Realm), |
| } |
| ]), |
| }, |
| result = { |
| ComponentDecl { |
| program: Some(fdata::Dictionary{entries: Some(vec![ |
| fdata::DictionaryEntry { |
| key: "args".to_string(), |
| value: Some(Box::new(fdata::DictionaryValue::StrVec(vec!["foo".to_string(), "bar".to_string()]))), |
| }, |
| fdata::DictionaryEntry{ |
| key: "binary".to_string(), |
| value: Some(Box::new(fdata::DictionaryValue::Str("bin/app".to_string()))), |
| }, |
| ])}), |
| uses: vec![ |
| UseDecl::Service(UseServiceDecl { |
| source: UseSource::Realm, |
| source_path: "/svc/netstack".try_into().unwrap(), |
| target_path: "/svc/mynetstack".try_into().unwrap(), |
| }), |
| UseDecl::Protocol(UseProtocolDecl { |
| source: UseSource::Realm, |
| source_path: "/svc/legacy_netstack".try_into().unwrap(), |
| target_path: "/svc/legacy_mynetstack".try_into().unwrap(), |
| }), |
| UseDecl::Directory(UseDirectoryDecl { |
| source: UseSource::Framework, |
| source_path: "/data/dir".try_into().unwrap(), |
| target_path: "/data".try_into().unwrap(), |
| rights: fio2::Operations::Connect, |
| subdir: Some("foo/bar".into()), |
| }), |
| UseDecl::Storage(UseStorageDecl::Cache("/cache".try_into().unwrap())), |
| UseDecl::Storage(UseStorageDecl::Meta), |
| UseDecl::Runner(UseRunnerDecl { |
| source_name: "myrunner".into(), |
| }), |
| ], |
| exposes: vec![ |
| ExposeDecl::Protocol(ExposeProtocolDecl { |
| source: ExposeSource::Child("netstack".to_string()), |
| source_path: "/svc/legacy_netstack".try_into().unwrap(), |
| target_path: "/svc/legacy_mynetstack".try_into().unwrap(), |
| target: ExposeTarget::Realm, |
| }), |
| ExposeDecl::Directory(ExposeDirectoryDecl { |
| source: ExposeSource::Child("netstack".to_string()), |
| source_path: "/data/dir".try_into().unwrap(), |
| target_path: "/data".try_into().unwrap(), |
| target: ExposeTarget::Framework, |
| rights: Some(fio2::Operations::Connect), |
| subdir: Some("foo/bar".into()), |
| }), |
| ExposeDecl::Runner(ExposeRunnerDecl { |
| source: ExposeSource::Child("netstack".to_string()), |
| source_name: "elf".try_into().unwrap(), |
| target: ExposeTarget::Realm, |
| target_name: "elf".try_into().unwrap(), |
| }), |
| ExposeDecl::Resolver(ExposeResolverDecl { |
| source: ExposeSource::Child("netstack".to_string()), |
| source_name: "pkg".try_into().unwrap(), |
| target: ExposeTarget::Realm, |
| target_name: "pkg".try_into().unwrap(), |
| }), |
| ExposeDecl::Service(ExposeServiceDecl { |
| sources: vec![ |
| ServiceSource::<ExposeServiceSource> { |
| source: ExposeServiceSource::Child("netstack".to_string()), |
| source_path: "/svc/netstack1".try_into().unwrap(), |
| }, |
| ServiceSource::<ExposeServiceSource> { |
| source: ExposeServiceSource::Child("netstack".to_string()), |
| source_path: "/svc/netstack2".try_into().unwrap(), |
| }, |
| ], |
| target_path: "/svc/mynetstack".try_into().unwrap(), |
| target: ExposeTarget::Realm, |
| }), |
| ], |
| offers: vec![ |
| OfferDecl::Protocol(OfferProtocolDecl { |
| source: OfferServiceSource::Realm, |
| source_path: "/svc/legacy_netstack".try_into().unwrap(), |
| target: OfferTarget::Child("echo".to_string()), |
| target_path: "/svc/legacy_mynetstack".try_into().unwrap(), |
| dependency_type: DependencyType::WeakForMigration, |
| }), |
| OfferDecl::Directory(OfferDirectoryDecl { |
| source: OfferDirectorySource::Realm, |
| source_path: "/data/dir".try_into().unwrap(), |
| target: OfferTarget::Collection("modular".to_string()), |
| target_path: "/data".try_into().unwrap(), |
| rights: Some(fio2::Operations::Connect), |
| subdir: None, |
| dependency_type: DependencyType::Strong, |
| }), |
| OfferDecl::Storage(OfferStorageDecl::Cache( |
| OfferStorage { |
| source: OfferStorageSource::Storage("memfs".to_string()), |
| target: OfferTarget::Collection("modular".to_string()), |
| } |
| )), |
| OfferDecl::Runner(OfferRunnerDecl { |
| source: OfferRunnerSource::Realm, |
| source_name: "elf".try_into().unwrap(), |
| target: OfferTarget::Child("echo".to_string()), |
| target_name: "elf2".try_into().unwrap(), |
| }), |
| OfferDecl::Resolver(OfferResolverDecl { |
| source: OfferResolverSource::Realm, |
| source_name: "pkg".try_into().unwrap(), |
| target: OfferTarget::Child("echo".to_string()), |
| target_name: "pkg".try_into().unwrap(), |
| }), |
| OfferDecl::Service(OfferServiceDecl { |
| sources: vec![ |
| ServiceSource::<OfferServiceSource> { |
| source: OfferServiceSource::Realm, |
| source_path: "/svc/netstack1".try_into().unwrap(), |
| }, |
| ServiceSource::<OfferServiceSource> { |
| source: OfferServiceSource::Realm, |
| source_path: "/svc/netstack2".try_into().unwrap(), |
| }, |
| ], |
| target: OfferTarget::Child("echo".to_string()), |
| target_path: "/svc/mynetstack".try_into().unwrap(), |
| }), |
| ], |
| children: vec![ |
| ChildDecl { |
| name: "netstack".to_string(), |
| url: "fuchsia-pkg://fuchsia.com/netstack#meta/netstack.cm".to_string(), |
| startup: fsys::StartupMode::Lazy, |
| environment: None, |
| }, |
| ChildDecl { |
| name: "echo".to_string(), |
| url: "fuchsia-pkg://fuchsia.com/echo#meta/echo.cm".to_string(), |
| startup: fsys::StartupMode::Eager, |
| environment: Some("test_env".to_string()), |
| }, |
| ], |
| collections: vec![ |
| CollectionDecl { |
| name: "modular".to_string(), |
| durability: fsys::Durability::Persistent, |
| }, |
| CollectionDecl { |
| name: "tests".to_string(), |
| durability: fsys::Durability::Transient, |
| }, |
| ], |
| facets: Some(fsys::Object{entries: vec![ |
| fsys::Entry{ |
| key: "author".to_string(), |
| value: Some(Box::new(fsys::Value::Str("Fuchsia".to_string()))), |
| }, |
| ]}), |
| storage: vec![ |
| StorageDecl { |
| name: "memfs".to_string(), |
| source_path: "/memfs".try_into().unwrap(), |
| source: StorageDirectorySource::Realm, |
| }, |
| ], |
| runners: vec![ |
| RunnerDecl { |
| name: "elf".to_string(), |
| source: RunnerSource::Self_, |
| source_path: "/elf".try_into().unwrap(), |
| } |
| ], |
| resolvers: vec![ |
| ResolverDecl { |
| name: "pkg".to_string(), |
| source_path: "/pkg_resolver".try_into().unwrap(), |
| } |
| ], |
| environments: vec![ |
| EnvironmentDecl { |
| name: "test_env".to_string(), |
| extends: fsys::EnvironmentExtends::Realm, |
| } |
| ] |
| } |
| }, |
| }, |
| } |
| |
| test_capability_path! { |
| capability_path_one_part => { |
| input = "/foo", |
| result = Ok(CapabilityPath{dirname: "/".to_string(), basename: "foo".to_string()}), |
| }, |
| capability_path_two_parts => { |
| input = "/foo/bar", |
| result = Ok(CapabilityPath{dirname: "/foo".to_string(), basename: "bar".to_string()}), |
| }, |
| capability_path_many_parts => { |
| input = "/foo/bar/long/path", |
| result = Ok(CapabilityPath{ |
| dirname: "/foo/bar/long".to_string(), |
| basename: "path".to_string() |
| }), |
| }, |
| capability_path_invalid_empty_part => { |
| input = "/foo/bar//long/path", |
| result = Err(Error::InvalidCapabilityPath{raw: "/foo/bar//long/path".to_string()}), |
| }, |
| capability_path_invalid_empty => { |
| input = "", |
| result = Err(Error::InvalidCapabilityPath{raw: "".to_string()}), |
| }, |
| capability_path_invalid_root => { |
| input = "/", |
| result = Err(Error::InvalidCapabilityPath{raw: "/".to_string()}), |
| }, |
| capability_path_invalid_relative => { |
| input = "foo/bar", |
| result = Err(Error::InvalidCapabilityPath{raw: "foo/bar".to_string()}), |
| }, |
| capability_path_invalid_trailing => { |
| input = "/foo/bar/", |
| result = Err(Error::InvalidCapabilityPath{raw: "/foo/bar/".to_string()}), |
| }, |
| } |
| |
| test_fidl_into_and_from! { |
| fidl_into_and_from_expose_source => { |
| input = vec![ |
| Some(fsys::Ref::Self_(fsys::SelfRef {})), |
| Some(fsys::Ref::Child(fsys::ChildRef { |
| name: "foo".to_string(), |
| collection: None, |
| })), |
| Some(fsys::Ref::Framework(fsys::FrameworkRef {})), |
| ], |
| input_type = Option<fsys::Ref>, |
| result = vec![ |
| ExposeSource::Self_, |
| ExposeSource::Child("foo".to_string()), |
| ExposeSource::Framework, |
| ], |
| result_type = ExposeSource, |
| }, |
| fidl_into_and_from_offer_service_source => { |
| input = vec![ |
| Some(fsys::Ref::Realm(fsys::RealmRef {})), |
| Some(fsys::Ref::Self_(fsys::SelfRef {})), |
| Some(fsys::Ref::Child(fsys::ChildRef { |
| name: "foo".to_string(), |
| collection: None, |
| })), |
| ], |
| input_type = Option<fsys::Ref>, |
| result = vec![ |
| OfferServiceSource::Realm, |
| OfferServiceSource::Self_, |
| OfferServiceSource::Child("foo".to_string()), |
| ], |
| result_type = OfferServiceSource, |
| }, |
| fidl_into_and_from_offer_directory_source => { |
| input = vec![ |
| Some(fsys::Ref::Realm(fsys::RealmRef {})), |
| Some(fsys::Ref::Self_(fsys::SelfRef {})), |
| Some(fsys::Ref::Framework(fsys::FrameworkRef {})), |
| Some(fsys::Ref::Child(fsys::ChildRef { |
| name: "foo".to_string(), |
| collection: None, |
| })), |
| ], |
| input_type = Option<fsys::Ref>, |
| result = vec![ |
| OfferDirectorySource::Realm, |
| OfferDirectorySource::Self_, |
| OfferDirectorySource::Framework, |
| OfferDirectorySource::Child("foo".to_string()), |
| ], |
| result_type = OfferDirectorySource, |
| }, |
| fidl_into_and_from_offer_storage_source => { |
| input = vec![ |
| Some(fsys::Ref::Realm(fsys::RealmRef {})), |
| Some(fsys::Ref::Storage(fsys::StorageRef { |
| name: "foo".to_string(), |
| })), |
| ], |
| input_type = Option<fsys::Ref>, |
| result = vec![ |
| OfferStorageSource::Realm, |
| OfferStorageSource::Storage("foo".to_string()), |
| ], |
| result_type = OfferStorageSource, |
| }, |
| fidl_into_and_from_storage_capability => { |
| input = vec![ |
| fsys::StorageDecl { |
| name: Some("minfs".to_string()), |
| source_path: Some("/minfs".to_string()), |
| source: Some(fsys::Ref::Realm(fsys::RealmRef {})), |
| }, |
| fsys::StorageDecl { |
| name: Some("minfs".to_string()), |
| source_path: Some("/minfs".to_string()), |
| source: Some(fsys::Ref::Child(fsys::ChildRef { |
| name: "foo".to_string(), |
| collection: None, |
| })), |
| }, |
| ], |
| input_type = fsys::StorageDecl, |
| result = vec![ |
| StorageDecl { |
| name: "minfs".to_string(), |
| source_path: CapabilityPath::try_from("/minfs").unwrap(), |
| source: StorageDirectorySource::Realm, |
| }, |
| StorageDecl { |
| name: "minfs".to_string(), |
| source_path: CapabilityPath::try_from("/minfs").unwrap(), |
| source: StorageDirectorySource::Child("foo".to_string()), |
| }, |
| ], |
| result_type = StorageDecl, |
| }, |
| } |
| |
| test_fidl_into! { |
| fidl_into_object => { |
| input = { |
| let obj_inner = fsys::Object{entries: vec![ |
| fsys::Entry{ |
| key: "string".to_string(), |
| value: Some(Box::new(fsys::Value::Str("bar".to_string()))), |
| }, |
| ]}; |
| let vector = fsys::Vector{values: vec![ |
| Some(Box::new(fsys::Value::Obj(obj_inner))), |
| Some(Box::new(fsys::Value::Inum(-42))) |
| ]}; |
| let obj_outer = fsys::Object{entries: vec![ |
| fsys::Entry{ |
| key: "array".to_string(), |
| value: Some(Box::new(fsys::Value::Vec(vector))), |
| }, |
| ]}; |
| let obj = fsys::Object {entries: vec![ |
| fsys::Entry { |
| key: "bool".to_string(), |
| value: Some(Box::new(fsys::Value::Bit(true))), |
| }, |
| fsys::Entry { |
| key: "obj".to_string(), |
| value: Some(Box::new(fsys::Value::Obj(obj_outer))), |
| }, |
| fsys::Entry { |
| key: "float".to_string(), |
| value: Some(Box::new(fsys::Value::Fnum(3.14))), |
| }, |
| fsys::Entry { |
| key: "int".to_string(), |
| value: Some(Box::new(fsys::Value::Inum(-42))), |
| }, |
| fsys::Entry { |
| key: "null".to_string(), |
| value: None, |
| }, |
| fsys::Entry { |
| key: "string".to_string(), |
| value: Some(Box::new(fsys::Value::Str("bar".to_string()))), |
| }, |
| ]}; |
| Some(obj) |
| }, |
| result = { |
| let mut obj_inner = HashMap::new(); |
| obj_inner.insert("string".to_string(), Value::Str("bar".to_string())); |
| let mut obj_outer = HashMap::new(); |
| let vector = vec![Value::Obj(obj_inner), Value::Inum(-42)]; |
| obj_outer.insert("array".to_string(), Value::Vec(vector)); |
| |
| let mut obj: HashMap<String, Value> = HashMap::new(); |
| obj.insert("bool".to_string(), Value::Bit(true)); |
| obj.insert("float".to_string(), Value::Fnum(3.14)); |
| obj.insert("int".to_string(), Value::Inum(-42)); |
| obj.insert("string".to_string(), Value::Str("bar".to_string())); |
| obj.insert("obj".to_string(), Value::Obj(obj_outer)); |
| obj.insert("null".to_string(), Value::Null); |
| Some(obj) |
| }, |
| }, |
| } |
| } |
