Google Git
Sign in
fuchsia / fuchsia / 57ef8eaaff96ca15cebfbd2e5605521ab24317e6 / . / tools / lib / cml / src / translate.rs
blob: 852f042487bb8e78a55cb1ac512e38d96ee974f5 [file] [log] [blame]
// 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 {
crate::{
error::Error, AnyRef, AsClause, Availability, Capability, CapabilityClause, Child,
Collection, ConfigKey, ConfigNestedValueType, ConfigValueType, DebugRegistration, Document,
Environment, EnvironmentExtends, EnvironmentRef, EventScope, EventSubscriptionsClause,
Expose, ExposeFromRef, ExposeToRef, FromClause, Offer, OneOrMany, Path, PathClause,
Program, ResolverRegistration, RightsClause, RunnerRegistration, SourceAvailability, Use,
UseFromRef,
},
cm_types::{self as cm, Name},
fidl_fuchsia_component_decl as fdecl, fidl_fuchsia_data as fdata, fidl_fuchsia_io as fio,
serde_json::{Map, Value},
sha2::{Digest, Sha256},
std::collections::{BTreeMap, HashSet},
std::convert::{Into, TryInto},
};
/// Compiles the Document into a FIDL `Component`.
/// Note: This function ignores the `include` section of the document. It is
/// assumed that those entries were already processed.
pub fn compile(
document: &Document,
config_package_path: Option<&str>,
) -> Result<fdecl::Component, Error> {
let all_capability_names = document.all_capability_names();
let all_children = document.all_children_names().into_iter().collect();
let all_collections = document.all_collection_names().into_iter().collect();
Ok(fdecl::Component {
program: document.program.as_ref().map(|p| translate_program(p)).transpose()?,
uses: document
.r#use
.as_ref()
.map(|u| translate_use(u, &all_capability_names, &all_children, &all_collections))
.transpose()?,
exposes: document
.expose
.as_ref()
.map(|e| translate_expose(e, &all_capability_names, &all_collections, &all_children))
.transpose()?,
offers: document
.offer
.as_ref()
.map(|offer| {
translate_offer(offer, &all_capability_names, &all_children, &all_collections)
})
.transpose()?,
capabilities: document
.capabilities
.as_ref()
.map(|c| translate_capabilities(c, false))
.transpose()?,
children: document.children.as_ref().map(translate_children).transpose()?,
collections: document.collections.as_ref().map(translate_collections).transpose()?,
environments: document
.environments
.as_ref()
.map(|env| translate_environments(env, &all_capability_names))
.transpose()?,
facets: document.facets.clone().map(dictionary_from_nested_map).transpose()?,
config: document
.config
.as_ref()
.map(|c| {
if let Some(p) = config_package_path {
Ok(translate_config(c, p))
} else {
Err(Error::invalid_args(
"can't translate config: no package path for value file",
))
}
})
.transpose()?,
..fdecl::Component::EMPTY
})
}
// Converts a Map<String, serde_json::Value> to a fuchsia Dictionary.
fn dictionary_from_map(in_obj: Map<String, Value>) -> Result<fdata::Dictionary, Error> {
let mut entries = vec![];
for (key, v) in in_obj {
let value = value_to_dictionary_value(v)?;
entries.push(fdata::DictionaryEntry { key, value });
}
Ok(fdata::Dictionary { entries: Some(entries), ..fdata::Dictionary::EMPTY })
}
// Converts a serde_json::Value into a fuchsia DictionaryValue.
fn value_to_dictionary_value(value: Value) -> Result<Option<Box<fdata::DictionaryValue>>, Error> {
match value {
Value::Null => Ok(None),
Value::String(s) => Ok(Some(Box::new(fdata::DictionaryValue::Str(s.clone())))),
Value::Array(arr) => {
if arr.iter().all(Value::is_string) {
let strs =
arr.into_iter().map(|v| v.as_str().unwrap().to_owned()).collect::<Vec<_>>();
Ok(Some(Box::new(fdata::DictionaryValue::StrVec(strs))))
} else if arr.iter().all(Value::is_object) {
let objs = arr
.into_iter()
.map(|v| v.as_object().unwrap().clone())
.map(|v| dictionary_from_nested_map(v))
.collect::<Result<Vec<_>, _>>()?;
Ok(Some(Box::new(fdata::DictionaryValue::ObjVec(objs))))
} else {
Err(Error::validate(
"Values of an array must either exclusively strings or exclusively objects",
))
}
}
other => Err(Error::validate(format!(
"Value must be string, list of strings, or list of objects: {:?}",
other
))),
}
}
/// Converts a [`serde_json::Map<String, serde_json::Value>`] to a [`fuchsia.data.Dictionary`].
///
/// The JSON object is converted as follows:
///
/// * Convert all non-string and string values into DictionaryValue::str.
/// * Flatten nested objects into top-level keys delimited by ".".
/// * Convert array of discrete values into array of DictionaryValue::str_vec.
/// * Convert array of objects into array of DictionaryValue::obj_vec.
///
/// Values may be null, strings, arrays of strings, arrays of objects, or objects.
///
/// # Example
///
/// ```json
/// {
/// "binary": "bin/app",
/// "lifecycle": {
/// "stop_event": "notify",
/// "nested": {
/// "foo": "bar"
/// }
/// }
/// }
/// ```
///
/// is flattened to:
///
/// ```json
/// {
/// "binary": "bin/app",
/// "lifecycle.stop_event": "notify",
/// "lifecycle.nested.foo": "bar"
/// }
/// ```
fn dictionary_from_nested_map(map: Map<String, Value>) -> Result<fdata::Dictionary, Error> {
fn key_value_to_entries(
key: String,
value: Value,
) -> Result<Vec<fdata::DictionaryEntry>, Error> {
if let Value::Object(map) = value {
let entries = map
.into_iter()
.map(|(k, v)| key_value_to_entries([key.clone(), ".".to_string(), k].concat(), v))
.collect::<Result<Vec<_>, _>>()?
.into_iter()
.flatten()
.collect();
return Ok(entries);
}
let entry_value = value_to_dictionary_value(value)?;
Ok(vec![fdata::DictionaryEntry { key, value: entry_value }])
}
let entries = map
.into_iter()
.map(|(k, v)| key_value_to_entries(k, v))
.collect::<Result<Vec<_>, _>>()?
.into_iter()
.flatten()
.collect();
Ok(fdata::Dictionary { entries: Some(entries), ..fdata::Dictionary::EMPTY })
}
/// Translates a [`Program`] to a [`fuchsa.sys2.Program`].
fn translate_program(program: &Program) -> Result<fdecl::Program, Error> {
Ok(fdecl::Program {
runner: program.runner.as_ref().map(|r| r.to_string()),
info: Some(dictionary_from_nested_map(program.info.clone())?),
..fdecl::Program::EMPTY
})
}
/// `use` rules consume a single capability from one source (parent|framework).
fn translate_use(
use_in: &Vec<Use>,
all_capability_names: &HashSet<Name>,
all_children: &HashSet<&Name>,
all_collections: &HashSet<&Name>,
) -> Result<Vec<fdecl::Use>, Error> {
let mut out_uses = vec![];
for use_ in use_in {
if let Some(n) = &use_.service {
let source = extract_use_source(use_, all_capability_names, all_children)?;
let target_paths =
all_target_use_paths(use_, use_).ok_or_else(|| Error::internal("no capability"))?;
let source_names = n.to_vec();
let availability = extract_use_availability(use_)?;
for (source_name, target_path) in source_names.into_iter().zip(target_paths.into_iter())
{
out_uses.push(fdecl::Use::Service(fdecl::UseService {
source: Some(clone_ref(&source)?),
source_name: Some(source_name.clone().into()),
target_path: Some(target_path.into()),
dependency_type: Some(
use_.dependency.clone().unwrap_or(cm::DependencyType::Strong).into(),
),
availability: Some(availability),
..fdecl::UseService::EMPTY
}));
}
} else if let Some(n) = &use_.protocol {
let source = extract_use_source(use_, all_capability_names, all_children)?;
let target_paths =
all_target_use_paths(use_, use_).ok_or_else(|| Error::internal("no capability"))?;
let source_names = n.to_vec();
let availability = extract_use_availability(use_)?;
for (source_name, target_path) in source_names.into_iter().zip(target_paths.into_iter())
{
out_uses.push(fdecl::Use::Protocol(fdecl::UseProtocol {
source: Some(clone_ref(&source)?),
source_name: Some(source_name.clone().into()),
target_path: Some(target_path.into()),
dependency_type: Some(
use_.dependency.clone().unwrap_or(cm::DependencyType::Strong).into(),
),
availability: Some(availability),
..fdecl::UseProtocol::EMPTY
}));
}
} else if let Some(n) = &use_.directory {
let source = extract_use_source(use_, all_capability_names, all_children)?;
let target_path = one_target_use_path(use_, use_)?;
let rights = extract_required_rights(use_, "use")?;
let subdir = extract_use_subdir(use_);
let availability = extract_use_availability(use_)?;
out_uses.push(fdecl::Use::Directory(fdecl::UseDirectory {
source: Some(source),
source_name: Some(n.clone().into()),
target_path: Some(target_path.into()),
rights: Some(rights),
subdir: subdir.map(|s| s.into()),
dependency_type: Some(
use_.dependency.clone().unwrap_or(cm::DependencyType::Strong).into(),
),
availability: Some(availability),
..fdecl::UseDirectory::EMPTY
}));
} else if let Some(n) = &use_.storage {
let target_path = one_target_use_path(use_, use_)?;
let availability = extract_use_availability(use_)?;
out_uses.push(fdecl::Use::Storage(fdecl::UseStorage {
source_name: Some(n.clone().into()),
target_path: Some(target_path.into()),
availability: Some(availability),
..fdecl::UseStorage::EMPTY
}));
} else if let Some(n) = &use_.event {
let source = extract_use_event_source(use_)?;
let target_names = all_target_capability_names(use_, use_)
.ok_or_else(|| Error::internal("no capability"))?;
let source_names = n.to_vec();
let availability = extract_use_availability(use_)?;
for target_name in target_names {
// When multiple source names are provided, there is no way to alias each one, so
// source_name == target_name,
// When one source name is provided, source_name may be aliased to a different
// target_name, so we use source_names[0] to derive the source_name.
let source_name = if source_names.len() == 1 {
source_names[0].clone()
} else {
target_name.clone()
};
out_uses.push(fdecl::Use::Event(fdecl::UseEvent {
source: Some(clone_ref(&source)?),
source_name: Some(source_name.into()),
target_name: Some(target_name.into()),
// We have already validated that none will be present if we were using many
// events.
filter: match use_.filter.clone() {
Some(dict) => Some(dictionary_from_map(dict)?),
None => None,
},
dependency_type: Some(
use_.dependency.clone().unwrap_or(cm::DependencyType::Strong).into(),
),
availability: Some(availability),
..fdecl::UseEvent::EMPTY
}));
}
} else if let Some(name) = &use_.event_stream_deprecated {
let opt_subscriptions = use_.event_subscriptions();
let availability = extract_use_availability(use_)?;
out_uses.push(fdecl::Use::EventStreamDeprecated(fdecl::UseEventStreamDeprecated {
name: Some(name.to_string()),
availability: Some(availability),
subscriptions: opt_subscriptions.map(|subscriptions| {
subscriptions
.iter()
.flat_map(|subscription| {
subscription.event.iter().map(move |event| fdecl::EventSubscription {
event_name: Some(event.to_string()),
..fdecl::EventSubscription::EMPTY
})
})
.collect()
}),
..fdecl::UseEventStreamDeprecated::EMPTY
}));
} else if let Some(names) = &use_.event_stream {
let source_names: Vec<String> =
annotate_type::<Vec<cm_types::Name>>(names.clone().into())
.iter()
.map(|name| name.to_string())
.collect();
let availability = extract_use_availability(use_)?;
for name in source_names {
let scopes = match use_.scope.clone() {
Some(value) => Some(annotate_type::<Vec<EventScope>>(value.into())),
None => None,
};
let internal_error = format!("Internal error in all_target_use_paths when translating an EventStream. Please file a bug.");
out_uses.push(fdecl::Use::EventStream(fdecl::UseEventStream {
source_name: Some(name),
scope: match scopes {
Some(values) => {
let mut output = vec![];
for value in &values {
output.push(translate_child_or_collection_ref(
value.into(),
&all_children,
&all_collections,
)?);
}
Some(output)
}
None => None,
},
source: Some(extract_use_source(use_, all_capability_names, all_children)?),
target_path: Some(
annotate_type::<Vec<cm_types::Path>>(
all_target_use_paths(use_, use_)
.ok_or_else(|| Error::internal(internal_error.clone()))?
.into(),
)
.iter()
.next()
.ok_or_else(|| Error::internal(internal_error.clone()))?
.as_str()
.to_string(),
),
availability: Some(availability),
..fdecl::UseEventStream::EMPTY
}));
}
} else {
return Err(Error::internal(format!("no capability in use declaration")));
};
}
Ok(out_uses)
}
/// `expose` rules route a single capability from one or more sources (self|framework|#<child>) to
/// one or more targets (parent|framework).
fn translate_expose(
expose_in: &Vec<Expose>,
all_capability_names: &HashSet<Name>,
all_collections: &HashSet<&Name>,
all_children: &HashSet<&Name>,
) -> Result<Vec<fdecl::Expose>, Error> {
let mut out_exposes = vec![];
for expose in expose_in.iter() {
let target = extract_expose_target(expose)?;
if let Some(source_names) = expose.service() {
let sources = extract_all_expose_sources(expose, Some(all_collections))?;
let target_names = all_target_capability_names(expose, expose)
.ok_or_else(|| Error::internal("no capability"))?;
for (source_name, target_name) in source_names.into_iter().zip(target_names.into_iter())
{
for source in &sources {
out_exposes.push(fdecl::Expose::Service(fdecl::ExposeService {
source: Some(clone_ref(source)?),
source_name: Some(source_name.clone().into()),
target_name: Some(target_name.clone().into()),
target: Some(clone_ref(&target)?),
..fdecl::ExposeService::EMPTY
}))
}
}
} else if let Some(n) = expose.protocol() {
let source = extract_single_expose_source(expose, Some(all_capability_names))?;
let source_names = n.to_vec();
let target_names = all_target_capability_names(expose, expose)
.ok_or_else(|| Error::internal("no capability"))?;
for (source_name, target_name) in source_names.into_iter().zip(target_names.into_iter())
{
out_exposes.push(fdecl::Expose::Protocol(fdecl::ExposeProtocol {
source: Some(clone_ref(&source)?),
source_name: Some(source_name.clone().into()),
target_name: Some(target_name.into()),
target: Some(clone_ref(&target)?),
..fdecl::ExposeProtocol::EMPTY
}))
}
} else if let Some(n) = expose.directory() {
let source = extract_single_expose_source(expose, None)?;
let source_names = n.to_vec();
let target_names = all_target_capability_names(expose, expose)
.ok_or_else(|| Error::internal("no capability"))?;
let rights = extract_expose_rights(expose)?;
let subdir = extract_expose_subdir(expose);
for (source_name, target_name) in source_names.into_iter().zip(target_names.into_iter())
{
out_exposes.push(fdecl::Expose::Directory(fdecl::ExposeDirectory {
source: Some(clone_ref(&source)?),
source_name: Some(source_name.clone().into()),
target_name: Some(target_name.into()),
target: Some(clone_ref(&target)?),
rights,
subdir: subdir.as_ref().map(|s| s.clone().into()),
..fdecl::ExposeDirectory::EMPTY
}))
}
} else if let Some(n) = expose.runner() {
let source = extract_single_expose_source(expose, None)?;
let source_names = n.to_vec();
let target_names = all_target_capability_names(expose, expose)
.ok_or_else(|| Error::internal("no capability"))?;
for (source_name, target_name) in source_names.into_iter().zip(target_names.into_iter())
{
out_exposes.push(fdecl::Expose::Runner(fdecl::ExposeRunner {
source: Some(clone_ref(&source)?),
source_name: Some(source_name.clone().into()),
target: Some(clone_ref(&target)?),
target_name: Some(target_name.into()),
..fdecl::ExposeRunner::EMPTY
}))
}
} else if let Some(n) = expose.resolver() {
let source = extract_single_expose_source(expose, None)?;
let source_names = n.to_vec();
let target_names = all_target_capability_names(expose, expose)
.ok_or_else(|| Error::internal("no capability"))?;
for (source_name, target_name) in source_names.into_iter().zip(target_names.into_iter())
{
out_exposes.push(fdecl::Expose::Resolver(fdecl::ExposeResolver {
source: Some(clone_ref(&source)?),
source_name: Some(source_name.clone().into()),
target: Some(clone_ref(&target)?),
target_name: Some(target_name.into()),
..fdecl::ExposeResolver::EMPTY
}))
}
} else if let Some(n) = expose.event_stream() {
let source = extract_single_expose_source(expose, None)?;
let source_names = n.to_vec();
let target_names = all_target_capability_names(expose, expose)
.ok_or_else(|| Error::internal("no capability"))?;
for (source_name, target_name) in source_names.into_iter().zip(target_names.into_iter())
{
let scopes = match expose.scope.clone() {
Some(value) => Some(annotate_type::<Vec<EventScope>>(value.into())),
None => None,
};
out_exposes.push(fdecl::Expose::EventStream(fdecl::ExposeEventStream {
source: Some(clone_ref(&source)?),
source_name: Some(source_name.clone().into()),
target: Some(clone_ref(&target)?),
target_name: Some(target_name.into()),
scope: match scopes {
Some(values) => {
let mut output = vec![];
for value in &values {
output.push(translate_child_or_collection_ref(
value.into(),
&all_children,
&all_collections,
)?);
}
Some(output)
}
None => None,
},
..fdecl::ExposeEventStream::EMPTY
}))
}
} else {
return Err(Error::internal(format!("expose: must specify a known capability")));
}
}
Ok(out_exposes)
}
impl<T> Into<Vec<T>> for OneOrMany<T> {
fn into(self) -> Vec<T> {
match self {
OneOrMany::One(one) => vec![one],
OneOrMany::Many(many) => many,
}
}
}
// Allows the above Into to work by annotating the type.
fn annotate_type<T>(val: T) -> T {
val
}
fn derive_source_and_availability(
availability: Option<&Availability>,
source: fdecl::Ref,
source_availability: Option<&SourceAvailability>,
all_capability_names: &HashSet<Name>,
all_children: &HashSet<&Name>,
all_collections: &HashSet<&Name>,
) -> (fdecl::Ref, fdecl::Availability) {
let availability = availability.map(|a| match a {
Availability::Required => fdecl::Availability::Required,
Availability::Optional => fdecl::Availability::Optional,
Availability::SameAsTarget => fdecl::Availability::SameAsTarget,
});
if source_availability != Some(&SourceAvailability::Unknown) {
return (source, availability.unwrap_or(fdecl::Availability::Required));
}
match &source {
fdecl::Ref::Child(fdecl::ChildRef { name, .. })
if !all_children.contains(&Name::new(name.clone()).unwrap()) =>
{
(
fdecl::Ref::VoidType(fdecl::VoidRef {}),
availability.unwrap_or(fdecl::Availability::Optional),
)
}
fdecl::Ref::Collection(fdecl::CollectionRef { name, .. })
if !all_collections.contains(&Name::new(name.clone()).unwrap()) =>
{
(
fdecl::Ref::VoidType(fdecl::VoidRef {}),
availability.unwrap_or(fdecl::Availability::Optional),
)
}
fdecl::Ref::Capability(fdecl::CapabilityRef { name, .. })
if !all_capability_names.contains(&Name::new(name.clone()).unwrap()) =>
{
(
fdecl::Ref::VoidType(fdecl::VoidRef {}),
availability.unwrap_or(fdecl::Availability::Optional),
)
}
_ => (source, availability.unwrap_or(fdecl::Availability::Required)),
}
}
/// `offer` rules route multiple capabilities from multiple sources to multiple targets.
fn translate_offer(
offer_in: &Vec<Offer>,
all_capability_names: &HashSet<Name>,
all_children: &HashSet<&Name>,
all_collections: &HashSet<&Name>,
) -> Result<Vec<fdecl::Offer>, Error> {
let mut out_offers = vec![];
for offer in offer_in.iter() {
if let Some(n) = offer.service() {
let entries = extract_offer_sources_and_targets(
offer,
n,
all_capability_names,
all_children,
all_collections,
)?;
for (source, source_name, target, target_name) in entries {
let (source, availability) = derive_source_and_availability(
offer.availability.as_ref(),
source,
offer.source_availability.as_ref(),
all_capability_names,
all_children,
all_collections,
);
out_offers.push(fdecl::Offer::Service(fdecl::OfferService {
source: Some(source),
source_name: Some(source_name.into()),
target: Some(target),
target_name: Some(target_name.into()),
availability: Some(availability),
..fdecl::OfferService::EMPTY
}));
}
} else if let Some(n) = offer.protocol() {
let entries = extract_offer_sources_and_targets(
offer,
n,
all_capability_names,
all_children,
all_collections,
)?;
for (source, source_name, target, target_name) in entries {
let (source, availability) = derive_source_and_availability(
offer.availability.as_ref(),
source,
offer.source_availability.as_ref(),
all_capability_names,
all_children,
all_collections,
);
out_offers.push(fdecl::Offer::Protocol(fdecl::OfferProtocol {
source: Some(source),
source_name: Some(source_name.into()),
target: Some(target),
target_name: Some(target_name.into()),
dependency_type: Some(
offer.dependency.clone().unwrap_or(cm::DependencyType::Strong).into(),
),
availability: Some(availability),
..fdecl::OfferProtocol::EMPTY
}));
}
} else if let Some(n) = offer.directory() {
let entries = extract_offer_sources_and_targets(
offer,
n,
all_capability_names,
all_children,
all_collections,
)?;
for (source, source_name, target, target_name) in entries {
let (source, availability) = derive_source_and_availability(
offer.availability.as_ref(),
source,
offer.source_availability.as_ref(),
all_capability_names,
all_children,
all_collections,
);
out_offers.push(fdecl::Offer::Directory(fdecl::OfferDirectory {
source: Some(source),
source_name: Some(source_name.into()),
target: Some(target),
target_name: Some(target_name.into()),
rights: extract_offer_rights(offer)?,
subdir: extract_offer_subdir(offer).map(|s| s.into()),
dependency_type: Some(
offer.dependency.clone().unwrap_or(cm::DependencyType::Strong).into(),
),
availability: Some(availability),
..fdecl::OfferDirectory::EMPTY
}));
}
} else if let Some(n) = offer.storage() {
let entries = extract_offer_sources_and_targets(
offer,
n,
all_capability_names,
all_children,
all_collections,
)?;
for (source, source_name, target, target_name) in entries {
let (source, availability) = derive_source_and_availability(
offer.availability.as_ref(),
source,
offer.source_availability.as_ref(),
all_capability_names,
all_children,
all_collections,
);
out_offers.push(fdecl::Offer::Storage(fdecl::OfferStorage {
source: Some(source),
source_name: Some(source_name.into()),
target: Some(target),
target_name: Some(target_name.into()),
availability: Some(availability),
..fdecl::OfferStorage::EMPTY
}));
}
} else if let Some(n) = offer.runner() {
let entries = extract_offer_sources_and_targets(
offer,
n,
all_capability_names,
all_children,
all_collections,
)?;
for (source, source_name, target, target_name) in entries {
out_offers.push(fdecl::Offer::Runner(fdecl::OfferRunner {
source: Some(source),
source_name: Some(source_name.into()),
target: Some(target),
target_name: Some(target_name.into()),
..fdecl::OfferRunner::EMPTY
}));
}
} else if let Some(n) = offer.resolver() {
let entries = extract_offer_sources_and_targets(
offer,
n,
all_capability_names,
all_children,
all_collections,
)?;
for (source, source_name, target, target_name) in entries {
out_offers.push(fdecl::Offer::Resolver(fdecl::OfferResolver {
source: Some(source),
source_name: Some(source_name.into()),
target: Some(target),
target_name: Some(target_name.into()),
..fdecl::OfferResolver::EMPTY
}));
}
} else if let Some(n) = offer.event() {
let entries = extract_offer_sources_and_targets(
offer,
n,
all_capability_names,
all_children,
all_collections,
)?;
for (source, source_name, target, target_name) in entries {
let (source, availability) = derive_source_and_availability(
offer.availability.as_ref(),
source,
offer.source_availability.as_ref(),
all_capability_names,
all_children,
all_collections,
);
out_offers.push(fdecl::Offer::Event(fdecl::OfferEvent {
source: Some(source),
source_name: Some(source_name.into()),
target: Some(target),
target_name: Some(target_name.into()),
// We have already validated that none will be present if we were using many
// events.
filter: match &offer.filter {
Some(dict) => Some(dictionary_from_map(dict.clone())?),
None => None,
},
availability: Some(availability),
..fdecl::OfferEvent::EMPTY
}));
}
} else if let Some(n) = offer.event_stream() {
let entries = extract_offer_sources_and_targets(
offer,
n,
all_capability_names,
all_children,
all_collections,
)?;
for (source, source_name, target, target_name) in entries {
let (source, availability) = derive_source_and_availability(
offer.availability.as_ref(),
source,
offer.source_availability.as_ref(),
all_capability_names,
all_children,
all_collections,
);
let scopes = match offer.scope.clone() {
Some(value) => Some(annotate_type::<Vec<EventScope>>(value.into())),
None => None,
};
out_offers.push(fdecl::Offer::EventStream(fdecl::OfferEventStream {
source: Some(source),
source_name: Some(source_name.into()),
target: Some(target),
target_name: Some(target_name.into()),
// We have already validated that none will be present if we were using many
// events.
filter: match offer.filter.clone() {
Some(dict) => Some(dictionary_from_map(dict)?),
None => None,
},
scope: match scopes {
Some(values) => {
let mut output = vec![];
for value in &values {
output.push(translate_child_or_collection_ref(
value.into(),
&all_children,
&all_collections,
)?);
}
Some(output)
}
None => None,
},
availability: Some(availability),
..fdecl::OfferEventStream::EMPTY
}));
}
} else {
return Err(Error::internal(format!("no capability")));
}
}
Ok(out_offers)
}
fn translate_children(children_in: &Vec<Child>) -> Result<Vec<fdecl::Child>, Error> {
let mut out_children = vec![];
for child in children_in.iter() {
out_children.push(fdecl::Child {
name: Some(child.name.clone().into()),
url: Some(child.url.clone().into()),
startup: Some(child.startup.clone().into()),
environment: extract_environment_ref(child.environment.as_ref()).map(|e| e.into()),
on_terminate: child.on_terminate.as_ref().map(|r| r.clone().into()),
..fdecl::Child::EMPTY
});
}
Ok(out_children)
}
fn translate_collections(
collections_in: &Vec<Collection>,
) -> Result<Vec<fdecl::Collection>, Error> {
let mut out_collections = vec![];
for collection in collections_in.iter() {
out_collections.push(fdecl::Collection {
name: Some(collection.name.clone().into()),
durability: Some(collection.durability.clone().into()),
environment: extract_environment_ref(collection.environment.as_ref()).map(|e| e.into()),
allowed_offers: collection.allowed_offers.clone().map(|a| a.into()),
allow_long_names: collection.allow_long_names.clone(),
persistent_storage: collection.persistent_storage.clone(),
..fdecl::Collection::EMPTY
});
}
Ok(out_collections)
}
/// Translates a nested value type to a [`fuchsia.config.decl.ConfigType`]
fn translate_nested_value_type(nested_type: &ConfigNestedValueType) -> fdecl::ConfigType {
let layout = match nested_type {
ConfigNestedValueType::Bool => fdecl::ConfigTypeLayout::Bool,
ConfigNestedValueType::Uint8 => fdecl::ConfigTypeLayout::Uint8,
ConfigNestedValueType::Uint16 => fdecl::ConfigTypeLayout::Uint16,
ConfigNestedValueType::Uint32 => fdecl::ConfigTypeLayout::Uint32,
ConfigNestedValueType::Uint64 => fdecl::ConfigTypeLayout::Uint64,
ConfigNestedValueType::Int8 => fdecl::ConfigTypeLayout::Int8,
ConfigNestedValueType::Int16 => fdecl::ConfigTypeLayout::Int16,
ConfigNestedValueType::Int32 => fdecl::ConfigTypeLayout::Int32,
ConfigNestedValueType::Int64 => fdecl::ConfigTypeLayout::Int64,
ConfigNestedValueType::String { .. } => fdecl::ConfigTypeLayout::String,
};
let constraints = match nested_type {
ConfigNestedValueType::String { max_size } => {
vec![fdecl::LayoutConstraint::MaxSize(max_size.get())]
}
_ => vec![],
};
fdecl::ConfigType {
layout,
constraints,
// This optional is not necessary, but without it,
// FIDL compilation complains because of a possible include-cycle.
// Bug: http://fxbug.dev/66350
parameters: Some(vec![]),
}
}
/// Translates a value type to a [`fuchsia.sys2.ConfigType`]
fn translate_value_type(value_type: &ConfigValueType) -> fdecl::ConfigType {
let layout = match value_type {
ConfigValueType::Bool => fdecl::ConfigTypeLayout::Bool,
ConfigValueType::Uint8 => fdecl::ConfigTypeLayout::Uint8,
ConfigValueType::Uint16 => fdecl::ConfigTypeLayout::Uint16,
ConfigValueType::Uint32 => fdecl::ConfigTypeLayout::Uint32,
ConfigValueType::Uint64 => fdecl::ConfigTypeLayout::Uint64,
ConfigValueType::Int8 => fdecl::ConfigTypeLayout::Int8,
ConfigValueType::Int16 => fdecl::ConfigTypeLayout::Int16,
ConfigValueType::Int32 => fdecl::ConfigTypeLayout::Int32,
ConfigValueType::Int64 => fdecl::ConfigTypeLayout::Int64,
ConfigValueType::String { .. } => fdecl::ConfigTypeLayout::String,
ConfigValueType::Vector { .. } => fdecl::ConfigTypeLayout::Vector,
};
let (constraints, parameters) = match value_type {
ConfigValueType::String { max_size } => {
(vec![fdecl::LayoutConstraint::MaxSize(max_size.get())], vec![])
}
ConfigValueType::Vector { max_count, element } => {
let nested_type = translate_nested_value_type(element);
(
vec![fdecl::LayoutConstraint::MaxSize(max_count.get())],
vec![fdecl::LayoutParameter::NestedType(nested_type)],
)
}
_ => (vec![], vec![]),
};
fdecl::ConfigType {
layout,
constraints,
// This optional is not necessary, but without it,
// FIDL compilation complains because of a possible include-cycle.
// Bug: http://fxbug.dev/66350
parameters: Some(parameters),
}
}
/// Translates a map of [`String`] -> [`ConfigValueType`] to a [`fuchsia.sys2.Config`]
fn translate_config(
fields: &BTreeMap<ConfigKey, ConfigValueType>,
package_path: &str,
) -> fdecl::ConfigSchema {
let mut fidl_fields = vec![];
// Compute a SHA-256 hash from each field
let mut hasher = Sha256::new();
for (key, value) in fields {
fidl_fields.push(fdecl::ConfigField {
key: Some(key.to_string()),
type_: Some(translate_value_type(value)),
..fdecl::ConfigField::EMPTY
});
hasher.update(key.as_str());
value.update_digest(&mut hasher);
}
let hash = hasher.finalize();
let checksum = fdecl::ConfigChecksum::Sha256(*hash.as_ref());
fdecl::ConfigSchema {
fields: Some(fidl_fields),
checksum: Some(checksum),
// for now we only support ELF components that look up config by package path
value_source: Some(fdecl::ConfigValueSource::PackagePath(package_path.to_owned())),
..fdecl::ConfigSchema::EMPTY
}
}
fn translate_environments(
envs_in: &Vec<Environment>,
all_capability_names: &HashSet<Name>,
) -> Result<Vec<fdecl::Environment>, Error> {
envs_in
.iter()
.map(|env| {
Ok(fdecl::Environment {
name: Some(env.name.clone().into()),
extends: match env.extends {
Some(EnvironmentExtends::Realm) => Some(fdecl::EnvironmentExtends::Realm),
Some(EnvironmentExtends::None) => Some(fdecl::EnvironmentExtends::None),
None => Some(fdecl::EnvironmentExtends::None),
},
runners: env
.runners
.as_ref()
.map(|runners| {
runners
.iter()
.map(translate_runner_registration)
.collect::<Result<Vec<_>, Error>>()
})
.transpose()?,
resolvers: env
.resolvers
.as_ref()
.map(|resolvers| {
resolvers
.iter()
.map(translate_resolver_registration)
.collect::<Result<Vec<_>, Error>>()
})
.transpose()?,
debug_capabilities: env
.debug
.as_ref()
.map(|debug_capabiltities| {
translate_debug_capabilities(debug_capabiltities, all_capability_names)
})
.transpose()?,
stop_timeout_ms: env.stop_timeout_ms.map(|s| s.0),
..fdecl::Environment::EMPTY
})
})
.collect()
}
fn translate_runner_registration(
reg: &RunnerRegistration,
) -> Result<fdecl::RunnerRegistration, Error> {
Ok(fdecl::RunnerRegistration {
source_name: Some(reg.runner.clone().into()),
source: Some(extract_single_offer_source(reg, None)?),
target_name: Some(reg.r#as.as_ref().unwrap_or(&reg.runner).clone().into()),
..fdecl::RunnerRegistration::EMPTY
})
}
fn translate_resolver_registration(
reg: &ResolverRegistration,
) -> Result<fdecl::ResolverRegistration, Error> {
Ok(fdecl::ResolverRegistration {
resolver: Some(reg.resolver.clone().into()),
source: Some(extract_single_offer_source(reg, None)?),
scheme: Some(
reg.scheme
.as_str()
.parse::<cm_types::UrlScheme>()
.map_err(|e| Error::internal(format!("invalid URL scheme: {}", e)))?
.into(),
),
..fdecl::ResolverRegistration::EMPTY
})
}
fn translate_debug_capabilities(
capabilities: &Vec<DebugRegistration>,
all_capability_names: &HashSet<Name>,
) -> Result<Vec<fdecl::DebugRegistration>, Error> {
let mut out_capabilities = vec![];
for capability in capabilities {
if let Some(n) = capability.protocol() {
let source = extract_single_offer_source(capability, Some(all_capability_names))?;
let targets = all_target_capability_names(capability, capability)
.ok_or_else(|| Error::internal("no capability"))?;
let source_names = n.to_vec();
for target_name in targets {
// When multiple source names are provided, there is no way to alias each one, so
// source_name == target_name.
// When one source name is provided, source_name may be aliased to a different
// target_name, so we source_names[0] to derive the source_name.
//
// TODO: This logic could be simplified to use iter::zip() if
// extract_all_targets_for_each_child returned separate vectors for targets and
// target_names instead of the cross product of them.
let source_name = if source_names.len() == 1 {
source_names[0].clone()
} else {
target_name.clone()
};
out_capabilities.push(fdecl::DebugRegistration::Protocol(
fdecl::DebugProtocolRegistration {
source: Some(clone_ref(&source)?),
source_name: Some(source_name.into()),
target_name: Some(target_name.into()),
..fdecl::DebugProtocolRegistration::EMPTY
},
));
}
}
}
Ok(out_capabilities)
}
fn extract_use_source(
in_obj: &Use,
all_capability_names: &HashSet<Name>,
all_children_names: &HashSet<&Name>,
) -> Result<fdecl::Ref, Error> {
match in_obj.from.as_ref() {
Some(UseFromRef::Parent) => Ok(fdecl::Ref::Parent(fdecl::ParentRef {})),
Some(UseFromRef::Framework) => Ok(fdecl::Ref::Framework(fdecl::FrameworkRef {})),
Some(UseFromRef::Debug) => Ok(fdecl::Ref::Debug(fdecl::DebugRef {})),
Some(UseFromRef::Self_) => Ok(fdecl::Ref::Self_(fdecl::SelfRef {})),
Some(UseFromRef::Named(name)) => {
if all_capability_names.contains(&name) {
Ok(fdecl::Ref::Capability(fdecl::CapabilityRef { name: name.clone().into() }))
} else if all_children_names.contains(&name) {
Ok(fdecl::Ref::Child(fdecl::ChildRef {
name: name.clone().into(),
collection: None,
}))
} else {
Err(Error::internal(format!(
"use source \"{:?}\" not supported for \"use from\"",
name
)))
}
}
None => Ok(fdecl::Ref::Parent(fdecl::ParentRef {})), // Default value.
}
}
fn extract_use_availability(in_obj: &Use) -> Result<fdecl::Availability, Error> {
match in_obj.availability.as_ref() {
Some(Availability::Required) | None => Ok(fdecl::Availability::Required),
Some(Availability::Optional) => Ok(fdecl::Availability::Optional),
_ => Err(Error::internal(
"availability \"same_as_target\" not supported for use declarations",
)),
}
}
// Since fdecl::Ref is not cloneable, write our own clone function.
fn clone_ref(ref_: &fdecl::Ref) -> Result<fdecl::Ref, Error> {
match ref_ {
fdecl::Ref::Parent(parent_ref) => Ok(fdecl::Ref::Parent(parent_ref.clone())),
fdecl::Ref::Self_(self_ref) => Ok(fdecl::Ref::Self_(self_ref.clone())),
fdecl::Ref::Child(child_ref) => Ok(fdecl::Ref::Child(child_ref.clone())),
fdecl::Ref::Collection(collection_ref) => {
Ok(fdecl::Ref::Collection(collection_ref.clone()))
}
fdecl::Ref::Framework(framework_ref) => Ok(fdecl::Ref::Framework(framework_ref.clone())),
fdecl::Ref::Capability(capability_ref) => {
Ok(fdecl::Ref::Capability(capability_ref.clone()))
}
fdecl::Ref::Debug(debug_ref) => Ok(fdecl::Ref::Debug(debug_ref.clone())),
_ => Err(Error::internal("Unknown fdecl::Ref found.")),
}
}
fn extract_use_event_source(in_obj: &Use) -> Result<fdecl::Ref, Error> {
match in_obj.from.as_ref() {
Some(UseFromRef::Parent) => Ok(fdecl::Ref::Parent(fdecl::ParentRef {})),
Some(UseFromRef::Framework) => Ok(fdecl::Ref::Framework(fdecl::FrameworkRef {})),
Some(UseFromRef::Named(name)) => {
Ok(fdecl::Ref::Capability(fdecl::CapabilityRef { name: name.clone().into() }))
}
Some(UseFromRef::Debug) => {
Err(Error::internal(format!("Debug source provided for \"use event\"")))
}
Some(UseFromRef::Self_) => {
Err(Error::internal(format!("Self source not supported for \"use event\"")))
}
None => Err(Error::internal(format!("No source \"from\" provided for \"use\""))),
}
}
fn extract_use_subdir(in_obj: &Use) -> Option<cm::RelativePath> {
in_obj.subdir.clone()
}
fn extract_expose_subdir(in_obj: &Expose) -> Option<cm::RelativePath> {
in_obj.subdir.clone()
}
fn extract_offer_subdir(in_obj: &Offer) -> Option<cm::RelativePath> {
in_obj.subdir.clone()
}
fn extract_expose_rights(in_obj: &Expose) -> Result<Option<fio::Operations>, Error> {
match in_obj.rights.as_ref() {
Some(rights_tokens) => {
let mut rights = Vec::new();
for token in rights_tokens.0.iter() {
rights.append(&mut token.expand())
}
if rights.is_empty() {
return Err(Error::missing_rights(
"Rights provided to expose are not well formed.",
));
}
let mut seen_rights = HashSet::with_capacity(rights.len());
let mut operations: fio::Operations = fio::Operations::empty();
for right in rights.iter() {
if seen_rights.contains(&right) {
return Err(Error::duplicate_rights(
"Rights provided to expose are not well formed.",
));
}
seen_rights.insert(right);
operations |= *right;
}
Ok(Some(operations))
}
// Unlike use rights, expose rights can take a None value
None => Ok(None),
}
}
fn expose_source_from_ref(
reference: &ExposeFromRef,
all_capability_names: Option<&HashSet<Name>>,
all_collections: Option<&HashSet<&Name>>,
) -> Result<fdecl::Ref, Error> {
match reference {
ExposeFromRef::Named(name) => {
if all_capability_names.is_some() && all_capability_names.unwrap().contains(&name) {
Ok(fdecl::Ref::Capability(fdecl::CapabilityRef { name: name.clone().into() }))
} else if all_collections.is_some() && all_collections.unwrap().contains(&name) {
Ok(fdecl::Ref::Collection(fdecl::CollectionRef { name: name.clone().into() }))
} else {
Ok(fdecl::Ref::Child(fdecl::ChildRef {
name: name.clone().into(),
collection: None,
}))
}
}
ExposeFromRef::Framework => Ok(fdecl::Ref::Framework(fdecl::FrameworkRef {})),
ExposeFromRef::Self_ => Ok(fdecl::Ref::Self_(fdecl::SelfRef {})),
}
}
fn extract_single_expose_source(
in_obj: &Expose,
all_capability_names: Option<&HashSet<Name>>,
) -> Result<fdecl::Ref, Error> {
match &in_obj.from {
OneOrMany::One(reference) => expose_source_from_ref(&reference, all_capability_names, None),
OneOrMany::Many(many) => {
return Err(Error::internal(format!(
"multiple unexpected \"from\" clauses for \"expose\": {:?}",
many
)))
}
}
}
fn extract_all_expose_sources(
in_obj: &Expose,
all_collections: Option<&HashSet<&Name>>,
) -> Result<Vec<fdecl::Ref>, Error> {
in_obj
.from
.to_vec()
.into_iter()
.map(|e| expose_source_from_ref(e, None, all_collections))
.collect()
}
fn extract_offer_rights(in_obj: &Offer) -> Result<Option<fio::Operations>, Error> {
match in_obj.rights.as_ref() {
Some(rights_tokens) => {
let mut rights = Vec::new();
for token in rights_tokens.0.iter() {
rights.append(&mut token.expand())
}
if rights.is_empty() {
return Err(Error::missing_rights("Rights provided to offer are not well formed."));
}
let mut seen_rights = HashSet::with_capacity(rights.len());
let mut operations: fio::Operations = fio::Operations::empty();
for right in rights.iter() {
if seen_rights.contains(&right) {
return Err(Error::duplicate_rights(
"Rights provided to offer are not well formed.",
));
}
seen_rights.insert(right);
operations |= *right;
}
Ok(Some(operations))
}
// Unlike use rights, offer rights can take a None value
None => Ok(None),
}
}
fn extract_single_offer_source<T>(
in_obj: &T,
all_capability_names: Option<&HashSet<Name>>,
) -> Result<fdecl::Ref, Error>
where
T: FromClause,
{
match in_obj.from_() {
OneOrMany::One(reference) => offer_source_from_ref(reference, all_capability_names, None),
many => {
return Err(Error::internal(format!(
"multiple unexpected \"from\" clauses for \"offer\": {}",
many
)))
}
}
}
fn extract_all_offer_sources<T: FromClause>(
in_obj: &T,
all_capability_names: &HashSet<Name>,
all_collections: &HashSet<&Name>,
) -> Result<Vec<fdecl::Ref>, Error> {
in_obj
.from_()
.to_vec()
.into_iter()
.map(|r| {
offer_source_from_ref(r.clone(), Some(all_capability_names), Some(all_collections))
})
.collect()
}
fn translate_child_or_collection_ref(
reference: AnyRef,
all_children: &HashSet<&Name>,
all_collections: &HashSet<&Name>,
) -> Result<fdecl::Ref, Error> {
match reference {
AnyRef::Named(name) if all_children.contains(name) => {
Ok(fdecl::Ref::Child(fdecl::ChildRef { name: name.clone().into(), collection: None }))
}
AnyRef::Named(name) if all_collections.contains(name) => {
Ok(fdecl::Ref::Collection(fdecl::CollectionRef { name: name.clone().into() }))
}
AnyRef::Named(_) => Err(Error::internal(format!("dangling reference: \"{}\"", reference))),
_ => Err(Error::internal(format!("invalid child reference: \"{}\"", reference))),
}
}
// Return a list of (source, source capability id, target, target capability id) expressed in the
// `offer`.
fn extract_offer_sources_and_targets(
offer: &Offer,
source_names: OneOrMany<Name>,
all_capability_names: &HashSet<Name>,
all_children: &HashSet<&Name>,
all_collections: &HashSet<&Name>,
) -> Result<Vec<(fdecl::Ref, Name, fdecl::Ref, Name)>, Error> {
let mut out = vec![];
let source_names = source_names.to_vec();
let sources = extract_all_offer_sources(offer, all_capability_names, all_collections)?;
let target_names = all_target_capability_names(offer, offer)
.ok_or_else(|| Error::internal("no capability".to_string()))?;
for source in &sources {
for to in &offer.to {
for target_name in &target_names {
// When multiple source names are provided, there is no way to alias each one,
// so we can assume source_name == target_name. When one source name is provided,
// source_name may be aliased to a different target_name, so we use
// source_names[0] to obtain the source_name.
let source_name = if source_names.len() == 1 {
source_names[0].clone()
} else {
target_name.clone()
};
let target =
translate_child_or_collection_ref(to.into(), all_children, all_collections)?;
out.push((source.clone(), source_name, target, target_name.clone()))
}
}
}
Ok(out)
}
/// Return the target paths specified in the given use declaration.
fn all_target_use_paths<T, U>(in_obj: &T, to_obj: &U) -> Option<OneOrMany<Path>>
where
T: CapabilityClause,
U: AsClause + PathClause,
{
if let Some(n) = in_obj.service() {
Some(svc_paths_from_names(n, to_obj))
} else if let Some(n) = in_obj.protocol() {
Some(svc_paths_from_names(n, to_obj))
} else if let Some(_) = in_obj.directory() {
let path = to_obj.path().expect("no path on use directory");
Some(OneOrMany::One(path.clone()))
} else if let Some(_) = in_obj.storage() {
let path = to_obj.path().expect("no path on use storage");
Some(OneOrMany::One(path.clone()))
} else if let Some(_) = in_obj.event_stream_deprecated() {
let path = to_obj.path().expect("no path on event stream");
Some(OneOrMany::One(path.clone()))
} else if let Some(_) = in_obj.event_stream() {
let default_path = Path::new("/svc/fuchsia.component.EventStream".to_string()).unwrap();
let path = to_obj.path().unwrap_or(&default_path);
Some(OneOrMany::One(path.clone()))
} else {
None
}
}
/// Returns the list of paths derived from a `use` declaration with `names` and `to_obj`. `to_obj`
/// must be a declaration that has a `path` clause.
fn svc_paths_from_names<T>(names: OneOrMany<Name>, to_obj: &T) -> OneOrMany<Path>
where
T: PathClause,
{
match names {
OneOrMany::One(n) => {
if let Some(path) = to_obj.path() {
OneOrMany::One(path.clone())
} else {
OneOrMany::One(format!("/svc/{}", n).parse().unwrap())
}
}
OneOrMany::Many(v) => {
let many = v.iter().map(|n| format!("/svc/{}", n).parse().unwrap()).collect();
OneOrMany::Many(many)
}
}
}
/// Return the single target path specified in the given use declaration.
fn one_target_use_path<T, U>(in_obj: &T, to_obj: &U) -> Result<Path, Error>
where
T: CapabilityClause,
U: AsClause + PathClause,
{
match all_target_use_paths(in_obj, to_obj) {
Some(OneOrMany::One(target_name)) => Ok(target_name),
Some(OneOrMany::Many(_)) => {
Err(Error::internal("expecting one capability, but multiple provided"))
}
_ => Err(Error::internal("expecting one capability, but none provided")),
}
}
/// Return the target names or paths specified in the given capability.
fn all_target_capability_names<T, U>(in_obj: &T, to_obj: &U) -> Option<OneOrMany<Name>>
where
T: CapabilityClause,
U: AsClause + PathClause,
{
if let Some(as_) = to_obj.r#as() {
// We've already validated that when `as` is specified, only 1 source id exists.
Some(OneOrMany::One(as_.clone()))
} else {
if let Some(n) = in_obj.service() {
Some(n.clone())
} else if let Some(n) = in_obj.protocol() {
Some(n.clone())
} else if let Some(n) = in_obj.directory() {
Some(n.clone())
} else if let Some(n) = in_obj.storage() {
Some(n.clone())
} else if let Some(n) = in_obj.runner() {
Some(n.clone())
} else if let Some(n) = in_obj.resolver() {
Some(n.clone())
} else if let Some(n) = in_obj.event() {
Some(n.clone())
} else if let Some(n) = in_obj.event_stream() {
Some(n.clone())
} else {
None
}
}
}
fn extract_expose_target(in_obj: &Expose) -> Result<fdecl::Ref, Error> {
match &in_obj.to {
Some(ExposeToRef::Parent) => Ok(fdecl::Ref::Parent(fdecl::ParentRef {})),
Some(ExposeToRef::Framework) => Ok(fdecl::Ref::Framework(fdecl::FrameworkRef {})),
None => Ok(fdecl::Ref::Parent(fdecl::ParentRef {})),
}
}
fn extract_environment_ref(r: Option<&EnvironmentRef>) -> Option<cm::Name> {
r.map(|r| {
let EnvironmentRef::Named(name) = r;
name.clone()
})
}
pub fn translate_capabilities(
capabilities_in: &Vec<Capability>,
as_builtin: bool,
) -> Result<Vec<fdecl::Capability>, Error> {
let mut out_capabilities = vec![];
for capability in capabilities_in {
if let Some(service) = &capability.service {
for n in service.to_vec() {
let source_path = match as_builtin {
true => None,
false => Some(
capability
.path
.clone()
.unwrap_or_else(|| format!("/svc/{}", n).parse().unwrap())
.into(),
),
};
out_capabilities.push(fdecl::Capability::Service(fdecl::Service {
name: Some(n.clone().into()),
source_path: source_path,
..fdecl::Service::EMPTY
}));
}
} else if let Some(protocol) = &capability.protocol {
for n in protocol.to_vec() {
let source_path = match as_builtin {
true => None,
false => Some(
capability
.path
.clone()
.unwrap_or_else(|| format!("/svc/{}", n).parse().unwrap())
.into(),
),
};
out_capabilities.push(fdecl::Capability::Protocol(fdecl::Protocol {
name: Some(n.clone().into()),
source_path: source_path,
..fdecl::Protocol::EMPTY
}));
}
} else if let Some(n) = &capability.directory {
let source_path = match as_builtin {
true => None,
false => {
Some(capability.path.as_ref().expect("missing source path").clone().into())
}
};
let rights = extract_required_rights(capability, "capability")?;
out_capabilities.push(fdecl::Capability::Directory(fdecl::Directory {
name: Some(n.clone().into()),
source_path: source_path,
rights: Some(rights),
..fdecl::Directory::EMPTY
}));
} else if let Some(n) = &capability.storage {
if as_builtin {
return Err(Error::internal(format!(
"built-in storage capabilities are not supported"
)));
}
let backing_dir = capability
.backing_dir
.as_ref()
.expect("storage has no path or backing_dir")
.clone()
.into();
out_capabilities.push(fdecl::Capability::Storage(fdecl::Storage {
name: Some(n.clone().into()),
backing_dir: Some(backing_dir),
source: Some(offer_source_from_ref(
capability.from.as_ref().unwrap().into(),
None,
None,
)?),
subdir: capability.subdir.clone().map(Into::into),
storage_id: Some(
capability.storage_id.clone().expect("storage is missing storage_id").into(),
),
..fdecl::Storage::EMPTY
}));
} else if let Some(n) = &capability.runner {
let source_path = match as_builtin {
true => None,
false => {
Some(capability.path.as_ref().expect("missing source path").clone().into())
}
};
out_capabilities.push(fdecl::Capability::Runner(fdecl::Runner {
name: Some(n.clone().into()),
source_path: source_path,
..fdecl::Runner::EMPTY
}));
} else if let Some(n) = &capability.resolver {
let source_path = match as_builtin {
true => None,
false => {
Some(capability.path.as_ref().expect("missing source path").clone().into())
}
};
out_capabilities.push(fdecl::Capability::Resolver(fdecl::Resolver {
name: Some(n.clone().into()),
source_path: source_path,
..fdecl::Resolver::EMPTY
}));
} else if let Some(n) = &capability.event {
if !as_builtin {
return Err(Error::internal(format!(
"event capabilities may only be declared as built-in capabilities"
)));
}
out_capabilities.push(fdecl::Capability::Event(fdecl::Event {
name: Some(n.clone().into()),
..fdecl::Event::EMPTY
}));
} else if let Some(ns) = &capability.event_stream {
if !as_builtin {
return Err(Error::internal(format!(
"event_stream capabilities may only be declared as built-in capabilities"
)));
}
for n in ns {
out_capabilities.push(fdecl::Capability::EventStream(fdecl::EventStream {
name: Some(n.clone().into()),
..fdecl::EventStream::EMPTY
}));
}
} else {
return Err(Error::internal(format!("no capability declaration recognized")));
}
}
Ok(out_capabilities)
}
pub fn extract_required_rights<T>(in_obj: &T, keyword: &str) -> Result<fio::Operations, Error>
where
T: RightsClause,
{
match in_obj.rights() {
Some(rights_tokens) => {
let mut rights = Vec::new();
for token in rights_tokens.0.iter() {
rights.append(&mut token.expand())
}
if rights.is_empty() {
return Err(Error::missing_rights(format!(
"Rights provided to `{}` are not well formed.",
keyword
)));
}
let mut seen_rights = HashSet::with_capacity(rights.len());
let mut operations: fio::Operations = fio::Operations::empty();
for right in rights.iter() {
if seen_rights.contains(&right) {
return Err(Error::duplicate_rights(format!(
"Rights provided to `{}` are not well formed.",
keyword
)));
}
seen_rights.insert(right);
operations |= *right;
}
Ok(operations)
}
None => Err(Error::internal(format!(
"No `{}` rights provided but required for directories",
keyword
))),
}
}
pub fn offer_source_from_ref(
reference: AnyRef<'_>,
all_capability_names: Option<&HashSet<Name>>,
all_collection_names: Option<&HashSet<&Name>>,
) -> Result<fdecl::Ref, Error> {
match reference {
AnyRef::Named(name) => {
if all_capability_names.is_some() && all_capability_names.unwrap().contains(&name) {
Ok(fdecl::Ref::Capability(fdecl::CapabilityRef { name: name.clone().into() }))
} else if all_collection_names.is_some()
&& all_collection_names.unwrap().contains(&name)
{
Ok(fdecl::Ref::Collection(fdecl::CollectionRef { name: name.clone().into() }))
} else {
Ok(fdecl::Ref::Child(fdecl::ChildRef {
name: name.clone().into(),
collection: None,
}))
}
}
AnyRef::Framework => Ok(fdecl::Ref::Framework(fdecl::FrameworkRef {})),
AnyRef::Debug => Ok(fdecl::Ref::Debug(fdecl::DebugRef {})),
AnyRef::Parent => Ok(fdecl::Ref::Parent(fdecl::ParentRef {})),
AnyRef::Self_ => Ok(fdecl::Ref::Self_(fdecl::SelfRef {})),
AnyRef::Void => Ok(fdecl::Ref::VoidType(fdecl::VoidRef {})),
}
}
#[cfg(test)]
mod tests {
use {
super::*,
crate::{
error::Error, AnyRef, AsClause, Capability, CapabilityClause, Child, Collection,
DebugRegistration, Document, Environment, EnvironmentExtends, EnvironmentRef,
EventSubscriptionsClause, Expose, ExposeFromRef, ExposeToRef, FromClause, Offer,
OneOrMany, Path, PathClause, Program, ResolverRegistration, RightsClause,
RunnerRegistration, Use, UseFromRef,
},
cm_types::{self as cm, Name},
fidl_fuchsia_component_decl as fdecl, fidl_fuchsia_data as fdata, fidl_fuchsia_io as fio,
serde_json::{json, Map, Value},
std::collections::HashSet,
std::convert::Into,
};
macro_rules! test_compile {
(
$(
$(#[$m:meta])*
$test_name:ident => {
input = $input:expr,
output = $expected:expr,
},
)+
) => {
$(
$(#[$m])*
#[test]
fn $test_name() {
let input = serde_json::from_str(&$input.to_string()).expect("deserialization failed");
let actual = compile(&input, Some("fake.cvf")).expect("compilation failed");
assert_eq!(actual, $expected);
}
)+
}
}
fn default_component_decl() -> fdecl::Component {
fdecl::Component::EMPTY
}
test_compile! {
test_compile_empty => {
input = json!({}),
output = default_component_decl(),
},
test_compile_empty_includes => {
input = json!({ "include": [] }),
output = default_component_decl(),
},
test_compile_program => {
input = json!({
"program": {
"runner": "elf",
"binary": "bin/app",
},
}),
output = fdecl::Component {
program: Some(fdecl::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/app".to_string()))),
}]),
..fdata::Dictionary::EMPTY
}),
..fdecl::Program::EMPTY
}),
..default_component_decl()
},
},
test_compile_program_with_nested_objects => {
input = json!({
"program": {
"runner": "elf",
"binary": "bin/app",
"one": {
"two": {
"three.four": {
"five": "six"
}
},
}
},
}),
output = fdecl::Component {
program: Some(fdecl::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/app".to_string()))),
},
fdata::DictionaryEntry {
key: "one.two.three.four.five".to_string(),
value: Some(Box::new(fdata::DictionaryValue::Str("six".to_string()))),
},
]),
..fdata::Dictionary::EMPTY
}),
..fdecl::Program::EMPTY
}),
..default_component_decl()
},
},
test_compile_program_with_array_of_objects => {
input = json!({
"program": {
"runner": "elf",
"binary": "bin/app",
"networks": [
{
"endpoints": [
{
"name": "device",
"mac": "aa:bb:cc:dd:ee:ff"
},
{
"name": "emu",
"mac": "ff:ee:dd:cc:bb:aa"
},
],
"name": "external_network"
}
],
},
}),
output = fdecl::Component {
program: Some(fdecl::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/app".to_string()))),
},
fdata::DictionaryEntry {
key: "networks".to_string(),
value: Some(Box::new(fdata::DictionaryValue::ObjVec(vec![
fdata::Dictionary {
entries: Some(vec![
fdata::DictionaryEntry {
key: "endpoints".to_string(),
value: Some(Box::new(fdata::DictionaryValue::ObjVec(vec![
fdata::Dictionary {
entries: Some(vec![
fdata::DictionaryEntry {
key: "mac".to_string(),
value: Some(Box::new(fdata::DictionaryValue::Str("aa:bb:cc:dd:ee:ff".to_string()))),
},
fdata::DictionaryEntry {
key: "name".to_string(),
value: Some(Box::new(fdata::DictionaryValue::Str("device".to_string()))),
}
]),
..fdata::Dictionary::EMPTY
},
fdata::Dictionary {
entries: Some(vec![
fdata::DictionaryEntry {
key: "mac".to_string(),
value: Some(Box::new(fdata::DictionaryValue::Str("ff:ee:dd:cc:bb:aa".to_string()))),
},
fdata::DictionaryEntry {
key: "name".to_string(),
value: Some(Box::new(fdata::DictionaryValue::Str("emu".to_string()))),
}
]),
..fdata::Dictionary::EMPTY
},
])))
},
fdata::DictionaryEntry {
key: "name".to_string(),
value: Some(Box::new(fdata::DictionaryValue::Str("external_network".to_string()))),
},
]),
..fdata::Dictionary::EMPTY
}
]))),
},
]),
..fdata::Dictionary::EMPTY
}),
..fdecl::Program::EMPTY
}),
..default_component_decl()
},
},
test_compile_use => {
input = json!({
"use": [
{
"protocol": "LegacyCoolFonts",
"path": "/svc/fuchsia.fonts.LegacyProvider",
"availability": "optional",
},
{ "protocol": "fuchsia.sys2.LegacyRealm", "from": "framework" },
{ "protocol": "fuchsia.sys2.StorageAdmin", "from": "#data-storage" },
{ "protocol": "fuchsia.sys2.DebugProto", "from": "debug" },
{ "protocol": "fuchsia.sys2.Echo", "from": "self", "availability": "optional" },
{ "directory": "assets", "rights" : ["read_bytes"], "path": "/data/assets" },
{
"directory": "config",
"path": "/data/config",
"from": "parent",
"rights": ["read_bytes"],
"subdir": "fonts",
},
{ "storage": "hippos", "path": "/hippos" },
{ "storage": "cache", "path": "/tmp" },
{ "event": "destroyed", "from": "parent" },
{ "event": ["started", "stopped"], "from": "framework" },
{
"event": "directory_ready",
"as": "diagnostics",
"from": "parent",
"filter": { "name": "diagnostics" }
},
{
"event_stream_deprecated": "foo_stream",
"subscriptions": [
{
"event": [ "started", "diagnostics" ],
},
{
"event": [ "destroyed" ],
}
]
},
{
"event_stream": "bar_stream",
},
{
"event_stream": ["foobar", "stream"],
"scope": ["#logger", "#modular"]
}
],
"capabilities": [
{
"storage": "data-storage",
"from": "parent",
"backing_dir": "minfs",
"storage_id": "static_instance_id_or_moniker",
}
],
"children": [
{
"name": "logger",
"url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm",
"environment": "#env_one"
}
],
"collections": [
{
"name": "modular",
"durability": "persistent",
},
],
}
),
output = fdecl::Component {
uses: Some(vec![
fdecl::Use::Protocol (
fdecl::UseProtocol {
dependency_type: Some(fdecl::DependencyType::Strong),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("LegacyCoolFonts".to_string()),
target_path: Some("/svc/fuchsia.fonts.LegacyProvider".to_string()),
availability: Some(fdecl::Availability::Optional),
..fdecl::UseProtocol::EMPTY
}
),
fdecl::Use::Protocol (
fdecl::UseProtocol {
dependency_type: Some(fdecl::DependencyType::Strong),
source: Some(fdecl::Ref::Framework(fdecl::FrameworkRef {})),
source_name: Some("fuchsia.sys2.LegacyRealm".to_string()),
target_path: Some("/svc/fuchsia.sys2.LegacyRealm".to_string()),
availability: Some(fdecl::Availability::Required),
..fdecl::UseProtocol::EMPTY
}
),
fdecl::Use::Protocol (
fdecl::UseProtocol {
dependency_type: Some(fdecl::DependencyType::Strong),
source: Some(fdecl::Ref::Capability(fdecl::CapabilityRef { name: "data-storage".to_string() })),
source_name: Some("fuchsia.sys2.StorageAdmin".to_string()),
target_path: Some("/svc/fuchsia.sys2.StorageAdmin".to_string()),
availability: Some(fdecl::Availability::Required),
..fdecl::UseProtocol::EMPTY
}
),
fdecl::Use::Protocol (
fdecl::UseProtocol {
dependency_type: Some(fdecl::DependencyType::Strong),
source: Some(fdecl::Ref::Debug(fdecl::DebugRef {})),
source_name: Some("fuchsia.sys2.DebugProto".to_string()),
target_path: Some("/svc/fuchsia.sys2.DebugProto".to_string()),
availability: Some(fdecl::Availability::Required),
..fdecl::UseProtocol::EMPTY
}
),
fdecl::Use::Protocol (
fdecl::UseProtocol {
dependency_type: Some(fdecl::DependencyType::Strong),
source: Some(fdecl::Ref::Self_(fdecl::SelfRef {})),
source_name: Some("fuchsia.sys2.Echo".to_string()),
target_path: Some("/svc/fuchsia.sys2.Echo".to_string()),
availability: Some(fdecl::Availability::Optional),
..fdecl::UseProtocol::EMPTY
}
),
fdecl::Use::Directory (
fdecl::UseDirectory {
dependency_type: Some(fdecl::DependencyType::Strong),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("assets".to_string()),
target_path: Some("/data/assets".to_string()),
rights: Some(fio::Operations::READ_BYTES),
subdir: None,
availability: Some(fdecl::Availability::Required),
..fdecl::UseDirectory::EMPTY
}
),
fdecl::Use::Directory (
fdecl::UseDirectory {
dependency_type: Some(fdecl::DependencyType::Strong),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("config".to_string()),
target_path: Some("/data/config".to_string()),
rights: Some(fio::Operations::READ_BYTES),
subdir: Some("fonts".to_string()),
availability: Some(fdecl::Availability::Required),
..fdecl::UseDirectory::EMPTY
}
),
fdecl::Use::Storage (
fdecl::UseStorage {
source_name: Some("hippos".to_string()),
target_path: Some("/hippos".to_string()),
availability: Some(fdecl::Availability::Required),
..fdecl::UseStorage::EMPTY
}
),
fdecl::Use::Storage (
fdecl::UseStorage {
source_name: Some("cache".to_string()),
target_path: Some("/tmp".to_string()),
availability: Some(fdecl::Availability::Required),
..fdecl::UseStorage::EMPTY
}
),
fdecl::Use::Event (
fdecl::UseEvent {
dependency_type: Some(fdecl::DependencyType::Strong),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("destroyed".to_string()),
target_name: Some("destroyed".to_string()),
filter: None,
availability: Some(fdecl::Availability::Required),
..fdecl::UseEvent::EMPTY
}
),
fdecl::Use::Event (
fdecl::UseEvent {
dependency_type: Some(fdecl::DependencyType::Strong),
source: Some(fdecl::Ref::Framework(fdecl::FrameworkRef {})),
source_name: Some("started".to_string()),
target_name: Some("started".to_string()),
filter: None,
availability: Some(fdecl::Availability::Required),
..fdecl::UseEvent::EMPTY
}
),
fdecl::Use::Event (
fdecl::UseEvent {
dependency_type: Some(fdecl::DependencyType::Strong),
source: Some(fdecl::Ref::Framework(fdecl::FrameworkRef {})),
source_name: Some("stopped".to_string()),
target_name: Some("stopped".to_string()),
filter: None,
availability: Some(fdecl::Availability::Required),
..fdecl::UseEvent::EMPTY
}
),
fdecl::Use::Event (
fdecl::UseEvent {
dependency_type: Some(fdecl::DependencyType::Strong),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("directory_ready".to_string()),
target_name: Some("diagnostics".to_string()),
filter: Some(fdata::Dictionary {
entries: Some(vec![
fdata::DictionaryEntry {
key: "name".to_string(),
value: Some(Box::new(fdata::DictionaryValue::Str("diagnostics".to_string()))),
},
]),
..fdata::Dictionary::EMPTY
}),
availability: Some(fdecl::Availability::Required),
..fdecl::UseEvent::EMPTY
}
),
fdecl::Use::EventStreamDeprecated(fdecl::UseEventStreamDeprecated {
name: Some("foo_stream".to_string()),
subscriptions: Some(vec![
fdecl::EventSubscription {
event_name: Some("started".to_string()),
..fdecl::EventSubscription::EMPTY
},
fdecl::EventSubscription {
event_name: Some("diagnostics".to_string()),
..fdecl::EventSubscription::EMPTY
},
fdecl::EventSubscription {
event_name: Some("destroyed".to_string()),
..fdecl::EventSubscription::EMPTY
},
]),
availability: Some(fdecl::Availability::Required),
..fdecl::UseEventStreamDeprecated::EMPTY
}),
fdecl::Use::EventStream(fdecl::UseEventStream {
source_name: Some("bar_stream".to_string()),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef{})),
target_path: Some("/svc/fuchsia.component.EventStream".to_string()),
availability: Some(fdecl::Availability::Required),
..fdecl::UseEventStream::EMPTY
}),
fdecl::Use::EventStream(fdecl::UseEventStream {
source_name: Some("foobar".to_string()),
scope: Some(vec![fdecl::Ref::Child(fdecl::ChildRef{name:"logger".to_string(), collection: None}), fdecl::Ref::Collection(fdecl::CollectionRef{name:"modular".to_string()})]),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef{})),
target_path: Some("/svc/fuchsia.component.EventStream".to_string()),
availability: Some(fdecl::Availability::Required),
..fdecl::UseEventStream::EMPTY
}),
fdecl::Use::EventStream(fdecl::UseEventStream {
source_name: Some("stream".to_string()),
scope: Some(vec![fdecl::Ref::Child(fdecl::ChildRef{name:"logger".to_string(), collection: None}), fdecl::Ref::Collection(fdecl::CollectionRef{name:"modular".to_string()})]),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef{})),
target_path: Some("/svc/fuchsia.component.EventStream".to_string()),
availability: Some(fdecl::Availability::Required),
..fdecl::UseEventStream::EMPTY
})
]),
collections:Some(vec![
fdecl::Collection{
name:Some("modular".to_string()),
durability:Some(fdecl::Durability::Persistent),
..fdecl::Collection::EMPTY
},
]),
capabilities: Some(vec![
fdecl::Capability::Storage(fdecl::Storage {
name: Some("data-storage".to_string()),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
backing_dir: Some("minfs".to_string()),
subdir: None,
storage_id: Some(fdecl::StorageId::StaticInstanceIdOrMoniker),
..fdecl::Storage::EMPTY
}),
]),
children: Some(vec![
fdecl::Child{
name:Some("logger".to_string()),
url:Some("fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm".to_string()),
startup:Some(fdecl::StartupMode::Lazy),
environment: Some("env_one".to_string()),
..fdecl::Child::EMPTY
}
]),
..default_component_decl()
},
},
test_compile_expose => {
input = json!({
"expose": [
{
"protocol": "fuchsia.logger.Log",
"from": "#logger",
"as": "fuchsia.logger.LegacyLog",
"to": "parent"
},
{
"protocol": [ "A", "B" ],
"from": "self",
"to": "parent"
},
{
"protocol": "C",
"from": "#data-storage",
},
{
"directory": "blob",
"from": "self",
"to": "framework",
"rights": ["r*"],
},
{
"directory": [ "blob2", "blob3" ],
"from": "#logger",
"to": "parent",
},
{ "directory": "hub", "from": "framework" },
{ "runner": "web", "from": "#logger", "to": "parent", "as": "web-rename" },
{ "runner": [ "runner_a", "runner_b" ], "from": "#logger" },
{ "resolver": "my_resolver", "from": "#logger", "to": "parent", "as": "pkg_resolver" },
{ "resolver": [ "resolver_a", "resolver_b" ], "from": "#logger" },
{
"event_stream": ["started", "stopped"],
"from": "#logger",
"to": "parent",
},
{
"event_stream": "running",
"as": "running_stream",
"from": "#logger",
"to": "parent",
},
],
"capabilities": [
{ "protocol": "A" },
{ "protocol": "B" },
{
"directory": "blob",
"path": "/volumes/blobfs/blob",
"rights": ["r*"],
},
{
"runner": "web",
"path": "/svc/fuchsia.component.ComponentRunner",
},
{
"storage": "data-storage",
"from": "parent",
"backing_dir": "minfs",
"storage_id": "static_instance_id_or_moniker",
},
],
"children": [
{
"name": "logger",
"url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm"
},
],
}),
output = fdecl::Component {
exposes: Some(vec![
fdecl::Expose::Protocol (
fdecl::ExposeProtocol {
source: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "logger".to_string(),
collection: None,
})),
source_name: Some("fuchsia.logger.Log".to_string()),
target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target_name: Some("fuchsia.logger.LegacyLog".to_string()),
..fdecl::ExposeProtocol::EMPTY
}
),
fdecl::Expose::Protocol (
fdecl::ExposeProtocol {
source: Some(fdecl::Ref::Self_(fdecl::SelfRef {})),
source_name: Some("A".to_string()),
target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target_name: Some("A".to_string()),
..fdecl::ExposeProtocol::EMPTY
}
),
fdecl::Expose::Protocol (
fdecl::ExposeProtocol {
source: Some(fdecl::Ref::Self_(fdecl::SelfRef {})),
source_name: Some("B".to_string()),
target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target_name: Some("B".to_string()),
..fdecl::ExposeProtocol::EMPTY
}
),
fdecl::Expose::Protocol (
fdecl::ExposeProtocol {
source: Some(fdecl::Ref::Capability(fdecl::CapabilityRef {
name: "data-storage".to_string(),
})),
source_name: Some("C".to_string()),
target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target_name: Some("C".to_string()),
..fdecl::ExposeProtocol::EMPTY
}
),
fdecl::Expose::Directory (
fdecl::ExposeDirectory {
source: Some(fdecl::Ref::Self_(fdecl::SelfRef {})),
source_name: Some("blob".to_string()),
target: Some(fdecl::Ref::Framework(fdecl::FrameworkRef {})),
target_name: Some("blob".to_string()),
rights: Some(
fio::Operations::CONNECT | fio::Operations::ENUMERATE |
fio::Operations::TRAVERSE | fio::Operations::READ_BYTES |
fio::Operations::GET_ATTRIBUTES
),
subdir: None,
..fdecl::ExposeDirectory::EMPTY
}
),
fdecl::Expose::Directory (
fdecl::ExposeDirectory {
source: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "logger".to_string(),
collection: None,
})),
source_name: Some("blob2".to_string()),
target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target_name: Some("blob2".to_string()),
rights: None,
subdir: None,
..fdecl::ExposeDirectory::EMPTY
}
),
fdecl::Expose::Directory (
fdecl::ExposeDirectory {
source: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "logger".to_string(),
collection: None,
})),
source_name: Some("blob3".to_string()),
target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target_name: Some("blob3".to_string()),
rights: None,
subdir: None,
..fdecl::ExposeDirectory::EMPTY
}
),
fdecl::Expose::Directory (
fdecl::ExposeDirectory {
source: Some(fdecl::Ref::Framework(fdecl::FrameworkRef {})),
source_name: Some("hub".to_string()),
target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target_name: Some("hub".to_string()),
rights: None,
subdir: None,
..fdecl::ExposeDirectory::EMPTY
}
),
fdecl::Expose::Runner (
fdecl::ExposeRunner {
source: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "logger".to_string(),
collection: None,
})),
source_name: Some("web".to_string()),
target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target_name: Some("web-rename".to_string()),
..fdecl::ExposeRunner::EMPTY
}
),
fdecl::Expose::Runner (
fdecl::ExposeRunner {
source: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "logger".to_string(),
collection: None,
})),
source_name: Some("runner_a".to_string()),
target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target_name: Some("runner_a".to_string()),
..fdecl::ExposeRunner::EMPTY
}
),
fdecl::Expose::Runner (
fdecl::ExposeRunner {
source: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "logger".to_string(),
collection: None,
})),
source_name: Some("runner_b".to_string()),
target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target_name: Some("runner_b".to_string()),
..fdecl::ExposeRunner::EMPTY
}
),
fdecl::Expose::Resolver (
fdecl::ExposeResolver {
source: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "logger".to_string(),
collection: None,
})),
source_name: Some("my_resolver".to_string()),
target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target_name: Some("pkg_resolver".to_string()),
..fdecl::ExposeResolver::EMPTY
}
),
fdecl::Expose::Resolver (
fdecl::ExposeResolver {
source: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "logger".to_string(),
collection: None,
})),
source_name: Some("resolver_a".to_string()),
target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target_name: Some("resolver_a".to_string()),
..fdecl::ExposeResolver::EMPTY
}
),
fdecl::Expose::Resolver (
fdecl::ExposeResolver {
source: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "logger".to_string(),
collection: None,
})),
source_name: Some("resolver_b".to_string()),
target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target_name: Some("resolver_b".to_string()),
..fdecl::ExposeResolver::EMPTY
}
),
fdecl::Expose::EventStream (
fdecl::ExposeEventStream {
source: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "logger".to_string(),
collection: None,
})),
source_name: Some("started".to_string()),
target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target_name: Some("started".to_string()),
..fdecl::ExposeEventStream::EMPTY
}
),
fdecl::Expose::EventStream (
fdecl::ExposeEventStream {
source: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "logger".to_string(),
collection: None,
})),
source_name: Some("stopped".to_string()),
target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target_name: Some("stopped".to_string()),
..fdecl::ExposeEventStream::EMPTY
}
),
fdecl::Expose::EventStream (
fdecl::ExposeEventStream {
source: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "logger".to_string(),
collection: None,
})),
source_name: Some("running".to_string()),
target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target_name: Some("running_stream".to_string()),
..fdecl::ExposeEventStream::EMPTY
}
),
]),
offers: None,
capabilities: Some(vec![
fdecl::Capability::Protocol (
fdecl::Protocol {
name: Some("A".to_string()),
source_path: Some("/svc/A".to_string()),
..fdecl::Protocol::EMPTY
}
),
fdecl::Capability::Protocol (
fdecl::Protocol {
name: Some("B".to_string()),
source_path: Some("/svc/B".to_string()),
..fdecl::Protocol::EMPTY
}
),
fdecl::Capability::Directory (
fdecl::Directory {
name: Some("blob".to_string()),
source_path: Some("/volumes/blobfs/blob".to_string()),
rights: Some(fio::Operations::CONNECT | fio::Operations::ENUMERATE |
fio::Operations::TRAVERSE | fio::Operations::READ_BYTES |
fio::Operations::GET_ATTRIBUTES
),
..fdecl::Directory::EMPTY
}
),
fdecl::Capability::Runner (
fdecl::Runner {
name: Some("web".to_string()),
source_path: Some("/svc/fuchsia.component.ComponentRunner".to_string()),
..fdecl::Runner::EMPTY
}
),
fdecl::Capability::Storage(fdecl::Storage {
name: Some("data-storage".to_string()),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
backing_dir: Some("minfs".to_string()),
subdir: None,
storage_id: Some(fdecl::StorageId::StaticInstanceIdOrMoniker),
..fdecl::Storage::EMPTY
}),
]),
children: Some(vec![
fdecl::Child {
name: Some("logger".to_string()),
url: Some("fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm".to_string()),
startup: Some(fdecl::StartupMode::Lazy),
environment: None,
on_terminate: None,
..fdecl::Child::EMPTY
}
]),
..default_component_decl()
},
},
test_compile_offer => {
input = json!({
"offer": [
{
"protocol": "fuchsia.logger.LegacyLog",
"from": "#logger",
"to": "#netstack", // Verifies compilation of singleton "to:".
"dependency": "weak"
},
{
"protocol": "fuchsia.logger.LegacyLog",
"from": "#logger",
"to": [ "#modular" ], // Verifies compilation of "to:" as array of one element.
"as": "fuchsia.logger.LegacySysLog",
"dependency": "strong"
},
{
"protocol": "fuchsia.logger.LegacyLog2",
"from": "#non-existent",
"to": [ "#modular" ], // Verifies compilation of "to:" as array of one element.
"as": "fuchsia.logger.LegacySysLog2",
"dependency": "strong",
"availability": "optional",
"source_availability": "unknown"
},
{
"protocol": [
"fuchsia.setui.SetUiService",
"fuchsia.test.service.Name"
],
"from": "parent",
"to": [ "#modular" ],
"availability": "optional"
},
{
"protocol": "fuchsia.sys2.StorageAdmin",
"from": "#data",
"to": [ "#modular" ],
},
{
"directory": "assets",
"from": "parent",
"to": [ "#netstack" ],
"dependency": "weak_for_migration",
"availability": "same_as_target"
},
{
"directory": [ "assets2", "assets3" ],
"from": "parent",
"to": [ "#modular", "#netstack" ],
},
{
"directory": "data",
"from": "parent",
"to": [ "#modular" ],
"as": "assets",
"subdir": "index/file",
"dependency": "strong"
},
{
"directory": "hub",
"from": "framework",
"to": [ "#modular" ],
"as": "hub",
},
{
"storage": "data",
"from": "self",
"to": [
"#netstack",
"#modular"
],
},
{
"storage": [ "storage_a", "storage_b" ],
"from": "parent",
"to": "#netstack",
},
{
"runner": "elf",
"from": "parent",
"to": [ "#modular" ],
"as": "elf-renamed",
},
{
"runner": [ "runner_a", "runner_b" ],
"from": "parent",
"to": "#netstack",
},
{
"event": "destroyed",
"from": "framework",
"to": [ "#netstack"],
"as": "destroyed_net"
},
{
"event": [ "stopped", "started" ],
"from": "parent",
"to": [ "#modular" ],
},
{
"event": "directory_ready",
"from": "parent",
"to": [ "#netstack" ],
"as": "net-ready",
"filter": {
"name": [
"diagnostics",
"foo"
],
}
},
{
"resolver": "my_resolver",
"from": "parent",
"to": [ "#modular" ],
"as": "pkg_resolver",
},
{
"resolver": [ "resolver_a", "resolver_b" ],
"from": "parent",
"to": "#netstack",
},
{
"event_stream": [
"running",
"started",
],
"from": "parent",
"to": "#netstack",
},
{
"event_stream": "stopped",
"from": "parent",
"to": "#netstack",
"as": "some_other_event",
"filter": { "name": "diagnostics" }
},
],
"children": [
{
"name": "logger",
"url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm"
},
{
"name": "netstack",
"url": "fuchsia-pkg://fuchsia.com/netstack/stable#meta/netstack.cm"
},
],
"collections": [
{
"name": "modular",
"durability": "persistent",
},
],
"capabilities": [
{
"storage": "data",
"backing_dir": "minfs",
"from": "#logger",
"storage_id": "static_instance_id_or_moniker",
},
],
}),
output = fdecl::Component {
offers: Some(vec![
fdecl::Offer::Protocol (
fdecl::OfferProtocol {
source: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "logger".to_string(),
collection: None,
})),
source_name: Some("fuchsia.logger.LegacyLog".to_string()),
target: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "netstack".to_string(),
collection: None,
})),
target_name: Some("fuchsia.logger.LegacyLog".to_string()),
dependency_type: Some(fdecl::DependencyType::Weak),
availability: Some(fdecl::Availability::Required),
..fdecl::OfferProtocol::EMPTY
}
),
fdecl::Offer::Protocol (
fdecl::OfferProtocol {
source: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "logger".to_string(),
collection: None,
})),
source_name: Some("fuchsia.logger.LegacyLog".to_string()),
target: Some(fdecl::Ref::Collection(fdecl::CollectionRef {
name: "modular".to_string(),
})),
target_name: Some("fuchsia.logger.LegacySysLog".to_string()),
dependency_type: Some(fdecl::DependencyType::Strong),
availability: Some(fdecl::Availability::Required),
..fdecl::OfferProtocol::EMPTY
}
),
fdecl::Offer::Protocol (
fdecl::OfferProtocol {
source: Some(fdecl::Ref::VoidType(fdecl::VoidRef {})),
source_name: Some("fuchsia.logger.LegacyLog2".to_string()),
target: Some(fdecl::Ref::Collection(fdecl::CollectionRef {
name: "modular".to_string(),
})),
target_name: Some("fuchsia.logger.LegacySysLog2".to_string()),
dependency_type: Some(fdecl::DependencyType::Strong),
availability: Some(fdecl::Availability::Optional),
..fdecl::OfferProtocol::EMPTY
}
),
fdecl::Offer::Protocol (
fdecl::OfferProtocol {
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("fuchsia.setui.SetUiService".to_string()),
target: Some(fdecl::Ref::Collection(fdecl::CollectionRef {
name: "modular".to_string(),
})),
target_name: Some("fuchsia.setui.SetUiService".to_string()),
dependency_type: Some(fdecl::DependencyType::Strong),
availability: Some(fdecl::Availability::Optional),
..fdecl::OfferProtocol::EMPTY
}
),
fdecl::Offer::Protocol (
fdecl::OfferProtocol {
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("fuchsia.test.service.Name".to_string()),
target: Some(fdecl::Ref::Collection(fdecl::CollectionRef {
name: "modular".to_string(),
})),
target_name: Some("fuchsia.test.service.Name".to_string()),
dependency_type: Some(fdecl::DependencyType::Strong),
availability: Some(fdecl::Availability::Optional),
..fdecl::OfferProtocol::EMPTY
}
),
fdecl::Offer::Protocol (
fdecl::OfferProtocol {
source: Some(fdecl::Ref::Capability(fdecl::CapabilityRef {
name: "data".to_string(),
})),
source_name: Some("fuchsia.sys2.StorageAdmin".to_string()),
target: Some(fdecl::Ref::Collection(fdecl::CollectionRef {
name: "modular".to_string(),
})),
target_name: Some("fuchsia.sys2.StorageAdmin".to_string()),
dependency_type: Some(fdecl::DependencyType::Strong),
availability: Some(fdecl::Availability::Required),
..fdecl::OfferProtocol::EMPTY
}
),
fdecl::Offer::Directory (
fdecl::OfferDirectory {
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("assets".to_string()),
target: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "netstack".to_string(),
collection: None,
})),
target_name: Some("assets".to_string()),
rights: None,
subdir: None,
dependency_type: Some(fdecl::DependencyType::WeakForMigration),
availability: Some(fdecl::Availability::SameAsTarget),
..fdecl::OfferDirectory::EMPTY
}
),
fdecl::Offer::Directory (
fdecl::OfferDirectory {
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("assets2".to_string()),
target: Some(fdecl::Ref::Collection(fdecl::CollectionRef {
name: "modular".to_string(),
})),
target_name: Some("assets2".to_string()),
rights: None,
subdir: None,
dependency_type: Some(fdecl::DependencyType::Strong),
availability: Some(fdecl::Availability::Required),
..fdecl::OfferDirectory::EMPTY
}
),
fdecl::Offer::Directory (
fdecl::OfferDirectory {
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("assets3".to_string()),
target: Some(fdecl::Ref::Collection(fdecl::CollectionRef {
name: "modular".to_string(),
})),
target_name: Some("assets3".to_string()),
rights: None,
subdir: None,
dependency_type: Some(fdecl::DependencyType::Strong),
availability: Some(fdecl::Availability::Required),
..fdecl::OfferDirectory::EMPTY
}
),
fdecl::Offer::Directory (
fdecl::OfferDirectory {
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("assets2".to_string()),
target: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "netstack".to_string(),
collection: None,
})),
target_name: Some("assets2".to_string()),
rights: None,
subdir: None,
dependency_type: Some(fdecl::DependencyType::Strong),
availability: Some(fdecl::Availability::Required),
..fdecl::OfferDirectory::EMPTY
}
),
fdecl::Offer::Directory (
fdecl::OfferDirectory {
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("assets3".to_string()),
target: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "netstack".to_string(),
collection: None,
})),
target_name: Some("assets3".to_string()),
rights: None,
subdir: None,
dependency_type: Some(fdecl::DependencyType::Strong),
availability: Some(fdecl::Availability::Required),
..fdecl::OfferDirectory::EMPTY
}
),
fdecl::Offer::Directory (
fdecl::OfferDirectory {
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("data".to_string()),
target: Some(fdecl::Ref::Collection(fdecl::CollectionRef {
name: "modular".to_string(),
})),
target_name: Some("assets".to_string()),
rights: None,
subdir: Some("index/file".to_string()),
dependency_type: Some(fdecl::DependencyType::Strong),
availability: Some(fdecl::Availability::Required),
..fdecl::OfferDirectory::EMPTY
}
),
fdecl::Offer::Directory (
fdecl::OfferDirectory {
source: Some(fdecl::Ref::Framework(fdecl::FrameworkRef {})),
source_name: Some("hub".to_string()),
target: Some(fdecl::Ref::Collection(fdecl::CollectionRef {
name: "modular".to_string(),
})),
target_name: Some("hub".to_string()),
rights: None,
subdir: None,
dependency_type: Some(fdecl::DependencyType::Strong),
availability: Some(fdecl::Availability::Required),
..fdecl::OfferDirectory::EMPTY
}
),
fdecl::Offer::Storage (
fdecl::OfferStorage {
source_name: Some("data".to_string()),
source: Some(fdecl::Ref::Self_(fdecl::SelfRef {})),
target: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "netstack".to_string(),
collection: None,
})),
target_name: Some("data".to_string()),
availability: Some(fdecl::Availability::Required),
..fdecl::OfferStorage::EMPTY
}
),
fdecl::Offer::Storage (
fdecl::OfferStorage {
source_name: Some("data".to_string()),
source: Some(fdecl::Ref::Self_(fdecl::SelfRef {})),
target: Some(fdecl::Ref::Collection(fdecl::CollectionRef {
name: "modular".to_string(),
})),
target_name: Some("data".to_string()),
availability: Some(fdecl::Availability::Required),
..fdecl::OfferStorage::EMPTY
}
),
fdecl::Offer::Storage (
fdecl::OfferStorage {
source_name: Some("storage_a".to_string()),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "netstack".to_string(),
collection: None,
})),
target_name: Some("storage_a".to_string()),
availability: Some(fdecl::Availability::Required),
..fdecl::OfferStorage::EMPTY
}
),
fdecl::Offer::Storage (
fdecl::OfferStorage {
source_name: Some("storage_b".to_string()),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "netstack".to_string(),
collection: None,
})),
target_name: Some("storage_b".to_string()),
availability: Some(fdecl::Availability::Required),
..fdecl::OfferStorage::EMPTY
}
),
fdecl::Offer::Runner (
fdecl::OfferRunner {
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("elf".to_string()),
target: Some(fdecl::Ref::Collection(fdecl::CollectionRef {
name: "modular".to_string(),
})),
target_name: Some("elf-renamed".to_string()),
..fdecl::OfferRunner::EMPTY
}
),
fdecl::Offer::Runner (
fdecl::OfferRunner {
source_name: Some("runner_a".to_string()),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "netstack".to_string(),
collection: None,
})),
target_name: Some("runner_a".to_string()),
..fdecl::OfferRunner::EMPTY
}
),
fdecl::Offer::Runner (
fdecl::OfferRunner {
source_name: Some("runner_b".to_string()),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "netstack".to_string(),
collection: None,
})),
target_name: Some("runner_b".to_string()),
..fdecl::OfferRunner::EMPTY
}
),
fdecl::Offer::Event (
fdecl::OfferEvent {
source: Some(fdecl::Ref::Framework(fdecl::FrameworkRef {})),
source_name: Some("destroyed".to_string()),
target: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "netstack".to_string(),
collection: None,
})),
target_name: Some("destroyed_net".to_string()),
filter: None,
availability: Some(fdecl::Availability::Required),
..fdecl::OfferEvent::EMPTY
}
),
fdecl::Offer::Event (
fdecl::OfferEvent {
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("stopped".to_string()),
target: Some(fdecl::Ref::Collection(fdecl::CollectionRef {
name: "modular".to_string(),
})),
target_name: Some("stopped".to_string()),
filter: None,
availability: Some(fdecl::Availability::Required),
..fdecl::OfferEvent::EMPTY
}
),
fdecl::Offer::Event (
fdecl::OfferEvent {
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("started".to_string()),
target: Some(fdecl::Ref::Collection(fdecl::CollectionRef {
name: "modular".to_string(),
})),
target_name: Some("started".to_string()),
filter: None,
availability: Some(fdecl::Availability::Required),
..fdecl::OfferEvent::EMPTY
}
),
fdecl::Offer::Event (
fdecl::OfferEvent {
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("directory_ready".to_string()),
target: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "netstack".to_string(),
collection: None,
})),
target_name: Some("net-ready".to_string()),
filter: Some(fdata::Dictionary {
entries: Some(vec![
fdata::DictionaryEntry {
key: "name".to_string(),
value: Some(Box::new(fdata::DictionaryValue::StrVec(
vec!["diagnostics".to_string(), "foo".to_string()]
))),
},
]),
..fdata::Dictionary::EMPTY
}),
availability: Some(fdecl::Availability::Required),
..fdecl::OfferEvent::EMPTY
}
),
fdecl::Offer::Resolver (
fdecl::OfferResolver {
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("my_resolver".to_string()),
target: Some(fdecl::Ref::Collection(fdecl::CollectionRef {
name: "modular".to_string(),
})),
target_name: Some("pkg_resolver".to_string()),
..fdecl::OfferResolver::EMPTY
}
),
fdecl::Offer::Resolver (
fdecl::OfferResolver {
source_name: Some("resolver_a".to_string()),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "netstack".to_string(),
collection: None,
})),
target_name: Some("resolver_a".to_string()),
..fdecl::OfferResolver::EMPTY
}
),
fdecl::Offer::Resolver (
fdecl::OfferResolver {
source_name: Some("resolver_b".to_string()),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "netstack".to_string(),
collection: None,
})),
target_name: Some("resolver_b".to_string()),
..fdecl::OfferResolver::EMPTY
}
),
fdecl::Offer::EventStream (
fdecl::OfferEventStream {
source_name: Some("running".to_string()),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "netstack".to_string(),
collection: None,
})),
target_name: Some("running".to_string()),
availability: Some(fdecl::Availability::Required),
..fdecl::OfferEventStream::EMPTY
}
),
fdecl::Offer::EventStream (
fdecl::OfferEventStream {
source_name: Some("started".to_string()),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "netstack".to_string(),
collection: None,
})),
target_name: Some("started".to_string()),
availability: Some(fdecl::Availability::Required),
..fdecl::OfferEventStream::EMPTY
}
),
fdecl::Offer::EventStream (
fdecl::OfferEventStream {
source_name: Some("stopped".to_string()),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "netstack".to_string(),
collection: None,
})),
filter: Some(fdata::Dictionary {
entries: Some(vec![
fdata::DictionaryEntry {
key: "name".to_string(),
value: Some(
Box::new(
fdata::DictionaryValue::Str(
"diagnostics".to_string()
)
)
),
},
]),
..fdata::Dictionary::EMPTY
}),
target_name: Some("some_other_event".to_string()),
availability: Some(fdecl::Availability::Required),
..fdecl::OfferEventStream::EMPTY
}
),
]),
capabilities: Some(vec![
fdecl::Capability::Storage (
fdecl::Storage {
name: Some("data".to_string()),
source: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "logger".to_string(),
collection: None,
})),
backing_dir: Some("minfs".to_string()),
subdir: None,
storage_id: Some(fdecl::StorageId::StaticInstanceIdOrMoniker),
..fdecl::Storage::EMPTY
}
)
]),
children: Some(vec![
fdecl::Child {
name: Some("logger".to_string()),
url: Some("fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm".to_string()),
startup: Some(fdecl::StartupMode::Lazy),
environment: None,
on_terminate: None,
..fdecl::Child::EMPTY
},
fdecl::Child {
name: Some("netstack".to_string()),
url: Some("fuchsia-pkg://fuchsia.com/netstack/stable#meta/netstack.cm".to_string()),
startup: Some(fdecl::StartupMode::Lazy),
environment: None,
on_terminate: None,
..fdecl::Child::EMPTY
},
]),
collections: Some(vec![
fdecl::Collection {
name: Some("modular".to_string()),
durability: Some(fdecl::Durability::Persistent),
environment: None,
allowed_offers: None,
..fdecl::Collection::EMPTY
}
]),
..default_component_decl()
},
},
test_compile_children => {
input = json!({
"children": [
{
"name": "logger",
"url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm",
},
{
"name": "gmail",
"url": "https://www.google.com/gmail",
"startup": "eager",
},
{
"name": "echo",
"url": "fuchsia-pkg://fuchsia.com/echo/stable#meta/echo.cm",
"startup": "lazy",
"on_terminate": "reboot",
"environment": "#myenv",
},
],
"environments": [
{
"name": "myenv",
"extends": "realm",
},
],
}),
output = fdecl::Component {
children: Some(vec![
fdecl::Child {
name: Some("logger".to_string()),
url: Some("fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm".to_string()),
startup: Some(fdecl::StartupMode::Lazy),
environment: None,
on_terminate: None,
..fdecl::Child::EMPTY
},
fdecl::Child {
name: Some("gmail".to_string()),
url: Some("https://www.google.com/gmail".to_string()),
startup: Some(fdecl::StartupMode::Eager),
environment: None,
on_terminate: None,
..fdecl::Child::EMPTY
},
fdecl::Child {
name: Some("echo".to_string()),
url: Some("fuchsia-pkg://fuchsia.com/echo/stable#meta/echo.cm".to_string()),
startup: Some(fdecl::StartupMode::Lazy),
environment: Some("myenv".to_string()),
on_terminate: Some(fdecl::OnTerminate::Reboot),
..fdecl::Child::EMPTY
}
]),
environments: Some(vec![
fdecl::Environment {
name: Some("myenv".to_string()),
extends: Some(fdecl::EnvironmentExtends::Realm),
runners: None,
resolvers: None,
stop_timeout_ms: None,
..fdecl::Environment::EMPTY
}
]),
..default_component_decl()
},
},
test_compile_collections => {
input = json!({
"collections": [
{
"name": "modular",
"durability": "persistent",
},
{
"name": "tests",
"durability": "transient",
"environment": "#myenv",
},
],
"environments": [
{
"name": "myenv",
"extends": "realm",
}
],
}),
output = fdecl::Component {
collections: Some(vec![
fdecl::Collection {
name: Some("modular".to_string()),
durability: Some(fdecl::Durability::Persistent),
environment: None,
allowed_offers: None,
..fdecl::Collection::EMPTY
},
fdecl::Collection {
name: Some("tests".to_string()),
durability: Some(fdecl::Durability::Transient),
environment: Some("myenv".to_string()),
allowed_offers: None,
..fdecl::Collection::EMPTY
}
]),
environments: Some(vec![
fdecl::Environment {
name: Some("myenv".to_string()),
extends: Some(fdecl::EnvironmentExtends::Realm),
runners: None,
resolvers: None,
stop_timeout_ms: None,
..fdecl::Environment::EMPTY
}
]),
..default_component_decl()
},
},
test_compile_capabilities => {
input = json!({
"capabilities": [
{
"protocol": "myprotocol",
"path": "/protocol",
},
{
"protocol": "myprotocol2",
},
{
"protocol": [ "myprotocol3", "myprotocol4" ],
},
{
"directory": "mydirectory",
"path": "/directory",
"rights": [ "connect" ],
},
{
"storage": "mystorage",
"backing_dir": "storage",
"from": "#minfs",
"storage_id": "static_instance_id_or_moniker",
},
{
"storage": "mystorage2",
"backing_dir": "storage2",
"from": "#minfs",
"storage_id": "static_instance_id",
},
{
"runner": "myrunner",
"path": "/runner",
},
{
"resolver": "myresolver",
"path": "/resolver"
},
],
"children": [
{
"name": "minfs",
"url": "fuchsia-pkg://fuchsia.com/minfs/stable#meta/minfs.cm",
},
]
}),
output = fdecl::Component {
capabilities: Some(vec![
fdecl::Capability::Protocol (
fdecl::Protocol {
name: Some("myprotocol".to_string()),
source_path: Some("/protocol".to_string()),
..fdecl::Protocol::EMPTY
}
),
fdecl::Capability::Protocol (
fdecl::Protocol {
name: Some("myprotocol2".to_string()),
source_path: Some("/svc/myprotocol2".to_string()),
..fdecl::Protocol::EMPTY
}
),
fdecl::Capability::Protocol (
fdecl::Protocol {
name: Some("myprotocol3".to_string()),
source_path: Some("/svc/myprotocol3".to_string()),
..fdecl::Protocol::EMPTY
}
),
fdecl::Capability::Protocol (
fdecl::Protocol {
name: Some("myprotocol4".to_string()),
source_path: Some("/svc/myprotocol4".to_string()),
..fdecl::Protocol::EMPTY
}
),
fdecl::Capability::Directory (
fdecl::Directory {
name: Some("mydirectory".to_string()),
source_path: Some("/directory".to_string()),
rights: Some(fio::Operations::CONNECT),
..fdecl::Directory::EMPTY
}
),
fdecl::Capability::Storage (
fdecl::Storage {
name: Some("mystorage".to_string()),
source: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "minfs".to_string(),
collection: None,
})),
backing_dir: Some("storage".to_string()),
subdir: None,
storage_id: Some(fdecl::StorageId::StaticInstanceIdOrMoniker),
..fdecl::Storage::EMPTY
}
),
fdecl::Capability::Storage (
fdecl::Storage {
name: Some("mystorage2".to_string()),
source: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "minfs".to_string(),
collection: None,
})),
backing_dir: Some("storage2".to_string()),
subdir: None,
storage_id: Some(fdecl::StorageId::StaticInstanceId),
..fdecl::Storage::EMPTY
}
),
fdecl::Capability::Runner (
fdecl::Runner {
name: Some("myrunner".to_string()),
source_path: Some("/runner".to_string()),
..fdecl::Runner::EMPTY
}
),
fdecl::Capability::Resolver (
fdecl::Resolver {
name: Some("myresolver".to_string()),
source_path: Some("/resolver".to_string()),
..fdecl::Resolver::EMPTY
}
)
]),
children: Some(vec![
fdecl::Child {
name: Some("minfs".to_string()),
url: Some("fuchsia-pkg://fuchsia.com/minfs/stable#meta/minfs.cm".to_string()),
startup: Some(fdecl::StartupMode::Lazy),
environment: None,
on_terminate: None,
..fdecl::Child::EMPTY
}
]),
..default_component_decl()
},
},
test_compile_facets => {
input = json!({
"facets": {
"title": "foo",
"authors": [ "me", "you" ],
"year": "2018",
"metadata": {
"publisher": "The Books Publisher",
}
}
}),
output = fdecl::Component {
facets: Some(fdata::Dictionary {
entries: Some(vec![
fdata::DictionaryEntry {
key: "authors".to_string(),
value: Some(Box::new(fdata::DictionaryValue::StrVec(vec!["me".to_owned(), "you".to_owned()]))),
},
fdata::DictionaryEntry {
key: "metadata.publisher".to_string(),
value: Some(Box::new(fdata::DictionaryValue::Str("The Books Publisher".to_string()))),
},
fdata::DictionaryEntry {
key: "title".to_string(),
value: Some(Box::new(fdata::DictionaryValue::Str("foo".to_string()))),
},
fdata::DictionaryEntry {
key: "year".to_string(),
value: Some(Box::new(fdata::DictionaryValue::Str("2018".to_string()))),
},
]),
..fdata::Dictionary::EMPTY
}
),
..default_component_decl()
},
},
test_compile_environment => {
input = json!({
"environments": [
{
"name": "myenv",
},
{
"name": "myenv2",
"extends": "realm",
},
{
"name": "myenv3",
"extends": "none",
"__stop_timeout_ms": 8000u32,
}
],
}),
output = fdecl::Component {
environments: Some(vec![
fdecl::Environment {
name: Some("myenv".to_string()),
extends: Some(fdecl::EnvironmentExtends::None),
runners: None,
resolvers: None,
stop_timeout_ms: None,
..fdecl::Environment::EMPTY
},
fdecl::Environment {
name: Some("myenv2".to_string()),
extends: Some(fdecl::EnvironmentExtends::Realm),
runners: None,
resolvers: None,
stop_timeout_ms: None,
..fdecl::Environment::EMPTY
},
fdecl::Environment {
name: Some("myenv3".to_string()),
extends: Some(fdecl::EnvironmentExtends::None),
runners: None,
resolvers: None,
stop_timeout_ms: Some(8000),
..fdecl::Environment::EMPTY
},
]),
..default_component_decl()
},
},
test_compile_environment_with_runner_and_resolver => {
input = json!({
"environments": [
{
"name": "myenv",
"runners": [
{
"runner": "dart",
"from": "parent",
}
],
"resolvers": [
{
"resolver": "pkg_resolver",
"from": "parent",
"scheme": "fuchsia-pkg",
}
],
},
],
}),
output = fdecl::Component {
environments: Some(vec![
fdecl::Environment {
name: Some("myenv".to_string()),
extends: Some(fdecl::EnvironmentExtends::None),
runners: Some(vec![
fdecl::RunnerRegistration {
source_name: Some("dart".to_string()),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target_name: Some("dart".to_string()),
..fdecl::RunnerRegistration::EMPTY
}
]),
resolvers: Some(vec![
fdecl::ResolverRegistration {
resolver: Some("pkg_resolver".to_string()),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
scheme: Some("fuchsia-pkg".to_string()),
..fdecl::ResolverRegistration::EMPTY
}
]),
stop_timeout_ms: None,
..fdecl::Environment::EMPTY
},
]),
..default_component_decl()
},
},
test_compile_environment_with_runner_alias => {
input = json!({
"environments": [
{
"name": "myenv",
"runners": [
{
"runner": "dart",
"from": "parent",
"as": "my-dart",
}
],
},
],
}),
output = fdecl::Component {
environments: Some(vec![
fdecl::Environment {
name: Some("myenv".to_string()),
extends: Some(fdecl::EnvironmentExtends::None),
runners: Some(vec![
fdecl::RunnerRegistration {
source_name: Some("dart".to_string()),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target_name: Some("my-dart".to_string()),
..fdecl::RunnerRegistration::EMPTY
}
]),
resolvers: None,
stop_timeout_ms: None,
..fdecl::Environment::EMPTY
},
]),
..default_component_decl()
},
},
test_compile_environment_with_debug => {
input = json!({
"capabilities": [
{
"protocol": "fuchsia.serve.service",
},
],
"environments": [
{
"name": "myenv",
"debug": [
{
"protocol": "fuchsia.serve.service",
"from": "self",
"as": "my-service",
}
],
},
],
}),
output = fdecl::Component {
capabilities: Some(vec![
fdecl::Capability::Protocol(
fdecl::Protocol {
name : Some("fuchsia.serve.service".to_owned()),
source_path: Some("/svc/fuchsia.serve.service".to_owned()),
..fdecl::Protocol::EMPTY
}
)
]),
environments: Some(vec![
fdecl::Environment {
name: Some("myenv".to_string()),
extends: Some(fdecl::EnvironmentExtends::None),
debug_capabilities: Some(vec![
fdecl::DebugRegistration::Protocol( fdecl::DebugProtocolRegistration {
source_name: Some("fuchsia.serve.service".to_string()),
source: Some(fdecl::Ref::Self_(fdecl::SelfRef {})),
target_name: Some("my-service".to_string()),
..fdecl::DebugProtocolRegistration::EMPTY
}),
]),
resolvers: None,
runners: None,
stop_timeout_ms: None,
..fdecl::Environment::EMPTY
},
]),
..default_component_decl()
},
},
test_compile_all_sections => {
input = json!({
"program": {
"runner": "elf",
"binary": "bin/app",
},
"use": [
{ "protocol": "LegacyCoolFonts", "path": "/svc/fuchsia.fonts.LegacyProvider" },
{ "protocol": [ "ReallyGoodFonts", "IWouldNeverUseTheseFonts"]},
{ "protocol": "DebugProtocol", "from": "debug"},
],
"expose": [
{ "directory": "blobfs", "from": "self", "rights": ["r*"]},
],
"offer": [
{
"protocol": "fuchsia.logger.LegacyLog",
"from": "#logger",
"to": [ "#netstack", "#modular" ],
"dependency": "weak"
},
],
"children": [
{
"name": "logger",
"url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm",
},
{
"name": "netstack",
"url": "fuchsia-pkg://fuchsia.com/netstack/stable#meta/netstack.cm",
},
],
"collections": [
{
"name": "modular",
"durability": "persistent",
},
],
"capabilities": [
{
"directory": "blobfs",
"path": "/volumes/blobfs",
"rights": [ "r*" ],
},
{
"runner": "myrunner",
"path": "/runner",
},
{
"protocol": "fuchsia.serve.service",
}
],
"facets": {
"author": "Fuchsia",
"year": "2018",
},
"environments": [
{
"name": "myenv",
"extends": "realm",
"debug": [
{
"protocol": "fuchsia.serve.service",
"from": "self",
"as": "my-service",
},
{
"protocol": "fuchsia.logger.LegacyLog",
"from": "#logger",
}
]
}
],
}),
output = fdecl::Component {
program: Some(fdecl::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/app".to_string()))),
}]),
..fdata::Dictionary::EMPTY
}),
..fdecl::Program::EMPTY
}),
uses: Some(vec![
fdecl::Use::Protocol (
fdecl::UseProtocol {
dependency_type: Some(fdecl::DependencyType::Strong),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("LegacyCoolFonts".to_string()),
target_path: Some("/svc/fuchsia.fonts.LegacyProvider".to_string()),
availability: Some(fdecl::Availability::Required),
..fdecl::UseProtocol::EMPTY
}
),
fdecl::Use::Protocol (
fdecl::UseProtocol {
dependency_type: Some(fdecl::DependencyType::Strong),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("ReallyGoodFonts".to_string()),
target_path: Some("/svc/ReallyGoodFonts".to_string()),
availability: Some(fdecl::Availability::Required),
..fdecl::UseProtocol::EMPTY
}
),
fdecl::Use::Protocol (
fdecl::UseProtocol {
dependency_type: Some(fdecl::DependencyType::Strong),
source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
source_name: Some("IWouldNeverUseTheseFonts".to_string()),
target_path: Some("/svc/IWouldNeverUseTheseFonts".to_string()),
availability: Some(fdecl::Availability::Required),
..fdecl::UseProtocol::EMPTY
}
),
fdecl::Use::Protocol (
fdecl::UseProtocol {
dependency_type: Some(fdecl::DependencyType::Strong),
source: Some(fdecl::Ref::Debug(fdecl::DebugRef {})),
source_name: Some("DebugProtocol".to_string()),
target_path: Some("/svc/DebugProtocol".to_string()),
availability: Some(fdecl::Availability::Required),
..fdecl::UseProtocol::EMPTY
}
),
]),
exposes: Some(vec![
fdecl::Expose::Directory (
fdecl::ExposeDirectory {
source: Some(fdecl::Ref::Self_(fdecl::SelfRef {})),
source_name: Some("blobfs".to_string()),
target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
target_name: Some("blobfs".to_string()),
rights: Some(
fio::Operations::CONNECT | fio::Operations::ENUMERATE |
fio::Operations::TRAVERSE | fio::Operations::READ_BYTES |
fio::Operations::GET_ATTRIBUTES
),
subdir: None,
..fdecl::ExposeDirectory::EMPTY
}
),
]),
offers: Some(vec![
fdecl::Offer::Protocol (
fdecl::OfferProtocol {
source: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "logger".to_string(),
collection: None,
})),
source_name: Some("fuchsia.logger.LegacyLog".to_string()),
target: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "netstack".to_string(),
collection: None,
})),
target_name: Some("fuchsia.logger.LegacyLog".to_string()),
dependency_type: Some(fdecl::DependencyType::Weak),
availability: Some(fdecl::Availability::Required),
..fdecl::OfferProtocol::EMPTY
}
),
fdecl::Offer::Protocol (
fdecl::OfferProtocol {
source: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "logger".to_string(),
collection: None,
})),
source_name: Some("fuchsia.logger.LegacyLog".to_string()),
target: Some(fdecl::Ref::Collection(fdecl::CollectionRef {
name: "modular".to_string(),
})),
target_name: Some("fuchsia.logger.LegacyLog".to_string()),
dependency_type: Some(fdecl::DependencyType::Weak),
availability: Some(fdecl::Availability::Required),
..fdecl::OfferProtocol::EMPTY
}
),
]),
capabilities: Some(vec![
fdecl::Capability::Directory (
fdecl::Directory {
name: Some("blobfs".to_string()),
source_path: Some("/volumes/blobfs".to_string()),
rights: Some(fio::Operations::CONNECT | fio::Operations::ENUMERATE |
fio::Operations::TRAVERSE | fio::Operations::READ_BYTES |
fio::Operations::GET_ATTRIBUTES
),
..fdecl::Directory::EMPTY
}
),
fdecl::Capability::Runner (
fdecl::Runner {
name: Some("myrunner".to_string()),
source_path: Some("/runner".to_string()),
..fdecl::Runner::EMPTY
}
),
fdecl::Capability::Protocol(
fdecl::Protocol {
name : Some("fuchsia.serve.service".to_owned()),
source_path: Some("/svc/fuchsia.serve.service".to_owned()),
..fdecl::Protocol::EMPTY
}
)
]),
children: Some(vec![
fdecl::Child {
name: Some("logger".to_string()),
url: Some("fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm".to_string()),
startup: Some(fdecl::StartupMode::Lazy),
environment: None,
on_terminate: None,
..fdecl::Child::EMPTY
},
fdecl::Child {
name: Some("netstack".to_string()),
url: Some("fuchsia-pkg://fuchsia.com/netstack/stable#meta/netstack.cm".to_string()),
startup: Some(fdecl::StartupMode::Lazy),
environment: None,
on_terminate: None,
..fdecl::Child::EMPTY
},
]),
collections: Some(vec![
fdecl::Collection {
name: Some("modular".to_string()),
durability: Some(fdecl::Durability::Persistent),
environment: None,
allowed_offers: None,
..fdecl::Collection::EMPTY
}
]),
environments: Some(vec![
fdecl::Environment {
name: Some("myenv".to_string()),
extends: Some(fdecl::EnvironmentExtends::Realm),
runners: None,
resolvers: None,
stop_timeout_ms: None,
debug_capabilities: Some(vec![
fdecl::DebugRegistration::Protocol( fdecl::DebugProtocolRegistration {
source_name: Some("fuchsia.serve.service".to_string()),
source: Some(fdecl::Ref::Self_(fdecl::SelfRef {})),
target_name: Some("my-service".to_string()),
..fdecl::DebugProtocolRegistration::EMPTY
}),
fdecl::DebugRegistration::Protocol( fdecl::DebugProtocolRegistration {
source_name: Some("fuchsia.logger.LegacyLog".to_string()),
source: Some(fdecl::Ref::Child(fdecl::ChildRef {
name: "logger".to_string(),
collection: None,
})),
target_name: Some("fuchsia.logger.LegacyLog".to_string()),
..fdecl::DebugProtocolRegistration::EMPTY
}),
]),
..fdecl::Environment::EMPTY
}
]),
facets: Some(fdata::Dictionary {
entries: Some(vec![
fdata::DictionaryEntry {
key: "author".to_string(),
value: Some(Box::new(fdata::DictionaryValue::Str("Fuchsia".to_string()))),
},
fdata::DictionaryEntry {
key: "year".to_string(),
value: Some(Box::new(fdata::DictionaryValue::Str("2018".to_string()))),
},
]),
..fdata::Dictionary::EMPTY
}),
..fdecl::Component::EMPTY
},
},
}
}