routing/bedrock/
sandbox_construction.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::aggregate_router::{AggregateRouterFn, AggregateSource};
6use crate::bedrock::request_metadata::{service_metadata, Metadata, METADATA_KEY_TYPE};
7use crate::bedrock::structured_dict::{
8    ComponentEnvironment, ComponentInput, ComponentOutput, StructuredDictMap,
9};
10use crate::bedrock::with_porcelain_type::WithPorcelainType as _;
11use crate::bedrock::with_service_renames_and_filter::WithServiceRenamesAndFilter;
12use crate::capability_source::{
13    AggregateCapability, AggregateInstance, AggregateMember, AnonymizedAggregateSource,
14    CapabilitySource, FilteredAggregateProviderSource, InternalCapability, VoidSource,
15};
16use crate::component_instance::{ComponentInstanceInterface, WeakComponentInstanceInterface};
17use crate::error::{ErrorReporter, RouteRequestErrorInfo, RoutingError};
18use crate::{DictExt, LazyGet, Sources, WithAvailability, WithDefault, WithErrorReporter};
19use async_trait::async_trait;
20use cm_rust::{
21    CapabilityTypeName, ExposeDeclCommon, OfferDeclCommon, SourceName, SourcePath, UseDeclCommon,
22};
23use cm_types::{IterablePath, Name, SeparatedPath};
24use fidl::endpoints::DiscoverableProtocolMarker;
25use itertools::Itertools;
26use lazy_static::lazy_static;
27use log::warn;
28use moniker::{ChildName, Moniker};
29use router_error::RouterError;
30use sandbox::{
31    Capability, CapabilityBound, Connector, Data, Dict, DirEntry, Request, Routable, Router,
32    RouterResponse,
33};
34use std::collections::HashMap;
35use std::fmt::Debug;
36use std::sync::Arc;
37use {fidl_fuchsia_component_decl as fdecl, fidl_fuchsia_sys2 as fsys};
38
39lazy_static! {
40    static ref NAMESPACE: Name = "namespace".parse().unwrap();
41    static ref RUNNER: Name = "runner".parse().unwrap();
42    static ref CONFIG: Name = "config".parse().unwrap();
43}
44
45/// All capabilities that are available to a component's program.
46#[derive(Debug, Clone)]
47pub struct ProgramInput {
48    // This will always have the following fields:
49    // - namespace: Dict
50    // - runner: Option<Router<Connector>>
51    // - config: Dict
52    inner: Dict,
53}
54
55impl Default for ProgramInput {
56    fn default() -> Self {
57        Self::new(Dict::new(), None, Dict::new())
58    }
59}
60
61impl From<ProgramInput> for Dict {
62    fn from(program_input: ProgramInput) -> Self {
63        program_input.inner
64    }
65}
66
67impl ProgramInput {
68    pub fn new(namespace: Dict, runner: Option<Router<Connector>>, config: Dict) -> Self {
69        let inner = Dict::new();
70        inner.insert(NAMESPACE.clone(), namespace.into()).unwrap();
71        if let Some(runner) = runner {
72            inner.insert(RUNNER.clone(), runner.into()).unwrap();
73        }
74        inner.insert(CONFIG.clone(), config.into()).unwrap();
75        ProgramInput { inner }
76    }
77
78    /// All of the capabilities that appear in a program's namespace.
79    pub fn namespace(&self) -> Dict {
80        let cap = self.inner.get(&*NAMESPACE).expect("capabilities must be cloneable").unwrap();
81        let Capability::Dictionary(dict) = cap else {
82            unreachable!("namespace entry must be a dict: {cap:?}");
83        };
84        dict
85    }
86
87    /// A router for the runner that a component has used (if any).
88    pub fn runner(&self) -> Option<Router<Connector>> {
89        let cap = self.inner.get(&*RUNNER).expect("capabilities must be cloneable");
90        match cap {
91            None => None,
92            Some(Capability::ConnectorRouter(r)) => Some(r),
93            cap => unreachable!("runner entry must be a router: {cap:?}"),
94        }
95    }
96
97    fn set_runner(&self, capability: Capability) {
98        self.inner.insert(RUNNER.clone(), capability).unwrap()
99    }
100
101    /// All of the config capabilities that a program will use.
102    pub fn config(&self) -> Dict {
103        let cap = self.inner.get(&*CONFIG).expect("capabilities must be cloneable").unwrap();
104        let Capability::Dictionary(dict) = cap else {
105            unreachable!("config entry must be a dict: {cap:?}");
106        };
107        dict
108    }
109}
110
111/// A component's sandbox holds all the routing dictionaries that a component has once its been
112/// resolved.
113#[derive(Default, Debug, Clone)]
114pub struct ComponentSandbox {
115    /// The dictionary containing all capabilities that a component's parent provided to it.
116    pub component_input: ComponentInput,
117
118    /// The dictionary containing all capabilities that a component makes available to its parent.
119    pub component_output: ComponentOutput,
120
121    /// The dictionary containing all capabilities that are available to a component's program.
122    pub program_input: ProgramInput,
123
124    /// The dictionary containing all capabilities that a component's program can provide.
125    pub program_output_dict: Dict,
126
127    /// The dictionary containing all framework capabilities that are available to a component.
128    pub framework_dict: Dict,
129
130    /// The dictionary containing all capabilities that a component declares based on another
131    /// capability. Currently this is only the storage admin protocol.
132    pub capability_sourced_capabilities_dict: Dict,
133
134    /// The dictionary containing all dictionaries declared by this component.
135    pub declared_dictionaries: Dict,
136
137    /// This set holds a component input dictionary for each child of a component. Each dictionary
138    /// contains all capabilities the component has made available to a specific collection.
139    pub child_inputs: StructuredDictMap<ComponentInput>,
140
141    /// This set holds a component input dictionary for each collection declared by a component.
142    /// Each dictionary contains all capabilities the component has made available to a specific
143    /// collection.
144    pub collection_inputs: StructuredDictMap<ComponentInput>,
145}
146
147impl ComponentSandbox {
148    /// Copies all of the entries from the given sandbox into this one. Panics if the given sandbox
149    /// is holding any entries that cannot be copied. Panics if there are any duplicate entries.
150    pub fn append(&self, sandbox: &ComponentSandbox) {
151        // We destructure the sandbox here to ensure that this code is updated if the contents of
152        // the sandbox change.
153        let ComponentSandbox {
154            component_input,
155            component_output,
156            program_input,
157            program_output_dict,
158            framework_dict,
159            capability_sourced_capabilities_dict,
160            declared_dictionaries,
161            child_inputs,
162            collection_inputs,
163        } = sandbox;
164        for (copy_from, copy_to) in [
165            (&component_input.capabilities(), &self.component_input.capabilities()),
166            (&component_input.environment().debug(), &self.component_input.environment().debug()),
167            (
168                &component_input.environment().runners(),
169                &self.component_input.environment().runners(),
170            ),
171            (
172                &component_input.environment().resolvers(),
173                &self.component_input.environment().resolvers(),
174            ),
175            (&component_output.capabilities(), &self.component_output.capabilities()),
176            (&component_output.framework(), &self.component_output.framework()),
177            (&program_input.namespace(), &self.program_input.namespace()),
178            (&program_input.config(), &self.program_input.config()),
179            (&program_output_dict, &self.program_output_dict),
180            (&framework_dict, &self.framework_dict),
181            (&capability_sourced_capabilities_dict, &self.capability_sourced_capabilities_dict),
182            (&declared_dictionaries, &self.declared_dictionaries),
183        ] {
184            copy_to.append(copy_from).expect("sandbox capability is not cloneable");
185        }
186        if let Some(runner_router) = program_input.runner() {
187            self.program_input.set_runner(runner_router.into());
188        }
189        self.child_inputs.append(child_inputs).unwrap();
190        self.collection_inputs.append(collection_inputs).unwrap();
191    }
192}
193
194/// Once a component has been resolved and its manifest becomes known, this function produces the
195/// various dicts the component needs based on the contents of its manifest.
196pub fn build_component_sandbox<C: ComponentInstanceInterface + 'static>(
197    component: &Arc<C>,
198    child_component_output_dictionary_routers: HashMap<ChildName, Router<Dict>>,
199    decl: &cm_rust::ComponentDecl,
200    component_input: ComponentInput,
201    program_output_dict: Dict,
202    framework_dict: Dict,
203    capability_sourced_capabilities_dict: Dict,
204    declared_dictionaries: Dict,
205    error_reporter: impl ErrorReporter,
206    aggregate_router_fn: &AggregateRouterFn<C>,
207) -> ComponentSandbox {
208    let component_output = ComponentOutput::new();
209    let program_input = ProgramInput::default();
210    let environments: StructuredDictMap<ComponentEnvironment> = Default::default();
211    let child_inputs: StructuredDictMap<ComponentInput> = Default::default();
212    let collection_inputs: StructuredDictMap<ComponentInput> = Default::default();
213
214    for environment_decl in &decl.environments {
215        environments
216            .insert(
217                environment_decl.name.clone(),
218                build_environment(
219                    &component.moniker(),
220                    &child_component_output_dictionary_routers,
221                    &component_input,
222                    environment_decl,
223                    &program_output_dict,
224                ),
225            )
226            .ok();
227    }
228
229    for child in &decl.children {
230        let environment;
231        if let Some(environment_name) = child.environment.as_ref() {
232            environment = environments.get(environment_name).expect(
233                "child references nonexistent environment, \
234                    this should be prevented in manifest validation",
235            );
236        } else {
237            environment = component_input.environment();
238        }
239        let input = ComponentInput::new(environment);
240        let name = Name::new(child.name.as_str()).expect("child is static so name is not long");
241        child_inputs.insert(name, input).ok();
242    }
243
244    for collection in &decl.collections {
245        let environment;
246        if let Some(environment_name) = collection.environment.as_ref() {
247            environment = environments.get(environment_name).expect(
248                "collection references nonexistent environment, \
249                    this should be prevented in manifest validation",
250            )
251        } else {
252            environment = component_input.environment();
253        }
254        let input = ComponentInput::new(environment);
255        collection_inputs.insert(collection.name.clone(), input).ok();
256    }
257
258    for use_ in decl.uses.iter() {
259        match use_ {
260            cm_rust::UseDecl::Service(_)
261                if matches!(use_.source(), cm_rust::UseSource::Collection(_)) =>
262            {
263                let cm_rust::UseSource::Collection(collection_name) = use_.source() else {
264                    unreachable!();
265                };
266                let aggregate = (aggregate_router_fn)(
267                    component.clone(),
268                    vec![AggregateSource::Collection { collection_name: collection_name.clone() }],
269                    CapabilitySource::AnonymizedAggregate(AnonymizedAggregateSource {
270                        capability: AggregateCapability::Service(use_.source_name().clone()),
271                        moniker: component.moniker().clone(),
272                        members: vec![AggregateMember::try_from(use_).unwrap()],
273                        sources: Sources::new(cm_rust::CapabilityTypeName::Service),
274                        instances: vec![],
275                    }),
276                )
277                .with_default(Request {
278                    metadata: service_metadata(*use_.availability()),
279                    target: component.as_weak().into(),
280                })
281                .with_error_reporter(RouteRequestErrorInfo::from(use_), error_reporter.clone());
282                if let Err(e) = program_input
283                    .namespace()
284                    .insert_capability(use_.path().unwrap(), aggregate.into())
285                {
286                    warn!("failed to insert {} in program input dict: {e:?}", use_.path().unwrap())
287                }
288            }
289            cm_rust::UseDecl::Service(_) => extend_dict_with_use::<DirEntry, _>(
290                component,
291                &child_component_output_dictionary_routers,
292                &component_input,
293                &program_input,
294                &program_output_dict,
295                &framework_dict,
296                &capability_sourced_capabilities_dict,
297                use_,
298                error_reporter.clone(),
299            ),
300            cm_rust::UseDecl::Protocol(_) | cm_rust::UseDecl::Runner(_) => {
301                extend_dict_with_use::<Connector, _>(
302                    component,
303                    &child_component_output_dictionary_routers,
304                    &component_input,
305                    &program_input,
306                    &program_output_dict,
307                    &framework_dict,
308                    &capability_sourced_capabilities_dict,
309                    use_,
310                    error_reporter.clone(),
311                )
312            }
313            cm_rust::UseDecl::Config(config) => extend_dict_with_config_use(
314                component,
315                &child_component_output_dictionary_routers,
316                &component_input,
317                &program_input,
318                &program_output_dict,
319                config,
320                error_reporter.clone(),
321            ),
322            _ => (),
323        }
324    }
325
326    // The runner may be specified by either use declaration or in the program section of the
327    // manifest. If there's no use declaration for a runner and there is one set in the program
328    // section, then let's synthesize a use decl for it and add it to the sandbox.
329    if !decl.uses.iter().any(|u| matches!(u, cm_rust::UseDecl::Runner(_))) {
330        if let Some(runner_name) = decl.program.as_ref().and_then(|p| p.runner.as_ref()) {
331            extend_dict_with_use::<Connector, _>(
332                component,
333                &child_component_output_dictionary_routers,
334                &component_input,
335                &program_input,
336                &program_output_dict,
337                &framework_dict,
338                &capability_sourced_capabilities_dict,
339                &cm_rust::UseDecl::Runner(cm_rust::UseRunnerDecl {
340                    source: cm_rust::UseSource::Environment,
341                    source_name: runner_name.clone(),
342                    source_dictionary: Default::default(),
343                }),
344                error_reporter.clone(),
345            );
346        }
347    }
348
349    for offer_bundle in group_offer_aggregates(&decl.offers).into_iter() {
350        let first_offer = offer_bundle.first().unwrap();
351        let get_target_dict = || match first_offer.target() {
352            cm_rust::OfferTarget::Child(child_ref) => {
353                assert!(child_ref.collection.is_none(), "unexpected dynamic offer target");
354                let child_name = Name::new(child_ref.name.as_str())
355                    .expect("child is static so name is not long");
356                if child_inputs.get(&child_name).is_none() {
357                    child_inputs.insert(child_name.clone(), Default::default()).ok();
358                }
359                child_inputs
360                    .get(&child_name)
361                    .expect("component input was just added")
362                    .capabilities()
363            }
364            cm_rust::OfferTarget::Collection(name) => {
365                if collection_inputs.get(&name).is_none() {
366                    collection_inputs.insert(name.clone(), Default::default()).ok();
367                }
368                collection_inputs
369                    .get(&name)
370                    .expect("collection input was just added")
371                    .capabilities()
372            }
373            cm_rust::OfferTarget::Capability(name) => {
374                let dict = match declared_dictionaries
375                    .get(name)
376                    .expect("dictionaries must be cloneable")
377                {
378                    Some(dict) => dict,
379                    None => {
380                        let dict = Dict::new();
381                        declared_dictionaries
382                            .insert(name.clone(), Capability::Dictionary(dict.clone()))
383                            .ok();
384                        Capability::Dictionary(dict)
385                    }
386                };
387                let Capability::Dictionary(dict) = dict else {
388                    panic!("wrong type in dict");
389                };
390                dict
391            }
392        };
393        match first_offer {
394            cm_rust::OfferDecl::Service(_)
395                if offer_bundle.len() == 1
396                    && !matches!(first_offer.source(), cm_rust::OfferSource::Collection(_)) =>
397            {
398                extend_dict_with_offer::<DirEntry, _>(
399                    component,
400                    &child_component_output_dictionary_routers,
401                    &component_input,
402                    &program_output_dict,
403                    &framework_dict,
404                    &capability_sourced_capabilities_dict,
405                    first_offer,
406                    &(get_target_dict)(),
407                    error_reporter.clone(),
408                );
409            }
410            cm_rust::OfferDecl::Service(_) => {
411                let aggregate_router = new_aggregate_router_from_service_offers(
412                    &offer_bundle,
413                    component,
414                    &child_component_output_dictionary_routers,
415                    &component_input,
416                    &program_output_dict,
417                    &framework_dict,
418                    &capability_sourced_capabilities_dict,
419                    error_reporter.clone(),
420                    aggregate_router_fn,
421                );
422                (get_target_dict)()
423                    .insert(first_offer.target_name().clone(), aggregate_router.into())
424                    .expect("failed to insert capability into target dict")
425            }
426            cm_rust::OfferDecl::Config(_) => extend_dict_with_offer::<Data, _>(
427                component,
428                &child_component_output_dictionary_routers,
429                &component_input,
430                &program_output_dict,
431                &framework_dict,
432                &capability_sourced_capabilities_dict,
433                first_offer,
434                &(get_target_dict)(),
435                error_reporter.clone(),
436            ),
437            cm_rust::OfferDecl::Dictionary(_) => extend_dict_with_offer::<Dict, _>(
438                component,
439                &child_component_output_dictionary_routers,
440                &component_input,
441                &program_output_dict,
442                &framework_dict,
443                &capability_sourced_capabilities_dict,
444                first_offer,
445                &(get_target_dict)(),
446                error_reporter.clone(),
447            ),
448            cm_rust::OfferDecl::Protocol(_)
449            | cm_rust::OfferDecl::Runner(_)
450            | cm_rust::OfferDecl::Resolver(_) => extend_dict_with_offer::<Connector, _>(
451                component,
452                &child_component_output_dictionary_routers,
453                &component_input,
454                &program_output_dict,
455                &framework_dict,
456                &capability_sourced_capabilities_dict,
457                first_offer,
458                &(get_target_dict)(),
459                error_reporter.clone(),
460            ),
461            _ => {}
462        }
463    }
464
465    for expose_bundle in group_expose_aggregates(&decl.exposes).into_iter() {
466        let first_expose = expose_bundle.first().unwrap();
467        match first_expose {
468            cm_rust::ExposeDecl::Service(_)
469                if expose_bundle.len() == 1
470                    && !matches!(first_expose.source(), cm_rust::ExposeSource::Collection(_)) =>
471            {
472                extend_dict_with_expose::<DirEntry, _>(
473                    component,
474                    &child_component_output_dictionary_routers,
475                    &program_output_dict,
476                    &framework_dict,
477                    &capability_sourced_capabilities_dict,
478                    first_expose,
479                    &component_output,
480                    error_reporter.clone(),
481                );
482            }
483            cm_rust::ExposeDecl::Service(_) => {
484                let mut aggregate_sources = vec![];
485                let temp_component_output = ComponentOutput::new();
486                for expose in expose_bundle.iter() {
487                    extend_dict_with_expose::<DirEntry, _>(
488                        component,
489                        &child_component_output_dictionary_routers,
490                        &program_output_dict,
491                        &framework_dict,
492                        &capability_sourced_capabilities_dict,
493                        expose,
494                        &temp_component_output,
495                        error_reporter.clone(),
496                    );
497                    match temp_component_output.capabilities().remove(first_expose.target_name()) {
498                        Some(Capability::DirEntryRouter(router)) => {
499                            let source_instance = match expose.source() {
500                                cm_rust::ExposeSource::Self_ => AggregateInstance::Self_,
501                                cm_rust::ExposeSource::Child(name) => AggregateInstance::Child(
502                                    moniker::ChildName::new(name.clone().to_long(), None),
503                                ),
504                                other_source => {
505                                    warn!(
506                                        "unsupported source found in expose aggregate: {:?}",
507                                        other_source
508                                    );
509                                    continue;
510                                }
511                            };
512                            aggregate_sources
513                                .push(AggregateSource::DirectoryRouter { source_instance, router })
514                        }
515                        None => match expose.source() {
516                            cm_rust::ExposeSource::Collection(collection_name) => {
517                                aggregate_sources.push(AggregateSource::Collection {
518                                    collection_name: collection_name.clone(),
519                                });
520                            }
521                            _ => continue,
522                        },
523                        other_value => panic!("unexpected dictionary entry: {:?}", other_value),
524                    }
525                }
526                let aggregate = (aggregate_router_fn)(
527                    component.clone(),
528                    aggregate_sources,
529                    CapabilitySource::AnonymizedAggregate(AnonymizedAggregateSource {
530                        capability: AggregateCapability::Service(
531                            first_expose.target_name().clone(),
532                        ),
533                        moniker: component.moniker().clone(),
534                        members: expose_bundle
535                            .iter()
536                            .filter_map(|e| AggregateMember::try_from(*e).ok())
537                            .collect(),
538                        sources: Sources::new(cm_rust::CapabilityTypeName::Service),
539                        instances: vec![],
540                    }),
541                )
542                .with_default(Request {
543                    metadata: service_metadata(*first_expose.availability()),
544                    target: component.as_weak().into(),
545                });
546                component_output
547                    .capabilities()
548                    .insert(first_expose.target_name().clone(), aggregate.into())
549                    .expect("failed to insert capability into target dict")
550            }
551            cm_rust::ExposeDecl::Config(_) => extend_dict_with_expose::<Data, _>(
552                component,
553                &child_component_output_dictionary_routers,
554                &program_output_dict,
555                &framework_dict,
556                &capability_sourced_capabilities_dict,
557                first_expose,
558                &component_output,
559                error_reporter.clone(),
560            ),
561            cm_rust::ExposeDecl::Dictionary(_) => extend_dict_with_expose::<Dict, _>(
562                component,
563                &child_component_output_dictionary_routers,
564                &program_output_dict,
565                &framework_dict,
566                &capability_sourced_capabilities_dict,
567                first_expose,
568                &component_output,
569                error_reporter.clone(),
570            ),
571            cm_rust::ExposeDecl::Protocol(_)
572            | cm_rust::ExposeDecl::Runner(_)
573            | cm_rust::ExposeDecl::Resolver(_) => extend_dict_with_expose::<Connector, _>(
574                component,
575                &child_component_output_dictionary_routers,
576                &program_output_dict,
577                &framework_dict,
578                &capability_sourced_capabilities_dict,
579                first_expose,
580                &component_output,
581                error_reporter.clone(),
582            ),
583            _ => {}
584        }
585    }
586
587    ComponentSandbox {
588        component_input,
589        component_output,
590        program_input,
591        program_output_dict,
592        framework_dict,
593        capability_sourced_capabilities_dict,
594        declared_dictionaries,
595        child_inputs,
596        collection_inputs,
597    }
598}
599
600fn new_aggregate_router_from_service_offers<C: ComponentInstanceInterface + 'static>(
601    offer_bundle: &Vec<&cm_rust::OfferDecl>,
602    component: &Arc<C>,
603    child_component_output_dictionary_routers: &HashMap<ChildName, Router<Dict>>,
604    component_input: &ComponentInput,
605    program_output_dict: &Dict,
606    framework_dict: &Dict,
607    capability_sourced_capabilities_dict: &Dict,
608    error_reporter: impl ErrorReporter,
609    aggregate_router_fn: &AggregateRouterFn<C>,
610) -> Router<DirEntry> {
611    let mut aggregate_sources = vec![];
612    let dict_for_source_router = Dict::new();
613    let source = new_aggregate_capability_source(component.moniker().clone(), offer_bundle.clone());
614    for offer in offer_bundle.iter() {
615        if matches!(&source, &CapabilitySource::FilteredAggregateProvider(_)) {
616            if let cm_rust::OfferDecl::Service(offer_service_decl) = offer {
617                if offer_service_decl
618                    .source_instance_filter
619                    .as_ref()
620                    .and_then(|v| v.first())
621                    .is_none()
622                    && offer_service_decl
623                        .renamed_instances
624                        .as_ref()
625                        .and_then(|v| v.first())
626                        .is_none()
627                {
628                    // If we're a filtering aggregate and no filter or renames have been
629                    // set, then all instances here are ignored, and there's no point in
630                    // including the router in the aggregate.
631                    continue;
632                }
633            }
634        }
635        extend_dict_with_offer::<DirEntry, _>(
636            component,
637            &child_component_output_dictionary_routers,
638            &component_input,
639            &program_output_dict,
640            &framework_dict,
641            &capability_sourced_capabilities_dict,
642            offer,
643            &dict_for_source_router,
644            error_reporter.clone(),
645        );
646        match dict_for_source_router.remove(offer.target_name()) {
647            Some(Capability::DirEntryRouter(router)) => {
648                let source_instance = match offer.source() {
649                    cm_rust::OfferSource::Self_ => AggregateInstance::Self_,
650                    cm_rust::OfferSource::Parent => AggregateInstance::Parent,
651                    cm_rust::OfferSource::Child(child_ref) => {
652                        AggregateInstance::Child(moniker::ChildName::new(
653                            child_ref.name.clone(),
654                            child_ref.collection.clone(),
655                        ))
656                    }
657                    other_source => {
658                        warn!("unsupported source found in offer aggregate: {:?}", other_source);
659                        continue;
660                    }
661                };
662                aggregate_sources.push(AggregateSource::DirectoryRouter { source_instance, router })
663            }
664            None => match offer.source() {
665                // `extend_dict_with_offer` doesn't insert a capability for offers with a source of
666                // `OfferSource::Collection`. This is because at this stage there's nothing in the
667                // collection, and thus no routers to things in the collection.
668                cm_rust::OfferSource::Collection(collection_name) => {
669                    aggregate_sources.push(AggregateSource::Collection {
670                        collection_name: collection_name.clone(),
671                    });
672                }
673                _ => continue,
674            },
675            other => warn!("found unexpected entry in dictionary: {:?}", other),
676        }
677    }
678    (aggregate_router_fn)(component.clone(), aggregate_sources, source).with_default(Request {
679        metadata: service_metadata(*offer_bundle.first().unwrap().availability()),
680        target: component.as_weak().into(),
681    })
682}
683
684fn new_aggregate_capability_source(
685    moniker: Moniker,
686    offers: Vec<&cm_rust::OfferDecl>,
687) -> CapabilitySource {
688    let offer_service_decls = offers
689        .iter()
690        .map(|o| match o {
691            cm_rust::OfferDecl::Service(o) => o,
692            _ => panic!("cannot aggregate non-service capabilities, manifest validation should prevent this"),
693        }).collect::<Vec<_>>();
694    // This is a filtered offer if any of the offers set a filter or rename mapping.
695    let is_filtered_offer = offer_service_decls.iter().any(|o| {
696        o.source_instance_filter.as_ref().map(|v| !v.is_empty()).unwrap_or(false)
697            || o.renamed_instances.as_ref().map(|v| !v.is_empty()).unwrap_or(false)
698    });
699    let capability =
700        AggregateCapability::Service(offer_service_decls.first().unwrap().target_name.clone());
701    if is_filtered_offer {
702        CapabilitySource::FilteredAggregateProvider(FilteredAggregateProviderSource {
703            capability,
704            moniker,
705            offer_service_decls: offer_service_decls.into_iter().cloned().collect(),
706            sources: Sources::new(cm_rust::CapabilityTypeName::Service).component().collection(),
707        })
708    } else {
709        let members = offers.iter().filter_map(|o| AggregateMember::try_from(*o).ok()).collect();
710        CapabilitySource::AnonymizedAggregate(AnonymizedAggregateSource {
711            capability,
712            moniker,
713            members,
714            sources: Sources::new(cm_rust::CapabilityTypeName::Service).component().collection(),
715            instances: vec![],
716        })
717    }
718}
719
720/// Groups together a set of offers into sub-sets of those that have the same target and target
721/// name. This is useful for identifying which offers are part of an aggregation of capabilities,
722/// and which are for standalone routes.
723fn group_offer_aggregates(offers: &Vec<cm_rust::OfferDecl>) -> Vec<Vec<&cm_rust::OfferDecl>> {
724    let mut groupings = HashMap::new();
725    for offer in offers.iter() {
726        groupings.entry((offer.target(), offer.target_name())).or_insert(vec![]).push(offer);
727    }
728    groupings.into_iter().map(|(_key, grouping)| grouping).collect()
729}
730
731/// Identical to `group_offer_aggregates`, but for exposes.
732fn group_expose_aggregates(exposes: &Vec<cm_rust::ExposeDecl>) -> Vec<Vec<&cm_rust::ExposeDecl>> {
733    let mut groupings = HashMap::new();
734    for expose in exposes.iter() {
735        groupings.entry((expose.target(), expose.target_name())).or_insert(vec![]).push(expose);
736    }
737    groupings.into_iter().map(|(_key, grouping)| grouping).collect()
738}
739
740fn build_environment(
741    moniker: &Moniker,
742    child_component_output_dictionary_routers: &HashMap<ChildName, Router<Dict>>,
743    component_input: &ComponentInput,
744    environment_decl: &cm_rust::EnvironmentDecl,
745    program_output_dict: &Dict,
746) -> ComponentEnvironment {
747    let mut environment = ComponentEnvironment::new();
748    if environment_decl.extends == fdecl::EnvironmentExtends::Realm {
749        if let Ok(e) = component_input.environment().shallow_copy() {
750            environment = e;
751        } else {
752            warn!("failed to copy component_input.environment");
753        }
754    }
755    let debug = environment_decl.debug_capabilities.iter().map(|debug_registration| {
756        let cm_rust::DebugRegistration::Protocol(debug) = debug_registration;
757        (&debug.source_name, debug.target_name.clone(), &debug.source, CapabilityTypeName::Protocol)
758    });
759    let runners = environment_decl.runners.iter().map(|runner| {
760        (
761            &runner.source_name,
762            runner.target_name.clone(),
763            &runner.source,
764            CapabilityTypeName::Runner,
765        )
766    });
767    let resolvers = environment_decl.resolvers.iter().map(|resolver| {
768        (
769            &resolver.resolver,
770            Name::new(&resolver.scheme).unwrap(),
771            &resolver.source,
772            CapabilityTypeName::Resolver,
773        )
774    });
775    for (source_name, target_name, source, cap_type) in debug.chain(runners).chain(resolvers) {
776        let source_path =
777            SeparatedPath { dirname: Default::default(), basename: source_name.clone() };
778        let router: Router<Connector> = match &source {
779            cm_rust::RegistrationSource::Parent => {
780                use_from_parent_router::<Connector>(component_input, source_path, moniker)
781                    .with_porcelain_type(cap_type, moniker.clone())
782            }
783            cm_rust::RegistrationSource::Self_ => program_output_dict
784                .get_router_or_not_found::<Connector>(
785                    &source_path,
786                    RoutingError::use_from_self_not_found(
787                        moniker,
788                        source_path.iter_segments().join("/"),
789                    ),
790                )
791                .with_porcelain_type(cap_type, moniker.clone()),
792            cm_rust::RegistrationSource::Child(child_name) => {
793                let child_name = ChildName::parse(child_name).expect("invalid child name");
794                let Some(child_component_output) =
795                    child_component_output_dictionary_routers.get(&child_name)
796                else {
797                    continue;
798                };
799                let r: Router<Connector> = child_component_output.clone().lazy_get(
800                    source_path,
801                    RoutingError::use_from_child_expose_not_found(
802                        &child_name,
803                        &moniker,
804                        source_name.clone(),
805                    ),
806                );
807                r.with_porcelain_type(cap_type, moniker.clone())
808            }
809        };
810        let dict_to_insert_to = match cap_type {
811            CapabilityTypeName::Protocol => environment.debug(),
812            CapabilityTypeName::Runner => environment.runners(),
813            CapabilityTypeName::Resolver => environment.resolvers(),
814            c => panic!("unexpected capability type {}", c),
815        };
816        match dict_to_insert_to.insert_capability(&target_name, router.into()) {
817            Ok(()) => (),
818            Err(_e) => {
819                // The only reason this will happen is if we're shadowing something else in the
820                // environment. `insert_capability` will still insert the new capability when it
821                // returns an error, so we can safely ignore this.
822            }
823        }
824    }
825    environment
826}
827
828/// Extends the given `target_input` to contain the capabilities described in `dynamic_offers`.
829pub fn extend_dict_with_offers<C: ComponentInstanceInterface + 'static>(
830    component: &Arc<C>,
831    static_offers: &Vec<cm_rust::OfferDecl>,
832    child_component_output_dictionary_routers: &HashMap<ChildName, Router<Dict>>,
833    component_input: &ComponentInput,
834    dynamic_offers: &Vec<cm_rust::OfferDecl>,
835    program_output_dict: &Dict,
836    framework_dict: &Dict,
837    capability_sourced_capabilities_dict: &Dict,
838    target_input: &ComponentInput,
839    error_reporter: impl ErrorReporter,
840    aggregate_router_fn: &AggregateRouterFn<C>,
841) {
842    for offer_bundle in group_offer_aggregates(dynamic_offers).into_iter() {
843        let first_offer = offer_bundle.first().unwrap();
844        match first_offer {
845            cm_rust::OfferDecl::Service(_) => {
846                let static_offer_bundles = group_offer_aggregates(static_offers);
847                let maybe_static_offer_bundle = static_offer_bundles.into_iter().find(|bundle| {
848                    bundle.first().unwrap().target_name() == first_offer.target_name()
849                });
850                let mut combined_offer_bundle = offer_bundle.clone();
851                if let Some(mut static_offer_bundle) = maybe_static_offer_bundle {
852                    // We are aggregating together dynamic and static offers, as there are static
853                    // offers with the same target name as our current dynamic offers. We already
854                    // populated a router for the static bundle in the target input, let's toss
855                    // that and generate a new one with the expanded set of offers.
856                    let _ = target_input.capabilities().remove(first_offer.target_name());
857                    combined_offer_bundle.append(&mut static_offer_bundle);
858                }
859                if combined_offer_bundle.len() == 1
860                    && !matches!(first_offer.source(), cm_rust::OfferSource::Collection(_))
861                {
862                    extend_dict_with_offer::<DirEntry, _>(
863                        component,
864                        &child_component_output_dictionary_routers,
865                        &component_input,
866                        &program_output_dict,
867                        &framework_dict,
868                        &capability_sourced_capabilities_dict,
869                        first_offer,
870                        &target_input.capabilities(),
871                        error_reporter.clone(),
872                    );
873                } else {
874                    let aggregate_router = new_aggregate_router_from_service_offers(
875                        &combined_offer_bundle,
876                        component,
877                        &child_component_output_dictionary_routers,
878                        &component_input,
879                        &program_output_dict,
880                        &framework_dict,
881                        &capability_sourced_capabilities_dict,
882                        error_reporter.clone(),
883                        aggregate_router_fn,
884                    );
885                    target_input
886                        .capabilities()
887                        .insert(first_offer.target_name().clone(), aggregate_router.into())
888                        .expect("failed to insert capability into target dict");
889                }
890            }
891            cm_rust::OfferDecl::Config(_) => extend_dict_with_offer::<Data, _>(
892                component,
893                &child_component_output_dictionary_routers,
894                component_input,
895                program_output_dict,
896                framework_dict,
897                capability_sourced_capabilities_dict,
898                first_offer,
899                &target_input.capabilities(),
900                error_reporter.clone(),
901            ),
902            cm_rust::OfferDecl::Dictionary(_) => extend_dict_with_offer::<Dict, _>(
903                component,
904                &child_component_output_dictionary_routers,
905                component_input,
906                program_output_dict,
907                framework_dict,
908                capability_sourced_capabilities_dict,
909                first_offer,
910                &target_input.capabilities(),
911                error_reporter.clone(),
912            ),
913            cm_rust::OfferDecl::Protocol(_)
914            | cm_rust::OfferDecl::Runner(_)
915            | cm_rust::OfferDecl::Resolver(_) => extend_dict_with_offer::<Connector, _>(
916                component,
917                &child_component_output_dictionary_routers,
918                component_input,
919                program_output_dict,
920                framework_dict,
921                capability_sourced_capabilities_dict,
922                first_offer,
923                &target_input.capabilities(),
924                error_reporter.clone(),
925            ),
926            _ => {}
927        }
928    }
929}
930
931pub fn is_supported_use(use_: &cm_rust::UseDecl) -> bool {
932    matches!(
933        use_,
934        cm_rust::UseDecl::Config(_)
935            | cm_rust::UseDecl::Protocol(_)
936            | cm_rust::UseDecl::Runner(_)
937            | cm_rust::UseDecl::Service(_)
938    )
939}
940
941// Add the `config_use` to the `program_input_dict`, so the component is able to
942// access this configuration.
943fn extend_dict_with_config_use<C: ComponentInstanceInterface + 'static>(
944    component: &Arc<C>,
945    child_component_output_dictionary_routers: &HashMap<ChildName, Router<Dict>>,
946    component_input: &ComponentInput,
947    program_input: &ProgramInput,
948    program_output_dict: &Dict,
949    config_use: &cm_rust::UseConfigurationDecl,
950    error_reporter: impl ErrorReporter,
951) {
952    let moniker = component.moniker();
953    let source_path = config_use.source_path();
954    let porcelain_type = CapabilityTypeName::Config;
955    let router: Router<Data> = match config_use.source() {
956        cm_rust::UseSource::Parent => {
957            use_from_parent_router::<Data>(component_input, source_path.to_owned(), moniker)
958                .with_porcelain_type(porcelain_type, moniker.clone())
959        }
960        cm_rust::UseSource::Self_ => program_output_dict
961            .get_router_or_not_found::<Data>(
962                &source_path,
963                RoutingError::use_from_self_not_found(
964                    moniker,
965                    source_path.iter_segments().join("/"),
966                ),
967            )
968            .with_porcelain_type(porcelain_type, moniker.clone()),
969        cm_rust::UseSource::Child(child_name) => {
970            let child_name = ChildName::parse(child_name).expect("invalid child name");
971            let Some(child_component_output) =
972                child_component_output_dictionary_routers.get(&child_name)
973            else {
974                panic!("use declaration in manifest for component {} has a source of a nonexistent child {}, this should be prevented by manifest validation", moniker, child_name);
975            };
976            let r: Router<Data> = child_component_output.clone().lazy_get(
977                source_path.to_owned(),
978                RoutingError::use_from_child_expose_not_found(
979                    &child_name,
980                    &moniker,
981                    config_use.source_name().clone(),
982                ),
983            );
984            r.with_porcelain_type(porcelain_type, moniker.clone())
985        }
986        // The following are not used with config capabilities.
987        cm_rust::UseSource::Environment => return,
988        cm_rust::UseSource::Debug => return,
989        cm_rust::UseSource::Capability(_) => return,
990        cm_rust::UseSource::Framework => return,
991        cm_rust::UseSource::Collection(_) => return,
992    };
993
994    let metadata = Dict::new();
995    metadata
996        .insert(
997            Name::new(METADATA_KEY_TYPE).unwrap(),
998            Capability::Data(Data::String(porcelain_type.to_string())),
999        )
1000        .expect("failed to build default use metadata?");
1001    metadata.set_metadata(*config_use.availability());
1002    let default_request = Request { metadata, target: component.as_weak().into() };
1003    match program_input.config().insert_capability(
1004        &config_use.target_name,
1005        router
1006            .with_availability(moniker.clone(), *config_use.availability())
1007            .with_default(default_request)
1008            .with_error_reporter(RouteRequestErrorInfo::from(config_use), error_reporter)
1009            .into(),
1010    ) {
1011        Ok(()) => (),
1012        Err(e) => {
1013            warn!("failed to insert {} in program input dict: {e:?}", config_use.target_name)
1014        }
1015    }
1016}
1017
1018fn extend_dict_with_use<T, C: ComponentInstanceInterface + 'static>(
1019    component: &Arc<C>,
1020    child_component_output_dictionary_routers: &HashMap<ChildName, Router<Dict>>,
1021    component_input: &ComponentInput,
1022    program_input: &ProgramInput,
1023    program_output_dict: &Dict,
1024    framework_dict: &Dict,
1025    capability_sourced_capabilities_dict: &Dict,
1026    use_: &cm_rust::UseDecl,
1027    error_reporter: impl ErrorReporter,
1028) where
1029    T: CapabilityBound + Clone,
1030    Router<T>: TryFrom<Capability> + Into<Capability>,
1031{
1032    if !is_supported_use(use_) {
1033        return;
1034    }
1035    let moniker = component.moniker();
1036    if let cm_rust::UseDecl::Config(config) = use_ {
1037        return extend_dict_with_config_use(
1038            component,
1039            child_component_output_dictionary_routers,
1040            component_input,
1041            program_input,
1042            program_output_dict,
1043            config,
1044            error_reporter,
1045        );
1046    };
1047
1048    let source_path = use_.source_path();
1049    let porcelain_type = CapabilityTypeName::from(use_);
1050    let router: Router<T> = match use_.source() {
1051        cm_rust::UseSource::Parent => {
1052            use_from_parent_router::<T>(component_input, source_path.to_owned(), moniker)
1053                .with_porcelain_type(porcelain_type, moniker.clone())
1054        }
1055        cm_rust::UseSource::Self_ => program_output_dict
1056            .get_router_or_not_found::<T>(
1057                &source_path,
1058                RoutingError::use_from_self_not_found(
1059                    moniker,
1060                    source_path.iter_segments().join("/"),
1061                ),
1062            )
1063            .with_porcelain_type(porcelain_type, moniker.clone()),
1064        cm_rust::UseSource::Child(child_name) => {
1065            let child_name = ChildName::parse(child_name).expect("invalid child name");
1066            let Some(child_component_output) =
1067                child_component_output_dictionary_routers.get(&child_name)
1068            else {
1069                panic!("use declaration in manifest for component {} has a source of a nonexistent child {}, this should be prevented by manifest validation", moniker, child_name);
1070            };
1071            let r: Router<T> = child_component_output.clone().lazy_get(
1072                source_path.to_owned(),
1073                RoutingError::use_from_child_expose_not_found(
1074                    &child_name,
1075                    &moniker,
1076                    use_.source_name().clone(),
1077                ),
1078            );
1079            r.with_porcelain_type(porcelain_type, moniker.clone())
1080        }
1081        cm_rust::UseSource::Framework if use_.is_from_dictionary() => {
1082            Router::<T>::new_error(RoutingError::capability_from_framework_not_found(
1083                moniker,
1084                source_path.iter_segments().join("/"),
1085            ))
1086        }
1087        cm_rust::UseSource::Framework => framework_dict
1088            .get_router_or_not_found::<T>(
1089                &source_path,
1090                RoutingError::capability_from_framework_not_found(
1091                    moniker,
1092                    source_path.iter_segments().join("/"),
1093                ),
1094            )
1095            .with_porcelain_type(porcelain_type, moniker.clone()),
1096        cm_rust::UseSource::Capability(capability_name) => {
1097            let err = RoutingError::capability_from_capability_not_found(
1098                moniker,
1099                capability_name.as_str().to_string(),
1100            );
1101            if source_path.iter_segments().join("/") == fsys::StorageAdminMarker::PROTOCOL_NAME {
1102                capability_sourced_capabilities_dict.get_router_or_not_found(&capability_name, err)
1103            } else {
1104                Router::<T>::new_error(err)
1105            }
1106        }
1107        cm_rust::UseSource::Debug => {
1108            let cm_rust::UseDecl::Protocol(use_protocol) = use_ else {
1109                panic!("non-protocol capability used with a debug source, this should be prevented by manifest validation");
1110            };
1111            component_input
1112                .environment()
1113                .debug()
1114                .get_router_or_not_found::<T>(
1115                    &use_protocol.source_name,
1116                    RoutingError::use_from_environment_not_found(
1117                        moniker,
1118                        "protocol",
1119                        &use_protocol.source_name,
1120                    ),
1121                )
1122                .with_porcelain_type(use_.into(), moniker.clone())
1123        }
1124        cm_rust::UseSource::Environment => {
1125            let cm_rust::UseDecl::Runner(use_runner) = use_ else {
1126                panic!("non-runner capability used with an environment source, this should be prevented by manifest validation");
1127            };
1128            component_input
1129                .environment()
1130                .runners()
1131                .get_router_or_not_found::<T>(
1132                    &use_runner.source_name,
1133                    RoutingError::use_from_environment_not_found(
1134                        moniker,
1135                        "runner",
1136                        &use_runner.source_name,
1137                    ),
1138                )
1139                .with_porcelain_type(porcelain_type, moniker.clone())
1140        }
1141        cm_rust::UseSource::Collection(_) => {
1142            // Collection sources are handled separately, in `build_component_sandbox`
1143            return;
1144        }
1145    };
1146    let metadata = Dict::new();
1147    metadata
1148        .insert(
1149            Name::new(METADATA_KEY_TYPE).unwrap(),
1150            Capability::Data(Data::String(porcelain_type.to_string())),
1151        )
1152        .expect("failed to build default use metadata?");
1153    metadata.set_metadata(*use_.availability());
1154    let default_request = Request { metadata, target: component.as_weak().into() };
1155    let router = router
1156        .with_availability(moniker.clone(), *use_.availability())
1157        .with_default(default_request)
1158        .with_error_reporter(RouteRequestErrorInfo::from(use_), error_reporter);
1159
1160    if let Some(target_path) = use_.path() {
1161        if let Err(e) = program_input.namespace().insert_capability(target_path, router.into()) {
1162            warn!("failed to insert {} in program input dict: {e:?}", target_path)
1163        }
1164    } else {
1165        match use_ {
1166            cm_rust::UseDecl::Runner(_) => {
1167                assert!(program_input.runner().is_none(), "component can't use multiple runners");
1168                program_input.set_runner(router.into());
1169            }
1170            _ => panic!("unexpected capability type: {:?}", use_),
1171        }
1172    }
1173}
1174
1175/// Builds a router that obtains a capability that the program uses from `parent`.
1176fn use_from_parent_router<T>(
1177    component_input: &ComponentInput,
1178    source_path: impl IterablePath + 'static + Debug,
1179    moniker: &Moniker,
1180) -> Router<T>
1181where
1182    T: CapabilityBound + Clone,
1183    Router<T>: TryFrom<Capability>,
1184{
1185    let err = if moniker == &Moniker::root() {
1186        RoutingError::register_from_component_manager_not_found(
1187            source_path.iter_segments().join("/"),
1188        )
1189    } else {
1190        RoutingError::use_from_parent_not_found(moniker, source_path.iter_segments().join("/"))
1191    };
1192    component_input.capabilities().get_router_or_not_found::<T>(&source_path, err)
1193}
1194
1195fn is_supported_offer(offer: &cm_rust::OfferDecl) -> bool {
1196    matches!(
1197        offer,
1198        cm_rust::OfferDecl::Config(_)
1199            | cm_rust::OfferDecl::Protocol(_)
1200            | cm_rust::OfferDecl::Dictionary(_)
1201            | cm_rust::OfferDecl::Runner(_)
1202            | cm_rust::OfferDecl::Resolver(_)
1203            | cm_rust::OfferDecl::Service(_)
1204    )
1205}
1206
1207fn extend_dict_with_offer<T, C: ComponentInstanceInterface + 'static>(
1208    component: &Arc<C>,
1209    child_component_output_dictionary_routers: &HashMap<ChildName, Router<Dict>>,
1210    component_input: &ComponentInput,
1211    program_output_dict: &Dict,
1212    framework_dict: &Dict,
1213    capability_sourced_capabilities_dict: &Dict,
1214    offer: &cm_rust::OfferDecl,
1215    target_dict: &Dict,
1216    error_reporter: impl ErrorReporter,
1217) where
1218    T: CapabilityBound + Clone,
1219    Router<T>: TryFrom<Capability> + Into<Capability> + WithServiceRenamesAndFilter,
1220{
1221    assert!(is_supported_offer(offer), "{offer:?}");
1222
1223    let source_path = offer.source_path();
1224    let target_name = offer.target_name();
1225    if target_dict.get_capability(&target_name).is_some() {
1226        panic!(
1227            "duplicate sources for {} {} in a dict, unable to populate dict entry, manifest \
1228                validation should prevent this",
1229            cm_rust::CapabilityTypeName::from(offer),
1230            target_name
1231        );
1232    }
1233    let porcelain_type = CapabilityTypeName::from(offer);
1234    let router: Router<T> = match offer.source() {
1235        cm_rust::OfferSource::Parent => {
1236            let err = if component.moniker() == &Moniker::root() {
1237                RoutingError::register_from_component_manager_not_found(
1238                    offer.source_name().to_string(),
1239                )
1240            } else {
1241                RoutingError::offer_from_parent_not_found(
1242                    &component.moniker(),
1243                    source_path.iter_segments().join("/"),
1244                )
1245            };
1246            let router =
1247                component_input.capabilities().get_router_or_not_found::<T>(&source_path, err);
1248            router.with_porcelain_type(porcelain_type, component.moniker().clone())
1249        }
1250        cm_rust::OfferSource::Self_ => program_output_dict
1251            .get_router_or_not_found::<T>(
1252                &source_path,
1253                RoutingError::offer_from_self_not_found(
1254                    &component.moniker(),
1255                    source_path.iter_segments().join("/"),
1256                ),
1257            )
1258            .with_porcelain_type(porcelain_type, component.moniker().clone()),
1259        cm_rust::OfferSource::Child(child_ref) => {
1260            let child_name: ChildName = child_ref.clone().try_into().expect("invalid child ref");
1261            match child_component_output_dictionary_routers.get(&child_name) {
1262                None => Router::<T>::new_error(RoutingError::offer_from_child_instance_not_found(
1263                    &child_name,
1264                    &component.moniker(),
1265                    source_path.iter_segments().join("/"),
1266                )),
1267                Some(child_component_output) => {
1268                    let router: Router<T> = child_component_output.clone().lazy_get(
1269                        source_path.to_owned(),
1270                        RoutingError::offer_from_child_expose_not_found(
1271                            &child_name,
1272                            &component.moniker(),
1273                            offer.source_name().clone(),
1274                        ),
1275                    );
1276                    match offer {
1277                        cm_rust::OfferDecl::Protocol(_) => {
1278                            router.with_porcelain_type(porcelain_type, component.moniker().clone())
1279                        }
1280                        _ => router,
1281                    }
1282                }
1283            }
1284        }
1285        cm_rust::OfferSource::Framework => {
1286            if offer.is_from_dictionary() {
1287                warn!(
1288                    "routing from framework with dictionary path is not supported: {source_path}"
1289                );
1290                return;
1291            }
1292            let router = framework_dict.get_router_or_not_found::<T>(
1293                &source_path,
1294                RoutingError::capability_from_framework_not_found(
1295                    &component.moniker(),
1296                    source_path.iter_segments().join("/"),
1297                ),
1298            );
1299            router.with_porcelain_type(offer.into(), component.moniker().clone())
1300        }
1301        cm_rust::OfferSource::Capability(capability_name) => {
1302            let err = RoutingError::capability_from_capability_not_found(
1303                &component.moniker(),
1304                capability_name.as_str().to_string(),
1305            );
1306            if source_path.iter_segments().join("/") == fsys::StorageAdminMarker::PROTOCOL_NAME {
1307                capability_sourced_capabilities_dict.get_router_or_not_found(&capability_name, err)
1308            } else {
1309                Router::<T>::new_error(err)
1310            }
1311        }
1312        cm_rust::OfferSource::Void => UnavailableRouter::new::<T>(
1313            InternalCapability::Protocol(offer.source_name().clone()),
1314            component,
1315        ),
1316        cm_rust::OfferSource::Collection(_collection_name) => {
1317            // There's nothing in a collection at this stage, and thus we can't get any routers to
1318            // things in the collection. What's more: the contents of the collection can change
1319            // over time, so it must be monitored. We don't handle collections here, they're
1320            // handled in a different way by whoever called `extend_dict_with_offer`.
1321            return;
1322        }
1323    };
1324    let metadata = Dict::new();
1325    metadata
1326        .insert(
1327            Name::new(METADATA_KEY_TYPE).unwrap(),
1328            Capability::Data(Data::String(porcelain_type.to_string())),
1329        )
1330        .expect("failed to build default offer metadata?");
1331    metadata.set_metadata(*offer.availability());
1332    // Offered capabilities need to support default requests in the case of offer-to-dictionary.
1333    // This is a corollary of the fact that program_input_dictionary and
1334    // component_output_dictionary support default requests, and we need this to cover the case
1335    // where the use or expose is from a dictionary.
1336    //
1337    // Technically, we could restrict this to the case of offer-to-dictionary, not offer in
1338    // general. However, supporting the general case simplifies the logic and establishes a nice
1339    // symmetry between program_input_dict, component_output_dict, and {child,collection}_inputs.
1340    let default_request = Request { metadata, target: component.as_weak().into() };
1341    let router = router
1342        .with_availability(component.moniker().clone(), *offer.availability())
1343        .with_default(default_request)
1344        .with_error_reporter(RouteRequestErrorInfo::from(offer), error_reporter)
1345        .with_service_renames_and_filter(offer.clone());
1346    match target_dict.insert_capability(target_name, router.into()) {
1347        Ok(()) => (),
1348        Err(e) => warn!("failed to insert {target_name} into target dict: {e:?}"),
1349    }
1350}
1351
1352pub fn is_supported_expose(expose: &cm_rust::ExposeDecl) -> bool {
1353    matches!(
1354        expose,
1355        cm_rust::ExposeDecl::Config(_)
1356            | cm_rust::ExposeDecl::Protocol(_)
1357            | cm_rust::ExposeDecl::Dictionary(_)
1358            | cm_rust::ExposeDecl::Runner(_)
1359            | cm_rust::ExposeDecl::Resolver(_)
1360            | cm_rust::ExposeDecl::Service(_)
1361    )
1362}
1363
1364fn extend_dict_with_expose<T, C: ComponentInstanceInterface + 'static>(
1365    component: &Arc<C>,
1366    child_component_output_dictionary_routers: &HashMap<ChildName, Router<Dict>>,
1367    program_output_dict: &Dict,
1368    framework_dict: &Dict,
1369    capability_sourced_capabilities_dict: &Dict,
1370    expose: &cm_rust::ExposeDecl,
1371    target_component_output: &ComponentOutput,
1372    error_reporter: impl ErrorReporter,
1373) where
1374    T: CapabilityBound + Clone,
1375    Router<T>: TryFrom<Capability> + Into<Capability>,
1376{
1377    assert!(is_supported_expose(expose), "{expose:?}");
1378
1379    // Exposing to the framework is vestigial
1380    let target_dict = match expose.target() {
1381        cm_rust::ExposeTarget::Parent => target_component_output.capabilities(),
1382        cm_rust::ExposeTarget::Framework => target_component_output.framework(),
1383    };
1384    let source_path = expose.source_path();
1385    let target_name = expose.target_name();
1386
1387    let porcelain_type = CapabilityTypeName::from(expose);
1388    let router: Router<T> = match expose.source() {
1389        cm_rust::ExposeSource::Self_ => program_output_dict
1390            .get_router_or_not_found::<T>(
1391                &source_path,
1392                RoutingError::expose_from_self_not_found(
1393                    &component.moniker(),
1394                    source_path.iter_segments().join("/"),
1395                ),
1396            )
1397            .with_porcelain_type(porcelain_type, component.moniker().clone()),
1398        cm_rust::ExposeSource::Child(child_name) => {
1399            let child_name = ChildName::parse(child_name).expect("invalid static child name");
1400            if let Some(child_component_output) =
1401                child_component_output_dictionary_routers.get(&child_name)
1402            {
1403                let router: Router<T> = child_component_output.clone().lazy_get(
1404                    source_path.to_owned(),
1405                    RoutingError::expose_from_child_expose_not_found(
1406                        &child_name,
1407                        &component.moniker(),
1408                        expose.source_name().clone(),
1409                    ),
1410                );
1411                match expose {
1412                    cm_rust::ExposeDecl::Protocol(_) => {
1413                        router.with_porcelain_type(porcelain_type, component.moniker().clone())
1414                    }
1415                    _ => router,
1416                }
1417            } else {
1418                Router::<T>::new_error(RoutingError::expose_from_child_instance_not_found(
1419                    &child_name,
1420                    &component.moniker(),
1421                    expose.source_name().clone(),
1422                ))
1423            }
1424        }
1425        cm_rust::ExposeSource::Framework => {
1426            if expose.is_from_dictionary() {
1427                warn!(
1428                    "routing from framework with dictionary path is not supported: {source_path}"
1429                );
1430                return;
1431            }
1432            framework_dict
1433                .get_router_or_not_found::<T>(
1434                    &source_path,
1435                    RoutingError::capability_from_framework_not_found(
1436                        &component.moniker(),
1437                        source_path.iter_segments().join("/"),
1438                    ),
1439                )
1440                .with_porcelain_type(porcelain_type, component.moniker().clone())
1441        }
1442        cm_rust::ExposeSource::Capability(capability_name) => {
1443            let err = RoutingError::capability_from_capability_not_found(
1444                &component.moniker(),
1445                capability_name.as_str().to_string(),
1446            );
1447            if source_path.iter_segments().join("/") == fsys::StorageAdminMarker::PROTOCOL_NAME {
1448                capability_sourced_capabilities_dict
1449                    .clone()
1450                    .get_router_or_not_found::<T>(&capability_name, err)
1451            } else {
1452                Router::<T>::new_error(err)
1453            }
1454        }
1455        cm_rust::ExposeSource::Void => UnavailableRouter::new(
1456            InternalCapability::Protocol(expose.source_name().clone()),
1457            component,
1458        ),
1459        // There's nothing in a collection at this stage, and thus we can't get any routers to
1460        // things in the collection. What's more: the contents of the collection can change over
1461        // time, so it must be monitored. We don't handle collections here, they're handled in a
1462        // different way by whoever called `extend_dict_with_expose`.
1463        cm_rust::ExposeSource::Collection(_name) => return,
1464    };
1465    let metadata = Dict::new();
1466    metadata
1467        .insert(
1468            Name::new(METADATA_KEY_TYPE).unwrap(),
1469            Capability::Data(Data::String(porcelain_type.to_string())),
1470        )
1471        .expect("failed to build default expose metadata?");
1472    metadata.set_metadata(*expose.availability());
1473    let default_request = Request { metadata, target: component.as_weak().into() };
1474    match target_dict.insert_capability(
1475        target_name,
1476        router
1477            .with_availability(component.moniker().clone(), *expose.availability())
1478            .with_default(default_request)
1479            .with_error_reporter(RouteRequestErrorInfo::from(expose), error_reporter)
1480            .into(),
1481    ) {
1482        Ok(()) => (),
1483        Err(e) => warn!("failed to insert {target_name} into target_dict: {e:?}"),
1484    }
1485}
1486
1487struct UnavailableRouter<C: ComponentInstanceInterface> {
1488    capability: InternalCapability,
1489    component: WeakComponentInstanceInterface<C>,
1490}
1491
1492impl<C: ComponentInstanceInterface + 'static> UnavailableRouter<C> {
1493    fn new<T: CapabilityBound>(capability: InternalCapability, component: &Arc<C>) -> Router<T> {
1494        Router::<T>::new(UnavailableRouter { capability, component: component.as_weak() })
1495    }
1496}
1497
1498#[async_trait]
1499impl<T: CapabilityBound, C: ComponentInstanceInterface + 'static> Routable<T>
1500    for UnavailableRouter<C>
1501{
1502    async fn route(
1503        &self,
1504        request: Option<Request>,
1505        debug: bool,
1506    ) -> Result<RouterResponse<T>, RouterError> {
1507        if debug {
1508            let data = CapabilitySource::Void(VoidSource {
1509                capability: self.capability.clone(),
1510                moniker: self.component.moniker.clone(),
1511            })
1512            .try_into()
1513            .expect("failed to convert capability source to Data");
1514            return Ok(RouterResponse::<T>::Debug(data));
1515        }
1516        let request = request.ok_or_else(|| RouterError::InvalidArgs)?;
1517        let availability = request.metadata.get_metadata().ok_or(RouterError::InvalidArgs)?;
1518        match availability {
1519            cm_rust::Availability::Required | cm_rust::Availability::SameAsTarget => {
1520                Err(RoutingError::SourceCapabilityIsVoid {
1521                    moniker: self.component.moniker.clone(),
1522                }
1523                .into())
1524            }
1525            cm_rust::Availability::Optional | cm_rust::Availability::Transitional => {
1526                Ok(RouterResponse::Unavailable)
1527            }
1528        }
1529    }
1530}
routing/bedrock/sandbox_construction.rs

routing/bedrock/
sandbox_construction.rs
