| // 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::Error; |
| use fdata::{Dictionary, DictionaryEntry, DictionaryValue}; |
| use fidl::encoding::decode_persistent; |
| use fidl_fuchsia_component_decl::*; |
| use fidl_fuchsia_data as fdata; |
| use fidl_fuchsia_io as fio; |
| use std::fs::File; |
| use std::io::Read; |
| use std::path::PathBuf; |
| |
| fn main() { |
| // example.cm has already been compiled by cmc as part of the build process |
| // See: https://fuchsia.googlesource.com/fuchsia/+/c4b7ddf8128e782f957374c64f57aa2508ac3fe2/build/package.gni#304 |
| let mut cm_decl = read_cm("/pkg/meta/example.cm").expect("could not read cm file"); |
| |
| // profile variant injects this protocol. |
| if let Some(uses) = &mut cm_decl.uses { |
| uses.retain(|u| match u { |
| Use::Protocol(decl) => { |
| if decl.source_name == Some("fuchsia.debugdata.Publisher".to_owned()) { |
| let protocol = decl.source_name.clone().unwrap(); |
| let target_path = format!("/svc/{}", protocol); |
| assert_eq!( |
| decl, |
| &UseProtocol { |
| dependency_type: Some(DependencyType::Strong), |
| source: Some(Ref::Debug(DebugRef {})), |
| source_name: Some(protocol), |
| target_path: Some(target_path), |
| availability: Some(Availability::Required), |
| ..UseProtocol::EMPTY |
| } |
| ); |
| return false; |
| } |
| return true; |
| } |
| _ => true, |
| }) |
| } |
| |
| let expected_decl = { |
| let program = Program { |
| runner: Some("elf".to_string()), |
| info: Some(fdata::Dictionary { |
| entries: Some(vec![ |
| fdata::DictionaryEntry { |
| key: "binary".to_string(), |
| value: Some(Box::new(fdata::DictionaryValue::Str( |
| "bin/example".to_string(), |
| ))), |
| }, |
| fdata::DictionaryEntry { |
| key: "lifecycle.stop_event".to_string(), |
| value: Some(Box::new(fdata::DictionaryValue::Str("notify".to_string()))), |
| }, |
| ]), |
| ..fdata::Dictionary::EMPTY |
| }), |
| ..Program::EMPTY |
| }; |
| let uses = vec![ |
| Use::Service(UseService { |
| dependency_type: Some(DependencyType::Strong), |
| source: Some(Ref::Parent(ParentRef {})), |
| source_name: Some("fuchsia.fonts.Provider".to_string()), |
| target_path: Some("/svc/fuchsia.fonts.Provider".to_string()), |
| availability: Some(Availability::Required), |
| ..UseService::EMPTY |
| }), |
| Use::Protocol(UseProtocol { |
| dependency_type: Some(DependencyType::Strong), |
| source: Some(Ref::Parent(ParentRef {})), |
| source_name: Some("fuchsia.fonts.LegacyProvider".to_string()), |
| target_path: Some("/svc/fuchsia.fonts.OldProvider".to_string()), |
| availability: Some(Availability::Optional), |
| ..UseProtocol::EMPTY |
| }), |
| Use::Protocol(UseProtocol { |
| dependency_type: Some(DependencyType::Strong), |
| source: Some(Ref::Debug(DebugRef {})), |
| source_name: Some("fuchsia.log.LegacyLog".to_string()), |
| target_path: Some("/svc/fuchsia.log.LegacyLog".to_string()), |
| availability: Some(Availability::Required), |
| ..UseProtocol::EMPTY |
| }), |
| Use::Event(UseEvent { |
| dependency_type: Some(DependencyType::Strong), |
| source: Some(Ref::Framework(FrameworkRef {})), |
| source_name: Some("started".to_string()), |
| target_name: Some("began".to_string()), |
| filter: None, |
| availability: Some(Availability::Required), |
| ..UseEvent::EMPTY |
| }), |
| Use::Event(UseEvent { |
| dependency_type: Some(DependencyType::Strong), |
| source: Some(Ref::Parent(ParentRef {})), |
| source_name: Some("destroyed".to_string()), |
| target_name: Some("destroyed".to_string()), |
| filter: None, |
| availability: Some(Availability::Required), |
| ..UseEvent::EMPTY |
| }), |
| Use::Event(UseEvent { |
| dependency_type: Some(DependencyType::Strong), |
| source: Some(Ref::Parent(ParentRef {})), |
| source_name: Some("stopped".to_string()), |
| target_name: Some("stopped".to_string()), |
| filter: None, |
| availability: Some(Availability::Required), |
| ..UseEvent::EMPTY |
| }), |
| Use::Event(UseEvent { |
| dependency_type: Some(DependencyType::Strong), |
| source: Some(Ref::Parent(ParentRef {})), |
| source_name: Some("directory_ready".to_string()), |
| target_name: Some("diagnostics_ready".to_string()), |
| filter: Some(fdata::Dictionary { |
| entries: Some(vec![fdata::DictionaryEntry { |
| key: "path".to_string(), |
| value: Some(Box::new(fdata::DictionaryValue::Str( |
| "diagnostics".to_string(), |
| ))), |
| }]), |
| ..fdata::Dictionary::EMPTY |
| }), |
| availability: Some(Availability::Optional), |
| ..UseEvent::EMPTY |
| }), |
| Use::EventStreamDeprecated(UseEventStreamDeprecated { |
| name: Some("my_stream".to_string()), |
| subscriptions: Some(vec![ |
| EventSubscription { |
| event_name: Some("began".to_string()), |
| ..EventSubscription::EMPTY |
| }, |
| EventSubscription { |
| event_name: Some("destroyed".to_string()), |
| ..EventSubscription::EMPTY |
| }, |
| EventSubscription { |
| event_name: Some("diagnostics_ready".to_string()), |
| ..EventSubscription::EMPTY |
| }, |
| ]), |
| availability: Some(Availability::Required), |
| ..UseEventStreamDeprecated::EMPTY |
| }), |
| Use::EventStream(UseEventStream { |
| source_name: Some("events".to_string()), |
| source: Some(Ref::Parent(ParentRef {})), |
| target_path: Some("/testdir/my_stream".to_string()), |
| scope: Some(vec![Ref::Child(ChildRef { |
| collection: None, |
| name: "logger".to_string(), |
| })]), |
| availability: Some(Availability::Required), |
| ..UseEventStream::EMPTY |
| }), |
| Use::EventStream(UseEventStream { |
| source_name: Some("other".to_string()), |
| source: Some(Ref::Parent(ParentRef {})), |
| target_path: Some("/testdir/my_stream".to_string()), |
| scope: Some(vec![Ref::Child(ChildRef { |
| collection: None, |
| name: "logger".to_string(), |
| })]), |
| availability: Some(Availability::Required), |
| ..UseEventStream::EMPTY |
| }), |
| Use::EventStream(UseEventStream { |
| source_name: Some("some".to_string()), |
| source: Some(Ref::Parent(ParentRef {})), |
| target_path: Some("/testdir/my_stream".to_string()), |
| scope: Some(vec![Ref::Child(ChildRef { |
| collection: None, |
| name: "logger".to_string(), |
| })]), |
| availability: Some(Availability::Required), |
| ..UseEventStream::EMPTY |
| }), |
| Use::EventStream(UseEventStream { |
| source_name: Some("filtered".to_string()), |
| source: Some(Ref::Parent(ParentRef {})), |
| target_path: Some("/svc/fuchsia.component.EventStream".to_string()), |
| availability: Some(Availability::Required), |
| ..UseEventStream::EMPTY |
| }), |
| Use::Protocol(UseProtocol { |
| dependency_type: Some(DependencyType::Strong), |
| source: Some(Ref::Parent(ParentRef {})), |
| source_name: Some("fuchsia.logger.LogSink".to_string()), |
| target_path: Some("/svc/fuchsia.logger.LogSink".to_string()), |
| availability: Some(Availability::Required), |
| ..UseProtocol::EMPTY |
| }), |
| ]; |
| let exposes = vec![ |
| Expose::Service(ExposeService { |
| source: Some(Ref::Child(ChildRef { name: "logger".to_string(), collection: None })), |
| source_name: Some("fuchsia.logger.Log".to_string()), |
| target_name: Some("fuchsia.logger.Log".to_string()), |
| target: Some(Ref::Parent(ParentRef {})), |
| ..ExposeService::EMPTY |
| }), |
| Expose::Protocol(ExposeProtocol { |
| source: Some(Ref::Child(ChildRef { name: "logger".to_string(), collection: None })), |
| source_name: Some("fuchsia.logger.LegacyLog".to_string()), |
| target_name: Some("fuchsia.logger.OldLog".to_string()), |
| target: Some(Ref::Parent(ParentRef {})), |
| ..ExposeProtocol::EMPTY |
| }), |
| Expose::Directory(ExposeDirectory { |
| source: Some(Ref::Self_(SelfRef {})), |
| source_name: Some("blobfs".to_string()), |
| target_name: Some("blobfs".to_string()), |
| target: Some(Ref::Parent(ParentRef {})), |
| rights: None, |
| subdir: Some("blob".to_string()), |
| ..ExposeDirectory::EMPTY |
| }), |
| Expose::EventStream(ExposeEventStream { |
| source: Some(Ref::Framework(FrameworkRef {})), |
| source_name: Some("started".to_string()), |
| target: Some(Ref::Parent(ParentRef {})), |
| scope: Some(vec![Ref::Child(ChildRef { |
| name: "logger".to_string(), |
| collection: None, |
| })]), |
| target_name: Some("started".to_string()), |
| ..ExposeEventStream::EMPTY |
| }), |
| Expose::EventStream(ExposeEventStream { |
| source: Some(Ref::Framework(FrameworkRef {})), |
| source_name: Some("stopped".to_string()), |
| target: Some(Ref::Parent(ParentRef {})), |
| scope: Some(vec![Ref::Child(ChildRef { |
| name: "logger".to_string(), |
| collection: None, |
| })]), |
| target_name: Some("stopped".to_string()), |
| ..ExposeEventStream::EMPTY |
| }), |
| ]; |
| let offers = vec![ |
| Offer::Service(OfferService { |
| source: Some(Ref::Child(ChildRef { name: "logger".to_string(), collection: None })), |
| source_name: Some("fuchsia.logger.Log".to_string()), |
| target: Some(Ref::Collection(CollectionRef { name: "modular".to_string() })), |
| target_name: Some("fuchsia.logger.Log".to_string()), |
| availability: Some(Availability::Required), |
| ..OfferService::EMPTY |
| }), |
| Offer::Protocol(OfferProtocol { |
| source: Some(Ref::Child(ChildRef { name: "logger".to_string(), collection: None })), |
| source_name: Some("fuchsia.logger.LegacyLog".to_string()), |
| target: Some(Ref::Collection(CollectionRef { name: "modular".to_string() })), |
| target_name: Some("fuchsia.logger.OldLog".to_string()), |
| dependency_type: Some(DependencyType::Strong), |
| availability: Some(Availability::Required), |
| ..OfferProtocol::EMPTY |
| }), |
| Offer::Event(OfferEvent { |
| source: Some(Ref::Parent(ParentRef {})), |
| source_name: Some("stopped".to_string()), |
| target: Some(Ref::Child(ChildRef { name: "logger".to_string(), collection: None })), |
| target_name: Some("stopped-logger".to_string()), |
| filter: None, |
| availability: Some(Availability::Required), |
| ..OfferEvent::EMPTY |
| }), |
| Offer::EventStream(OfferEventStream { |
| source_name: Some("directory_ready".to_string()), |
| source: Some(Ref::Parent(ParentRef {})), |
| target: Some(Ref::Child(ChildRef { name: "logger".to_string(), collection: None })), |
| filter: Some(Dictionary { |
| entries: Some(vec![DictionaryEntry { |
| key: "name".to_string(), |
| value: Some(Box::new(DictionaryValue::Str("diagnostics".to_string()))), |
| }]), |
| ..Dictionary::EMPTY |
| }), |
| target_name: Some("directory_ready".to_string()), |
| availability: Some(Availability::SameAsTarget), |
| ..OfferEventStream::EMPTY |
| }), |
| Offer::EventStream(OfferEventStream { |
| source_name: Some("started".to_string()), |
| source: Some(Ref::Parent(ParentRef {})), |
| target: Some(Ref::Child(ChildRef { name: "logger".to_string(), collection: None })), |
| scope: Some(vec![Ref::Child(ChildRef { |
| name: "logger".to_string(), |
| collection: None, |
| })]), |
| target_name: Some("started".to_string()), |
| availability: Some(Availability::Required), |
| ..OfferEventStream::EMPTY |
| }), |
| Offer::EventStream(OfferEventStream { |
| source_name: Some("stopped".to_string()), |
| source: Some(Ref::Parent(ParentRef {})), |
| target: Some(Ref::Child(ChildRef { name: "logger".to_string(), collection: None })), |
| scope: Some(vec![Ref::Child(ChildRef { |
| name: "logger".to_string(), |
| collection: None, |
| })]), |
| target_name: Some("stopped".to_string()), |
| availability: Some(Availability::Required), |
| ..OfferEventStream::EMPTY |
| }), |
| Offer::Protocol(OfferProtocol { |
| source: Some(Ref::VoidType(VoidRef {})), |
| source_name: Some("fuchsia.logger.LegacyLog2".to_string()), |
| target: Some(Ref::Collection(CollectionRef { name: "modular".to_string() })), |
| target_name: Some("fuchsia.logger.OldLog2".to_string()), |
| dependency_type: Some(DependencyType::Strong), |
| availability: Some(Availability::Optional), |
| ..OfferProtocol::EMPTY |
| }), |
| Offer::Protocol(OfferProtocol { |
| source: Some(Ref::Child(ChildRef { name: "logger".to_string(), collection: None })), |
| source_name: Some("fuchsia.logger.LegacyLog3".to_string()), |
| target: Some(Ref::Collection(CollectionRef { name: "modular".to_string() })), |
| target_name: Some("fuchsia.logger.OldLog3".to_string()), |
| dependency_type: Some(DependencyType::Strong), |
| availability: Some(Availability::Required), |
| ..OfferProtocol::EMPTY |
| }), |
| Offer::Protocol(OfferProtocol { |
| source: Some(Ref::Parent(ParentRef {})), |
| source_name: Some("fuchsia.logger.LegacyLog4".to_string()), |
| target: Some(Ref::Collection(CollectionRef { name: "modular".to_string() })), |
| target_name: Some("fuchsia.logger.OldLog4".to_string()), |
| dependency_type: Some(DependencyType::Strong), |
| availability: Some(Availability::Optional), |
| ..OfferProtocol::EMPTY |
| }), |
| ]; |
| let capabilities = vec![ |
| Capability::Service(Service { |
| name: Some("fuchsia.logger.Log".to_string()), |
| source_path: Some("/svc/fuchsia.logger.Log".to_string()), |
| ..Service::EMPTY |
| }), |
| Capability::Protocol(Protocol { |
| name: Some("fuchsia.logger.Log2".to_string()), |
| source_path: Some("/svc/fuchsia.logger.Log2".to_string()), |
| ..Protocol::EMPTY |
| }), |
| Capability::Directory(Directory { |
| name: Some("blobfs".to_string()), |
| source_path: Some("/volumes/blobfs".to_string()), |
| rights: Some( |
| fio::Operations::CONNECT |
| | fio::Operations::READ_BYTES |
| | fio::Operations::WRITE_BYTES |
| | fio::Operations::GET_ATTRIBUTES |
| | fio::Operations::UPDATE_ATTRIBUTES |
| | fio::Operations::ENUMERATE |
| | fio::Operations::TRAVERSE |
| | fio::Operations::MODIFY_DIRECTORY, |
| ), |
| ..Directory::EMPTY |
| }), |
| Capability::Storage(Storage { |
| name: Some("minfs".to_string()), |
| source: Some(Ref::Parent(ParentRef {})), |
| backing_dir: Some("data".to_string()), |
| subdir: None, |
| storage_id: Some(StorageId::StaticInstanceIdOrMoniker), |
| ..Storage::EMPTY |
| }), |
| Capability::Runner(Runner { |
| name: Some("dart_runner".to_string()), |
| source_path: Some("/svc/fuchsia.sys2.Runner".to_string()), |
| ..Runner::EMPTY |
| }), |
| Capability::Resolver(Resolver { |
| name: Some("pkg_resolver".to_string()), |
| source_path: Some("/svc/fuchsia.pkg.Resolver".to_string()), |
| ..Resolver::EMPTY |
| }), |
| ]; |
| let children = vec![Child { |
| name: Some("logger".to_string()), |
| url: Some("fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm".to_string()), |
| startup: Some(StartupMode::Lazy), |
| environment: Some("env_one".to_string()), |
| ..Child::EMPTY |
| }]; |
| let collections = vec![ |
| Collection { |
| name: Some("modular".to_string()), |
| durability: Some(Durability::Persistent), |
| environment: None, |
| allowed_offers: None, |
| allow_long_names: None, |
| persistent_storage: None, |
| ..Collection::EMPTY |
| }, |
| Collection { |
| name: Some("explicit_static".to_string()), |
| durability: Some(Durability::Persistent), |
| environment: None, |
| allowed_offers: Some(AllowedOffers::StaticOnly), |
| allow_long_names: None, |
| persistent_storage: None, |
| ..Collection::EMPTY |
| }, |
| Collection { |
| name: Some("explicit_dynamic".to_string()), |
| durability: Some(Durability::Persistent), |
| environment: None, |
| allowed_offers: Some(AllowedOffers::StaticAndDynamic), |
| allow_long_names: None, |
| persistent_storage: None, |
| ..Collection::EMPTY |
| }, |
| Collection { |
| name: Some("long_child_names".to_string()), |
| durability: Some(Durability::Persistent), |
| environment: None, |
| allowed_offers: None, |
| allow_long_names: Some(true), |
| persistent_storage: None, |
| ..Collection::EMPTY |
| }, |
| Collection { |
| name: Some("persistent_storage".to_string()), |
| durability: Some(Durability::Persistent), |
| environment: None, |
| allowed_offers: None, |
| allow_long_names: None, |
| persistent_storage: Some(true), |
| ..Collection::EMPTY |
| }, |
| ]; |
| let facets = fdata::Dictionary { |
| entries: Some(vec![ |
| fdata::DictionaryEntry { |
| key: "author".to_string(), |
| value: Some(Box::new(fdata::DictionaryValue::Str("Fuchsia".to_string()))), |
| }, |
| fdata::DictionaryEntry { |
| key: "metadata.publisher".to_string(), |
| value: Some(Box::new(fdata::DictionaryValue::Str( |
| "The Books Publisher".to_string(), |
| ))), |
| }, |
| fdata::DictionaryEntry { |
| key: "year".to_string(), |
| value: Some(Box::new(fdata::DictionaryValue::Str("2018".to_string()))), |
| }, |
| ]), |
| ..fdata::Dictionary::EMPTY |
| }; |
| let envs = vec![ |
| Environment { |
| name: Some("env_one".to_string()), |
| extends: Some(EnvironmentExtends::None), |
| stop_timeout_ms: Some(1337), |
| runners: None, |
| resolvers: None, |
| debug_capabilities: None, |
| ..Environment::EMPTY |
| }, |
| Environment { |
| name: Some("env_two".to_string()), |
| extends: Some(EnvironmentExtends::Realm), |
| stop_timeout_ms: None, |
| runners: None, |
| resolvers: None, |
| debug_capabilities: Some(vec![ |
| DebugRegistration::Protocol(DebugProtocolRegistration { |
| source_name: Some("fuchsia.logger.LegacyLog".to_string()), |
| source: Some(Ref::Child(ChildRef { |
| name: "logger".to_string(), |
| collection: None, |
| })), |
| target_name: Some("fuchsia.logger.LegacyLog".to_string()), |
| ..DebugProtocolRegistration::EMPTY |
| }), |
| DebugRegistration::Protocol(DebugProtocolRegistration { |
| source_name: Some("fuchsia.logger.OtherLog".to_string()), |
| source: Some(Ref::Parent(ParentRef {})), |
| target_name: Some("fuchsia.logger.OtherLog".to_string()), |
| ..DebugProtocolRegistration::EMPTY |
| }), |
| DebugRegistration::Protocol(DebugProtocolRegistration { |
| source_name: Some("fuchsia.logger.Log2".to_string()), |
| source: Some(Ref::Self_(SelfRef {})), |
| target_name: Some("fuchsia.logger.Log2".to_string()), |
| ..DebugProtocolRegistration::EMPTY |
| }), |
| ]), |
| ..Environment::EMPTY |
| }, |
| ]; |
| |
| let config = ConfigSchema { |
| fields: Some(vec![ |
| ConfigField { |
| key: Some("my_flag".to_string()), |
| type_: Some(ConfigType { |
| layout: ConfigTypeLayout::Bool, |
| parameters: Some(vec![]), |
| constraints: vec![], |
| }), |
| ..ConfigField::EMPTY |
| }, |
| ConfigField { |
| key: Some("my_string".to_string()), |
| type_: Some(ConfigType { |
| layout: ConfigTypeLayout::String, |
| constraints: vec![LayoutConstraint::MaxSize(100)], |
| parameters: Some(vec![]), |
| }), |
| ..ConfigField::EMPTY |
| }, |
| ConfigField { |
| key: Some("my_uint8".to_string()), |
| type_: Some(ConfigType { |
| layout: ConfigTypeLayout::Uint8, |
| parameters: Some(vec![]), |
| constraints: vec![], |
| }), |
| ..ConfigField::EMPTY |
| }, |
| ConfigField { |
| key: Some("my_vector_of_string".to_string()), |
| type_: Some(ConfigType { |
| layout: ConfigTypeLayout::Vector, |
| constraints: vec![LayoutConstraint::MaxSize(100)], |
| parameters: Some(vec![LayoutParameter::NestedType(ConfigType { |
| layout: ConfigTypeLayout::String, |
| constraints: vec![LayoutConstraint::MaxSize(50)], |
| parameters: Some(vec![]), |
| })]), |
| }), |
| ..ConfigField::EMPTY |
| }, |
| ]), |
| checksum: Some(ConfigChecksum::Sha256([ |
| 227, 126, 183, 151, 1, 15, 67, 110, 144, 49, 222, 176, 221, 111, 19, 165, 34, 204, |
| 240, 41, 165, 95, 117, 57, 203, 42, 186, 167, 84, 26, 25, 231, |
| ])), |
| value_source: Some(ConfigValueSource::PackagePath("meta/example.cvf".to_string())), |
| ..ConfigSchema::EMPTY |
| }; |
| |
| Component { |
| program: Some(program), |
| uses: Some(uses), |
| exposes: Some(exposes), |
| offers: Some(offers), |
| capabilities: Some(capabilities), |
| children: Some(children), |
| collections: Some(collections), |
| facets: Some(facets), |
| environments: Some(envs), |
| config: Some(config), |
| ..Component::EMPTY |
| } |
| }; |
| assert_eq!(cm_decl, expected_decl); |
| } |
| |
| fn read_cm(file: &str) -> Result<Component, Error> { |
| let mut buffer = Vec::new(); |
| let path = PathBuf::from(file); |
| File::open(&path)?.read_to_end(&mut buffer)?; |
| Ok(decode_persistent(&buffer)?) |
| } |
