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::structured_dict::ComponentInput;
6use crate::bedrock::with_policy_check::WithPolicyCheck;
7use crate::component_instance::{
8    ComponentInstanceInterface, ExtendedInstanceInterface, WeakComponentInstanceInterface,
9    WeakExtendedInstanceInterface,
10};
11use crate::error::RoutingError;
12use crate::{DictExt, LazyGet, WeakInstanceTokenExt};
13use async_trait::async_trait;
14use capability_source::{CapabilitySource, ComponentCapability, ComponentSource};
15use cm_rust::{CapabilityTypeName, NativeIntoFidl};
16use cm_types::{Path, RelativePath};
17use component_id_index::InstanceId;
18use fidl_fuchsia_component_decl as fdecl;
19use fidl_fuchsia_component_runtime::RouteRequest;
20use fidl_fuchsia_io as fio;
21use moniker::{ChildName, ExtendedMoniker, Moniker};
22use router_error::RouterError;
23use runtime_capabilities::{
24    Capability, Connector, Data, Dictionary, DirConnector, Routable, Router, WeakInstanceToken,
25};
26use std::collections::HashMap;
27use std::marker::PhantomData;
28use std::path::PathBuf;
29use std::sync::Arc;
30
31pub trait ProgramOutputGenerator<C: ComponentInstanceInterface + 'static> {
32    /// Get a router for [Dictionary] that forwards the request to a [Router] served at `path`
33    /// in the program's outgoing directory.
34    fn new_program_dictionary_router(
35        &self,
36        component: WeakComponentInstanceInterface<C>,
37        path: Path,
38        capability: ComponentCapability,
39    ) -> Arc<Router<Dictionary>>;
40
41    /// Get an outgoing directory router for `capability` that returns [Connector]. `capability`
42    /// should be a type that maps to [Connector].
43    fn new_outgoing_dir_connector_router(
44        &self,
45        component: &Arc<C>,
46        decl: &cm_rust::ComponentDecl,
47        capability: &cm_rust::CapabilityDecl,
48    ) -> Arc<Router<Connector>>;
49
50    /// Get an outgoing directory router for `capability` that returns [DirConnector]. `capability`
51    /// should be a type that maps to [DirConnector].
52    fn new_outgoing_dir_dir_connector_router(
53        &self,
54        component: &Arc<C>,
55        decl: &cm_rust::ComponentDecl,
56        capability: &cm_rust::CapabilityDecl,
57    ) -> Arc<Router<DirConnector>>;
58}
59
60pub fn build_program_output_dictionary<C: ComponentInstanceInterface + 'static>(
61    component: &Arc<C>,
62    decl: &cm_rust::ComponentDecl,
63    component_input: &ComponentInput,
64    child_outgoing_dictionary_routers: &HashMap<ChildName, Arc<Router<Dictionary>>>,
65    router_gen: &impl ProgramOutputGenerator<C>,
66) -> (Arc<Dictionary>, Arc<Dictionary>) {
67    let program_output_dict = Dictionary::new();
68    let declared_dictionaries = Dictionary::new();
69    for capability in &decl.capabilities {
70        extend_dict_with_capability(
71            component,
72            decl,
73            capability,
74            &program_output_dict,
75            &declared_dictionaries,
76            component_input,
77            child_outgoing_dictionary_routers,
78            router_gen,
79        );
80    }
81    (program_output_dict, declared_dictionaries)
82}
83
84/// Adds `capability` to the program output dict given the resolved `decl`. The program output dict
85/// is a dict of routers, keyed by capability name.
86fn extend_dict_with_capability<C: ComponentInstanceInterface + 'static>(
87    component: &Arc<C>,
88    decl: &cm_rust::ComponentDecl,
89    capability: &cm_rust::CapabilityDecl,
90    program_output_dict: &Arc<Dictionary>,
91    declared_dictionaries: &Arc<Dictionary>,
92    component_input: &ComponentInput,
93    child_outgoing_dictionary_routers: &HashMap<ChildName, Arc<Router<Dictionary>>>,
94    router_gen: &impl ProgramOutputGenerator<C>,
95) {
96    match capability {
97        cm_rust::CapabilityDecl::Service(_) => {
98            let router =
99                router_gen.new_outgoing_dir_dir_connector_router(component, decl, capability);
100            let router = router.with_policy_check::<C>(
101                CapabilitySource::Component(ComponentSource {
102                    capability: ComponentCapability::from(capability.clone()),
103                    moniker: component.moniker().clone(),
104                }),
105                component.policy_checker().clone(),
106            );
107            let prev = program_output_dict
108                .insert_capability(capability.name(), Capability::DirConnectorRouter(router));
109            assert!(prev.is_none(), "failed to insert {}: preexisting value", capability.name());
110        }
111        cm_rust::CapabilityDecl::Directory(_) => {
112            let router =
113                router_gen.new_outgoing_dir_dir_connector_router(component, decl, capability);
114            let router = router.with_policy_check::<C>(
115                CapabilitySource::Component(ComponentSource {
116                    capability: ComponentCapability::from(capability.clone()),
117                    moniker: component.moniker().clone(),
118                }),
119                component.policy_checker().clone(),
120            );
121            let prev = program_output_dict
122                .insert_capability(capability.name(), Capability::DirConnectorRouter(router));
123            assert!(prev.is_none(), "failed to insert {}: preexisting value", capability.name());
124        }
125        cm_rust::CapabilityDecl::Storage(cm_rust::StorageDecl {
126            name,
127            source,
128            backing_dir,
129            subdir,
130            storage_id,
131        }) => {
132            let router: Arc<Router<DirConnector>> = match source {
133                cm_rust::StorageDirectorySource::Parent => {
134                    component_input.capabilities().get_router_or_not_found(
135                        backing_dir,
136                        RoutingError::storage_from_parent_not_found(
137                            component.moniker(),
138                            backing_dir.clone(),
139                        ),
140                    )
141                }
142                cm_rust::StorageDirectorySource::Self_ => program_output_dict
143                    .get_router_or_not_found(
144                        backing_dir,
145                        RoutingError::BedrockNotPresentInDictionary {
146                            name: backing_dir.to_string(),
147                            moniker: ExtendedMoniker::ComponentInstance(
148                                component.moniker().clone(),
149                            ),
150                        },
151                    ),
152                cm_rust::StorageDirectorySource::Child(child_name) => {
153                    let child_name = ChildName::parse(child_name).expect("invalid child name");
154                    let Some(child_component_output) =
155                        child_outgoing_dictionary_routers.get(&child_name)
156                    else {
157                        panic!(
158                            "use declaration in manifest for component {} has a source of a nonexistent child {}, this should be prevented by manifest validation",
159                            component.moniker(),
160                            child_name
161                        );
162                    };
163                    child_component_output.clone().lazy_get(
164                        backing_dir.to_owned(),
165                        RoutingError::storage_from_child_expose_not_found(
166                            &child_name,
167                            &component.moniker(),
168                            backing_dir.clone(),
169                        ),
170                    )
171                }
172            };
173
174            #[derive(Debug)]
175            struct StorageBackingDirRouter<C: ComponentInstanceInterface + 'static> {
176                subdir: RelativePath,
177                storage_id: fdecl::StorageId,
178                backing_dir_router: Arc<Router<DirConnector>>,
179                storage_source_moniker: Moniker,
180                backing_dir_target: Arc<WeakInstanceToken>,
181                _component_type: PhantomData<C>,
182            }
183
184            impl<C: ComponentInstanceInterface + 'static> StorageBackingDirRouter<C> {
185                fn prepare_route(
186                    &self,
187                    mut request: RouteRequest,
188                    target: Arc<WeakInstanceToken>,
189                ) -> Result<RouteRequest, RouterError> {
190                    fn generate_moniker_based_storage_path(
191                        subdir: Option<String>,
192                        moniker: &Moniker,
193                        instance_id: Option<&InstanceId>,
194                    ) -> PathBuf {
195                        let mut dir_path = vec![];
196                        if let Some(subdir) = subdir {
197                            dir_path.push(subdir);
198                        }
199
200                        if let Some(id) = instance_id {
201                            dir_path.push(id.to_string());
202                            return dir_path.into_iter().collect();
203                        }
204
205                        let path = moniker.path();
206                        let mut path = path.iter();
207                        if let Some(p) = path.next() {
208                            dir_path.push(format!("{p}:0"));
209                        }
210                        while let Some(p) = path.next() {
211                            dir_path.push("children".to_string());
212                            dir_path.push(format!("{p}:0"));
213                        }
214
215                        // Storage capabilities used to have a hardcoded set of types, which would be appended
216                        // here. To maintain compatibility with the old paths (and thus not lose data when this was
217                        // migrated) we append "data" here. This works because this is the only type of storage
218                        // that was actually used in the wild.
219                        //
220                        // This is only temporary, until the storage instance id migration changes this layout.
221                        dir_path.push("data".to_string());
222                        dir_path.into_iter().collect()
223                    }
224                    let StorageBackingDirRouter {
225                        subdir,
226                        storage_id,
227                        backing_dir_router: _,
228                        storage_source_moniker,
229                        backing_dir_target: _,
230                        _component_type: _,
231                    } = self;
232                    let instance: ExtendedInstanceInterface<C> = target.upgrade().unwrap();
233                    let instance = match instance {
234                        ExtendedInstanceInterface::Component(c) => c,
235                        ExtendedInstanceInterface::AboveRoot(_) => {
236                            panic!("unexpected component manager instance")
237                        }
238                    };
239                    let index = instance.component_id_index();
240                    let instance_id = index.id_for_moniker(instance.moniker());
241                    match storage_id {
242                        fdecl::StorageId::StaticInstanceId if instance_id.is_none() => {
243                            return Err(RouterError::from(RoutingError::ComponentNotInIdIndex {
244                                source_moniker: storage_source_moniker.clone(),
245                                target_name: instance.moniker().leaf().map(Into::into),
246                            }));
247                        }
248                        _ => (),
249                    }
250                    let moniker = match WeakInstanceTokenExt::<C>::moniker(&target) {
251                        ExtendedMoniker::ComponentInstance(m) => m,
252                        ExtendedMoniker::ComponentManager => {
253                            panic!("component manager is the target of a storage capability")
254                        }
255                    };
256                    let moniker = match moniker.strip_prefix(&storage_source_moniker) {
257                        Ok(v) => v,
258                        Err(_) => moniker,
259                    };
260                    let subdir_opt = if subdir.is_dot() { None } else { Some(subdir.to_string()) };
261                    let isolated_storage_path =
262                        generate_moniker_based_storage_path(subdir_opt, &moniker, instance_id);
263                    request.isolated_storage_path =
264                        Some(format!("{}", isolated_storage_path.display()));
265                    request.build_type_name = Some(CapabilityTypeName::Directory.to_string());
266                    request.directory_rights = Some(fio::PERM_READABLE | fio::PERM_WRITABLE);
267                    request.inherit_rights = Some(false);
268                    request.storage_sub_directory_path = Some(subdir.to_string());
269                    request.storage_source_moniker = Some(storage_source_moniker.to_string());
270                    Ok(request)
271                }
272            }
273
274            #[async_trait]
275            impl<C: ComponentInstanceInterface + 'static> Routable<DirConnector>
276                for StorageBackingDirRouter<C>
277            {
278                async fn route(
279                    &self,
280                    request: RouteRequest,
281                    target: Arc<WeakInstanceToken>,
282                ) -> Result<Option<Arc<DirConnector>>, RouterError> {
283                    let request = self.prepare_route(request, target)?;
284                    self.backing_dir_router.route(request, self.backing_dir_target.clone()).await
285                }
286
287                async fn route_debug(
288                    &self,
289                    request: RouteRequest,
290                    target: Arc<WeakInstanceToken>,
291                ) -> Result<CapabilitySource, RouterError> {
292                    let request = self.prepare_route(request, target)?;
293                    self.backing_dir_router
294                        .route_debug(request, self.backing_dir_target.clone())
295                        .await
296                }
297            }
298
299            let router = router.with_policy_check::<C>(
300                CapabilitySource::Component(ComponentSource {
301                    capability: ComponentCapability::from(capability.clone()),
302                    moniker: component.moniker().clone(),
303                }),
304                component.policy_checker().clone(),
305            );
306            let router = Router::new(StorageBackingDirRouter::<C> {
307                subdir: subdir.clone(),
308                storage_id: storage_id.clone(),
309                backing_dir_router: router,
310                storage_source_moniker: component.moniker().clone(),
311                backing_dir_target: Arc::new(WeakInstanceToken {
312                    inner: Box::new(WeakExtendedInstanceInterface::Component(component.as_weak())),
313                }),
314                _component_type: Default::default(),
315            });
316            let prev =
317                program_output_dict.insert_capability(name, Capability::DirConnectorRouter(router));
318            assert!(prev.is_none(), "failed to insert {}: preexisting value", capability.name());
319        }
320        cm_rust::CapabilityDecl::Protocol(_)
321        | cm_rust::CapabilityDecl::Runner(_)
322        | cm_rust::CapabilityDecl::Resolver(_) => {
323            let router = router_gen.new_outgoing_dir_connector_router(component, decl, capability);
324            let router = router.with_policy_check::<C>(
325                CapabilitySource::Component(ComponentSource {
326                    capability: ComponentCapability::from(capability.clone()),
327                    moniker: component.moniker().clone(),
328                }),
329                component.policy_checker().clone(),
330            );
331            let prev = program_output_dict
332                .insert_capability(capability.name(), Capability::ConnectorRouter(router));
333            assert!(prev.is_none(), "failed to insert {}: preexisting value", capability.name());
334        }
335        cm_rust::CapabilityDecl::Dictionary(d) => {
336            extend_dict_with_dictionary(
337                component,
338                d,
339                program_output_dict,
340                declared_dictionaries,
341                router_gen,
342            );
343        }
344        cm_rust::CapabilityDecl::Config(c) => {
345            let data = Arc::new(Data::Bytes(
346                fidl::persist(&c.value.clone().native_into_fidl()).unwrap().into(),
347            ));
348            struct ConfigRouter {
349                data: Arc<Data>,
350                source: CapabilitySource,
351            }
352            #[async_trait]
353            impl Routable<Data> for ConfigRouter {
354                async fn route(
355                    &self,
356                    _request: RouteRequest,
357                    _target: Arc<WeakInstanceToken>,
358                ) -> Result<Option<Arc<Data>>, RouterError> {
359                    Ok(Some(self.data.clone()))
360                }
361                async fn route_debug(
362                    &self,
363                    _request: RouteRequest,
364                    _target: Arc<WeakInstanceToken>,
365                ) -> Result<CapabilitySource, RouterError> {
366                    Ok(self.source.clone())
367                }
368            }
369            let source = CapabilitySource::Component(ComponentSource {
370                capability: ComponentCapability::from(capability.clone()),
371                moniker: component.moniker().clone(),
372            });
373            let router = Router::new(ConfigRouter { data, source: source.clone() });
374            let router = router.with_policy_check::<C>(source, component.policy_checker().clone());
375            let prev = program_output_dict
376                .insert_capability(capability.name(), Capability::DataRouter(router));
377            assert!(prev.is_none(), "failed to insert {}: preexisting value", capability.name());
378        }
379        cm_rust::CapabilityDecl::EventStream(_) => {
380            // Capabilities not supported in bedrock program output dict yet.
381            return;
382        }
383    }
384}
385
386fn extend_dict_with_dictionary<C: ComponentInstanceInterface + 'static>(
387    component: &Arc<C>,
388    decl: &cm_rust::DictionaryDecl,
389    program_output_dict: &Arc<Dictionary>,
390    declared_dictionaries: &Arc<Dictionary>,
391    router_gen: &impl ProgramOutputGenerator<C>,
392) {
393    let router;
394    let declared_dict;
395    if let Some(source_path) = decl.source_path.as_ref() {
396        // Dictionary backed by program's outgoing directory.
397        router = router_gen.new_program_dictionary_router(
398            component.as_weak(),
399            source_path.clone(),
400            ComponentCapability::Dictionary(decl.clone()),
401        );
402        declared_dict = None;
403    } else {
404        let dict = Dictionary::new();
405        router = make_simple_dict_router(dict.clone(), component, decl);
406        declared_dict = Some(dict);
407    }
408    if let Some(dict) = declared_dict {
409        let prev = declared_dictionaries.insert_capability(&decl.name, dict.into());
410        assert!(prev.is_none(), "failed to insert {}: preexisting value", decl.name);
411    }
412    let prev = program_output_dict.insert_capability(&decl.name, router.into());
413    assert!(prev.is_none(), "failed to insert {}: preexisting value", decl.name);
414}
415
416/// Makes a router that always returns the given dictionary.
417fn make_simple_dict_router<C: ComponentInstanceInterface + 'static>(
418    dict: Arc<Dictionary>,
419    component: &Arc<C>,
420    decl: &cm_rust::DictionaryDecl,
421) -> Arc<Router<Dictionary>> {
422    struct DictRouter {
423        dict: Arc<Dictionary>,
424        source: CapabilitySource,
425    }
426    #[async_trait]
427    impl Routable<Dictionary> for DictRouter {
428        async fn route(
429            &self,
430            _request: RouteRequest,
431            _target: Arc<WeakInstanceToken>,
432        ) -> Result<Option<Arc<Dictionary>>, RouterError> {
433            Ok(Some(self.dict.clone()))
434        }
435
436        async fn route_debug(
437            &self,
438            _request: RouteRequest,
439            _target: Arc<WeakInstanceToken>,
440        ) -> Result<CapabilitySource, RouterError> {
441            Ok(self.source.clone())
442        }
443    }
444    let source = CapabilitySource::Component(ComponentSource {
445        capability: ComponentCapability::Dictionary(decl.clone()),
446        moniker: component.moniker().clone(),
447    });
448    Router::<Dictionary>::new(DictRouter { dict, source })
449}
routing/bedrock/program_output_dict.rs

routing/bedrock/
program_output_dict.rs
