routing/bedrock/
program_output_dict.rs

1// Copyright 2023 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::bedrock::with_policy_check::WithPolicyCheck;
6use crate::capability_source::{CapabilitySource, ComponentCapability, ComponentSource};
7use crate::component_instance::{ComponentInstanceInterface, WeakComponentInstanceInterface};
8use crate::DictExt;
9use async_trait::async_trait;
10use cm_rust::NativeIntoFidl;
11use cm_types::Path;
12use log::warn;
13use router_error::RouterError;
14use sandbox::{Connector, Data, Dict, DirEntry, Request, Routable, Router, RouterResponse};
15use std::sync::Arc;
16
17pub trait ProgramOutputGenerator<C: ComponentInstanceInterface + 'static> {
18    /// Get a router for [Dict] that forwards the request to a [Router] served at `path`
19    /// in the program's outgoing directory.
20    fn new_program_dictionary_router(
21        &self,
22        component: WeakComponentInstanceInterface<C>,
23        path: Path,
24        capability: ComponentCapability,
25    ) -> Router<Dict>;
26
27    /// Get an outgoing directory router for `capability` that returns [Connector]. `capability`
28    /// should be a type that maps to [Connector].
29    fn new_outgoing_dir_connector_router(
30        &self,
31        component: &Arc<C>,
32        decl: &cm_rust::ComponentDecl,
33        capability: &cm_rust::CapabilityDecl,
34    ) -> Router<Connector>;
35
36    /// Get an outgoing directory router for `capability` that returns [DirEntry]. `capability`
37    /// should be a type that maps to [DirEntry].
38    fn new_outgoing_dir_dir_entry_router(
39        &self,
40        component: &Arc<C>,
41        decl: &cm_rust::ComponentDecl,
42        capability: &cm_rust::CapabilityDecl,
43    ) -> Router<DirEntry>;
44}
45
46pub fn build_program_output_dictionary<C: ComponentInstanceInterface + 'static>(
47    component: &Arc<C>,
48    decl: &cm_rust::ComponentDecl,
49    router_gen: &impl ProgramOutputGenerator<C>,
50) -> (Dict, Dict) {
51    let program_output_dict = Dict::new();
52    let declared_dictionaries = Dict::new();
53    for capability in &decl.capabilities {
54        extend_dict_with_capability(
55            component,
56            decl,
57            capability,
58            &program_output_dict,
59            &declared_dictionaries,
60            router_gen,
61        );
62    }
63    (program_output_dict, declared_dictionaries)
64}
65
66/// Adds `capability` to the program output dict given the resolved `decl`. The program output dict
67/// is a dict of routers, keyed by capability name.
68fn extend_dict_with_capability<C: ComponentInstanceInterface + 'static>(
69    component: &Arc<C>,
70    decl: &cm_rust::ComponentDecl,
71    capability: &cm_rust::CapabilityDecl,
72    program_output_dict: &Dict,
73    declared_dictionaries: &Dict,
74    router_gen: &impl ProgramOutputGenerator<C>,
75) {
76    match capability {
77        cm_rust::CapabilityDecl::Service(_) | cm_rust::CapabilityDecl::Directory(_) => {
78            let router = router_gen.new_outgoing_dir_dir_entry_router(component, decl, capability);
79            let router = router.with_policy_check::<C>(
80                CapabilitySource::Component(ComponentSource {
81                    capability: ComponentCapability::from(capability.clone()),
82                    moniker: component.moniker().clone(),
83                }),
84                component.policy_checker().clone(),
85            );
86            match program_output_dict.insert_capability(capability.name(), router.into()) {
87                Ok(()) => (),
88                Err(e) => {
89                    warn!("failed to add {} to program output dict: {e:?}", capability.name())
90                }
91            }
92        }
93        cm_rust::CapabilityDecl::Protocol(_)
94        | cm_rust::CapabilityDecl::Runner(_)
95        | cm_rust::CapabilityDecl::Resolver(_) => {
96            let router = router_gen.new_outgoing_dir_connector_router(component, decl, capability);
97            let router = router.with_policy_check::<C>(
98                CapabilitySource::Component(ComponentSource {
99                    capability: ComponentCapability::from(capability.clone()),
100                    moniker: component.moniker().clone(),
101                }),
102                component.policy_checker().clone(),
103            );
104            match program_output_dict.insert_capability(capability.name(), router.into()) {
105                Ok(()) => (),
106                Err(e) => {
107                    warn!("failed to add {} to program output dict: {e:?}", capability.name())
108                }
109            }
110        }
111        cm_rust::CapabilityDecl::Dictionary(d) => {
112            extend_dict_with_dictionary(
113                component,
114                d,
115                program_output_dict,
116                declared_dictionaries,
117                router_gen,
118            );
119        }
120        cm_rust::CapabilityDecl::Config(c) => {
121            let data =
122                sandbox::Data::Bytes(fidl::persist(&c.value.clone().native_into_fidl()).unwrap());
123            match program_output_dict
124                .insert_capability(capability.name(), Router::<Data>::new_ok(data).into())
125            {
126                Ok(()) => (),
127                Err(e) => {
128                    warn!("failed to add {} to program output dict: {e:?}", capability.name())
129                }
130            }
131        }
132        cm_rust::CapabilityDecl::EventStream(_) | cm_rust::CapabilityDecl::Storage(_) => {
133            // Capabilities not supported in bedrock program output dict yet.
134            return;
135        }
136    }
137}
138
139fn extend_dict_with_dictionary<C: ComponentInstanceInterface + 'static>(
140    component: &Arc<C>,
141    decl: &cm_rust::DictionaryDecl,
142    program_output_dict: &Dict,
143    declared_dictionaries: &Dict,
144    router_gen: &impl ProgramOutputGenerator<C>,
145) {
146    let router;
147    let declared_dict;
148    if let Some(source_path) = decl.source_path.as_ref() {
149        // Dictionary backed by program's outgoing directory.
150        router = router_gen.new_program_dictionary_router(
151            component.as_weak(),
152            source_path.clone(),
153            ComponentCapability::Dictionary(decl.clone()),
154        );
155        declared_dict = None;
156    } else {
157        let dict = Dict::new();
158        router = make_simple_dict_router(dict.clone(), component, decl);
159        declared_dict = Some(dict);
160    }
161    if let Some(dict) = declared_dict {
162        match declared_dictionaries.insert_capability(&decl.name, dict.into()) {
163            Ok(()) => (),
164            Err(e) => warn!("failed to add {} to declared dicts: {e:?}", decl.name),
165        };
166    }
167    match program_output_dict.insert_capability(&decl.name, router.into()) {
168        Ok(()) => (),
169        Err(e) => warn!("failed to add {} to program output dict: {e:?}", decl.name),
170    }
171}
172
173/// Makes a router that always returns the given dictionary.
174fn make_simple_dict_router<C: ComponentInstanceInterface + 'static>(
175    dict: Dict,
176    component: &Arc<C>,
177    decl: &cm_rust::DictionaryDecl,
178) -> Router<Dict> {
179    struct DictRouter {
180        dict: Dict,
181        source: CapabilitySource,
182    }
183    #[async_trait]
184    impl Routable<Dict> for DictRouter {
185        async fn route(
186            &self,
187            _request: Option<Request>,
188            debug: bool,
189        ) -> Result<RouterResponse<Dict>, RouterError> {
190            if debug {
191                Ok(RouterResponse::Debug(
192                    self.source
193                        .clone()
194                        .try_into()
195                        .expect("failed to convert capability source to dictionary"),
196                ))
197            } else {
198                Ok(RouterResponse::Capability(self.dict.clone().into()))
199            }
200        }
201    }
202    let source = CapabilitySource::Component(ComponentSource {
203        capability: ComponentCapability::Dictionary(decl.clone()),
204        moniker: component.moniker().clone(),
205    });
206    Router::<Dict>::new(DictRouter { dict, source })
207}
routing/bedrock/program_output_dict.rs

routing/bedrock/
program_output_dict.rs
