routing/
lib.rs

1// Copyright 2021 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
5pub mod availability;
6pub mod bedrock;
7pub mod capability_source;
8pub mod component_instance;
9pub mod config;
10pub mod environment;
11pub mod error;
12pub mod event;
13pub mod legacy_router;
14pub mod mapper;
15pub mod path;
16pub mod policy;
17pub mod resolving;
18pub mod rights;
19pub mod walk_state;
20
21use crate::bedrock::request_metadata::{
22    dictionary_metadata, protocol_metadata, resolver_metadata, runner_metadata, service_metadata,
23};
24use crate::capability_source::{
25    CapabilitySource, ComponentCapability, ComponentSource, InternalCapability, VoidSource,
26};
27use crate::component_instance::{
28    ComponentInstanceInterface, ResolvedInstanceInterface, WeakComponentInstanceInterface,
29};
30use crate::environment::DebugRegistration;
31use crate::error::RoutingError;
32use crate::legacy_router::{
33    CapabilityVisitor, ErrorNotFoundFromParent, ErrorNotFoundInChild, ExposeVisitor, NoopVisitor,
34    OfferVisitor, RouteBundle, Sources,
35};
36use crate::mapper::DebugRouteMapper;
37use crate::rights::RightsWalker;
38use crate::walk_state::WalkState;
39use cm_rust::{
40    Availability, CapabilityTypeName, ExposeConfigurationDecl, ExposeDecl, ExposeDeclCommon,
41    ExposeDirectoryDecl, ExposeProtocolDecl, ExposeResolverDecl, ExposeRunnerDecl,
42    ExposeServiceDecl, ExposeSource, ExposeTarget, OfferConfigurationDecl, OfferDeclCommon,
43    OfferDictionaryDecl, OfferDirectoryDecl, OfferEventStreamDecl, OfferProtocolDecl,
44    OfferResolverDecl, OfferRunnerDecl, OfferServiceDecl, OfferSource, OfferStorageDecl,
45    OfferTarget, RegistrationDeclCommon, RegistrationSource, ResolverRegistration,
46    RunnerRegistration, SourceName, StorageDecl, StorageDirectorySource, UseConfigurationDecl,
47    UseDecl, UseDeclCommon, UseDirectoryDecl, UseEventStreamDecl, UseProtocolDecl, UseRunnerDecl,
48    UseServiceDecl, UseSource, UseStorageDecl,
49};
50use cm_types::{IterablePath, Name, RelativePath};
51use from_enum::FromEnum;
52use itertools::Itertools;
53use moniker::{ChildName, ExtendedMoniker, Moniker, MonikerError};
54use router_error::Explain;
55use sandbox::{
56    Capability, CapabilityBound, Connector, Data, Dict, DirEntry, Request, Routable, Router,
57    RouterResponse,
58};
59use std::sync::Arc;
60use {fidl_fuchsia_component_decl as fdecl, fidl_fuchsia_io as fio, zx_status as zx};
61
62pub use bedrock::dict_ext::{DictExt, GenericRouterResponse};
63pub use bedrock::lazy_get::LazyGet;
64pub use bedrock::weak_instance_token_ext::{test_invalid_instance_token, WeakInstanceTokenExt};
65pub use bedrock::with_availability::WithAvailability;
66pub use bedrock::with_default::WithDefault;
67pub use bedrock::with_error_reporter::WithErrorReporter;
68
69#[cfg(feature = "serde")]
70use serde::{Deserialize, Serialize};
71
72/// A request to route a capability, together with the data needed to do so.
73#[derive(Clone, Debug)]
74pub enum RouteRequest {
75    // Route a capability from an ExposeDecl.
76    ExposeDirectory(ExposeDirectoryDecl),
77    ExposeProtocol(ExposeProtocolDecl),
78    ExposeService(RouteBundle<ExposeServiceDecl>),
79    ExposeRunner(ExposeRunnerDecl),
80    ExposeResolver(ExposeResolverDecl),
81    ExposeConfig(ExposeConfigurationDecl),
82
83    // Route a capability from a realm's environment.
84    Resolver(ResolverRegistration),
85
86    // Route the directory capability that backs a storage capability.
87    StorageBackingDirectory(StorageDecl),
88
89    // Route a capability from a UseDecl.
90    UseDirectory(UseDirectoryDecl),
91    UseEventStream(UseEventStreamDecl),
92    UseProtocol(UseProtocolDecl),
93    UseService(UseServiceDecl),
94    UseStorage(UseStorageDecl),
95    UseRunner(UseRunnerDecl),
96    UseConfig(UseConfigurationDecl),
97
98    // Route a capability from an OfferDecl.
99    OfferDirectory(OfferDirectoryDecl),
100    OfferEventStream(OfferEventStreamDecl),
101    OfferProtocol(OfferProtocolDecl),
102    OfferService(RouteBundle<OfferServiceDecl>),
103    OfferStorage(OfferStorageDecl),
104    OfferRunner(OfferRunnerDecl),
105    OfferResolver(OfferResolverDecl),
106    OfferConfig(OfferConfigurationDecl),
107    OfferDictionary(OfferDictionaryDecl),
108}
109
110impl From<UseDecl> for RouteRequest {
111    fn from(decl: UseDecl) -> Self {
112        match decl {
113            UseDecl::Directory(decl) => Self::UseDirectory(decl),
114            UseDecl::Protocol(decl) => Self::UseProtocol(decl),
115            UseDecl::Service(decl) => Self::UseService(decl),
116            UseDecl::Storage(decl) => Self::UseStorage(decl),
117            UseDecl::EventStream(decl) => Self::UseEventStream(decl),
118            UseDecl::Runner(decl) => Self::UseRunner(decl),
119            UseDecl::Config(decl) => Self::UseConfig(decl),
120        }
121    }
122}
123
124impl RouteRequest {
125    pub fn from_expose_decls(
126        moniker: &Moniker,
127        exposes: Vec<&ExposeDecl>,
128    ) -> Result<Self, RoutingError> {
129        let first_expose = exposes.first().expect("invalid empty expose list");
130        let first_type_name = CapabilityTypeName::from(*first_expose);
131        assert!(
132            exposes.iter().all(|e| {
133                let type_name: CapabilityTypeName = CapabilityTypeName::from(*e);
134                first_type_name == type_name && first_expose.target_name() == e.target_name()
135            }),
136            "invalid expose input: {:?}",
137            exposes
138        );
139        match first_expose {
140            ExposeDecl::Protocol(e) => {
141                assert!(exposes.len() == 1, "multiple exposes");
142                Ok(Self::ExposeProtocol(e.clone()))
143            }
144            ExposeDecl::Service(_) => {
145                // Gather the exposes into a bundle. Services can aggregate, in which case
146                // multiple expose declarations map to one expose directory entry.
147                let exposes: Vec<_> = exposes
148                    .into_iter()
149                    .filter_map(|e| match e {
150                        cm_rust::ExposeDecl::Service(e) => Some(e.clone()),
151                        _ => None,
152                    })
153                    .collect();
154                Ok(Self::ExposeService(RouteBundle::from_exposes(exposes)))
155            }
156            ExposeDecl::Directory(e) => {
157                assert!(exposes.len() == 1, "multiple exposes");
158                Ok(Self::ExposeDirectory(e.clone()))
159            }
160            ExposeDecl::Runner(e) => {
161                assert!(exposes.len() == 1, "multiple exposes");
162                Ok(Self::ExposeRunner(e.clone()))
163            }
164            ExposeDecl::Resolver(e) => {
165                assert!(exposes.len() == 1, "multiple exposes");
166                Ok(Self::ExposeResolver(e.clone()))
167            }
168            ExposeDecl::Config(e) => {
169                assert!(exposes.len() == 1, "multiple exposes");
170                Ok(Self::ExposeConfig(e.clone()))
171            }
172            ExposeDecl::Dictionary(_) => {
173                // Only bedrock routing supports dictionaries, the legacy RouteRequest does not.
174                Err(RoutingError::unsupported_capability_type(
175                    moniker.clone(),
176                    CapabilityTypeName::Dictionary,
177                ))
178            }
179        }
180    }
181
182    /// Returns the availability of the RouteRequest if supported.
183    pub fn availability(&self) -> Option<Availability> {
184        use crate::RouteRequest::*;
185        match self {
186            UseDirectory(UseDirectoryDecl { availability, .. })
187            | UseEventStream(UseEventStreamDecl { availability, .. })
188            | UseProtocol(UseProtocolDecl { availability, .. })
189            | UseService(UseServiceDecl { availability, .. })
190            | UseConfig(UseConfigurationDecl { availability, .. })
191            | UseStorage(UseStorageDecl { availability, .. }) => Some(*availability),
192
193            ExposeDirectory(decl) => Some(*decl.availability()),
194            ExposeProtocol(decl) => Some(*decl.availability()),
195            ExposeService(decl) => Some(*decl.availability()),
196            ExposeRunner(decl) => Some(*decl.availability()),
197            ExposeResolver(decl) => Some(*decl.availability()),
198            ExposeConfig(decl) => Some(*decl.availability()),
199
200            OfferRunner(decl) => Some(*decl.availability()),
201            OfferResolver(decl) => Some(*decl.availability()),
202            OfferDirectory(decl) => Some(*decl.availability()),
203            OfferEventStream(decl) => Some(*decl.availability()),
204            OfferProtocol(decl) => Some(*decl.availability()),
205            OfferConfig(decl) => Some(*decl.availability()),
206            OfferStorage(decl) => Some(*decl.availability()),
207            OfferDictionary(decl) => Some(*decl.availability()),
208
209            OfferService(_) | Resolver(_) | StorageBackingDirectory(_) | UseRunner(_) => None,
210        }
211    }
212}
213
214impl std::fmt::Display for RouteRequest {
215    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
216        match self {
217            Self::ExposeDirectory(e) => {
218                write!(f, "directory `{}`", e.target_name)
219            }
220            Self::ExposeProtocol(e) => {
221                write!(f, "protocol `{}`", e.target_name)
222            }
223            Self::ExposeService(e) => {
224                write!(f, "service {:?}", e)
225            }
226            Self::ExposeRunner(e) => {
227                write!(f, "runner `{}`", e.target_name)
228            }
229            Self::ExposeResolver(e) => {
230                write!(f, "resolver `{}`", e.target_name)
231            }
232            Self::ExposeConfig(e) => {
233                write!(f, "config `{}`", e.target_name)
234            }
235            Self::Resolver(r) => {
236                write!(f, "resolver `{}`", r.resolver)
237            }
238            Self::UseDirectory(u) => {
239                write!(f, "directory `{}`", u.source_name)
240            }
241            Self::UseProtocol(u) => {
242                write!(f, "protocol `{}`", u.source_name)
243            }
244            Self::UseService(u) => {
245                write!(f, "service `{}`", u.source_name)
246            }
247            Self::UseStorage(u) => {
248                write!(f, "storage `{}`", u.source_name)
249            }
250            Self::UseEventStream(u) => {
251                write!(f, "event stream `{}`", u.source_name)
252            }
253            Self::UseRunner(u) => {
254                write!(f, "runner `{}`", u.source_name)
255            }
256            Self::UseConfig(u) => {
257                write!(f, "config `{}`", u.source_name)
258            }
259            Self::StorageBackingDirectory(u) => {
260                write!(f, "storage backing directory `{}`", u.backing_dir)
261            }
262            Self::OfferDirectory(o) => {
263                write!(f, "directory `{}`", o.target_name)
264            }
265            Self::OfferProtocol(o) => {
266                write!(f, "protocol `{}`", o.target_name)
267            }
268            Self::OfferService(o) => {
269                write!(f, "service {:?}", o)
270            }
271            Self::OfferEventStream(o) => {
272                write!(f, "event stream `{}`", o.target_name)
273            }
274            Self::OfferStorage(o) => {
275                write!(f, "storage `{}`", o.target_name)
276            }
277            Self::OfferResolver(o) => {
278                write!(f, "resolver `{}`", o.target_name)
279            }
280            Self::OfferRunner(o) => {
281                write!(f, "runner `{}`", o.target_name)
282            }
283            Self::OfferConfig(o) => {
284                write!(f, "config `{}`", o.target_name)
285            }
286            Self::OfferDictionary(o) => {
287                write!(f, "dictionary `{}`", o.target_name)
288            }
289        }
290    }
291}
292
293/// The data returned after successfully routing a capability to its source.
294#[derive(Debug)]
295pub struct RouteSource {
296    pub source: CapabilitySource,
297    pub relative_path: RelativePath,
298}
299
300impl RouteSource {
301    pub fn new(source: CapabilitySource) -> Self {
302        Self { source, relative_path: Default::default() }
303    }
304
305    pub fn new_with_relative_path(source: CapabilitySource, relative_path: RelativePath) -> Self {
306        Self { source, relative_path }
307    }
308}
309
310/// Performs a debug route from the `target` for the capability defined in `request`. The source of
311/// the route is returned if the route is valid, otherwise a routing error is returned.
312///
313/// If the capability is not allowed to be routed to the `target`, per the
314/// [`crate::model::policy::GlobalPolicyChecker`], then an error is returned.
315///
316/// This function will only be used for developer tools once the bedrock routing refactor has been
317/// completed, but for now it's the only way to route capabilities which are unsupported in
318/// bedrock.
319///
320/// For capabilities which are not supported in bedrock, the `mapper` is invoked on every step in
321/// the routing process and can be used to record the routing steps. Once all capabilities are
322/// supported in bedrock routing, the `mapper` argument will be removed.
323pub async fn route_capability<C>(
324    request: RouteRequest,
325    target: &Arc<C>,
326    mapper: &mut dyn DebugRouteMapper,
327) -> Result<RouteSource, RoutingError>
328where
329    C: ComponentInstanceInterface + 'static,
330{
331    match request {
332        // Route from an ExposeDecl
333        RouteRequest::ExposeDirectory(expose_directory_decl) => {
334            route_directory_from_expose(expose_directory_decl, target, mapper).await
335        }
336        RouteRequest::ExposeProtocol(expose_protocol_decl) => {
337            let sandbox = target.component_sandbox().await?;
338            let dictionary = match &expose_protocol_decl.target {
339                ExposeTarget::Parent => sandbox.component_output.capabilities(),
340                ExposeTarget::Framework => sandbox.component_output.framework(),
341            };
342            route_capability_inner::<Connector, _>(
343                &dictionary,
344                &expose_protocol_decl.target_name,
345                protocol_metadata(expose_protocol_decl.availability),
346                target,
347            )
348            .await
349        }
350        RouteRequest::ExposeService(expose_bundle) => {
351            let first_expose = expose_bundle.iter().next().expect("can't route empty bundle");
352            route_capability_inner::<DirEntry, _>(
353                &target.component_sandbox().await?.component_output.capabilities(),
354                first_expose.target_name(),
355                service_metadata(*first_expose.availability()),
356                target,
357            )
358            .await
359        }
360        RouteRequest::ExposeRunner(expose_runner_decl) => {
361            let sandbox = target.component_sandbox().await?;
362            let dictionary = match &expose_runner_decl.target {
363                ExposeTarget::Parent => sandbox.component_output.capabilities(),
364                ExposeTarget::Framework => sandbox.component_output.framework(),
365            };
366            route_capability_inner::<Connector, _>(
367                &dictionary,
368                &expose_runner_decl.target_name,
369                runner_metadata(Availability::Required),
370                target,
371            )
372            .await
373        }
374        RouteRequest::ExposeResolver(expose_resolver_decl) => {
375            let sandbox = target.component_sandbox().await?;
376            let dictionary = match &expose_resolver_decl.target {
377                ExposeTarget::Parent => sandbox.component_output.capabilities(),
378                ExposeTarget::Framework => sandbox.component_output.framework(),
379            };
380            route_capability_inner::<Connector, _>(
381                &dictionary,
382                &expose_resolver_decl.target_name,
383                resolver_metadata(Availability::Required),
384                target,
385            )
386            .await
387        }
388        RouteRequest::ExposeConfig(expose_config_decl) => {
389            route_config_from_expose(expose_config_decl, target, mapper).await
390        }
391
392        // Route a resolver or runner from an environment
393        RouteRequest::Resolver(resolver_registration) => {
394            let component_sandbox = target.component_sandbox().await?;
395            let source_dictionary = match &resolver_registration.source {
396                RegistrationSource::Parent => component_sandbox.component_input.capabilities(),
397                RegistrationSource::Self_ => component_sandbox.program_output_dict.clone(),
398                RegistrationSource::Child(static_name) => {
399                    let child_name = ChildName::parse(static_name).expect(
400                        "invalid child name, this should be prevented by manifest validation",
401                    );
402                    let child_component = target.lock_resolved_state().await?.get_child(&child_name).expect("resolver registration references nonexistent static child, this should be prevented by manifest validation");
403                    let child_sandbox = child_component.component_sandbox().await?;
404                    child_sandbox.component_output.capabilities().clone()
405                }
406            };
407            route_capability_inner::<Connector, _>(
408                &source_dictionary,
409                &resolver_registration.resolver,
410                resolver_metadata(Availability::Required),
411                target,
412            )
413            .await
414        }
415        // Route the backing directory for a storage capability
416        RouteRequest::StorageBackingDirectory(storage_decl) => {
417            route_storage_backing_directory(storage_decl, target, mapper).await
418        }
419
420        // Route from a UseDecl
421        RouteRequest::UseDirectory(use_directory_decl) => {
422            route_directory(use_directory_decl, target, mapper).await
423        }
424        RouteRequest::UseEventStream(use_event_stream_decl) => {
425            route_event_stream(use_event_stream_decl, target, mapper).await
426        }
427        RouteRequest::UseProtocol(use_protocol_decl) => {
428            route_capability_inner::<Connector, _>(
429                &target.component_sandbox().await?.program_input.namespace(),
430                &use_protocol_decl.target_path,
431                protocol_metadata(use_protocol_decl.availability),
432                target,
433            )
434            .await
435        }
436        RouteRequest::UseService(use_service_decl) => {
437            route_capability_inner::<DirEntry, _>(
438                &target.component_sandbox().await?.program_input.namespace(),
439                &use_service_decl.target_path,
440                service_metadata(use_service_decl.availability),
441                target,
442            )
443            .await
444        }
445        RouteRequest::UseStorage(use_storage_decl) => {
446            route_storage(use_storage_decl, target, mapper).await
447        }
448        RouteRequest::UseRunner(_use_runner_decl) => {
449            let router =
450                target.component_sandbox().await?.program_input.runner().expect("we have a use declaration for a runner but the program input dictionary has no runner, this should be impossible");
451            perform_route::<Connector, _>(router, runner_metadata(Availability::Required), target)
452                .await
453        }
454        RouteRequest::UseConfig(use_config_decl) => {
455            route_config(use_config_decl, target, mapper).await
456        }
457
458        // Route from a OfferDecl
459        RouteRequest::OfferProtocol(offer_protocol_decl) => {
460            let target_dictionary =
461                get_dictionary_for_offer_target(target, &offer_protocol_decl).await?;
462            let metadata = protocol_metadata(offer_protocol_decl.availability);
463            metadata
464                .insert(
465                    Name::new(crate::bedrock::with_policy_check::SKIP_POLICY_CHECKS).unwrap(),
466                    Capability::Data(Data::Uint64(1)),
467                )
468                .unwrap();
469            route_capability_inner::<Connector, _>(
470                &target_dictionary,
471                &offer_protocol_decl.target_name,
472                metadata,
473                target,
474            )
475            .await
476        }
477        RouteRequest::OfferDictionary(offer_dictionary_decl) => {
478            let target_dictionary =
479                get_dictionary_for_offer_target(target, &offer_dictionary_decl).await?;
480            let metadata = dictionary_metadata(offer_dictionary_decl.availability);
481            metadata
482                .insert(
483                    Name::new(crate::bedrock::with_policy_check::SKIP_POLICY_CHECKS).unwrap(),
484                    Capability::Data(Data::Uint64(1)),
485                )
486                .unwrap();
487            route_capability_inner::<Dict, _>(
488                &target_dictionary,
489                &offer_dictionary_decl.target_name,
490                metadata,
491                target,
492            )
493            .await
494        }
495        RouteRequest::OfferDirectory(offer_directory_decl) => {
496            route_directory_from_offer(offer_directory_decl, target, mapper).await
497        }
498        RouteRequest::OfferStorage(offer_storage_decl) => {
499            route_storage_from_offer(offer_storage_decl, target, mapper).await
500        }
501        RouteRequest::OfferService(offer_service_bundle) => {
502            let first_offer = offer_service_bundle.iter().next().expect("can't route empty bundle");
503            let target_dictionary = get_dictionary_for_offer_target(target, first_offer).await?;
504            let metadata = service_metadata(first_offer.availability);
505            metadata
506                .insert(
507                    Name::new(crate::bedrock::with_policy_check::SKIP_POLICY_CHECKS).unwrap(),
508                    Capability::Data(Data::Uint64(1)),
509                )
510                .unwrap();
511            route_capability_inner::<DirEntry, _>(
512                &target_dictionary,
513                &first_offer.target_name,
514                metadata,
515                target,
516            )
517            .await
518        }
519        RouteRequest::OfferEventStream(offer_event_stream_decl) => {
520            route_event_stream_from_offer(offer_event_stream_decl, target, mapper).await
521        }
522        RouteRequest::OfferRunner(offer_runner_decl) => {
523            let target_dictionary =
524                get_dictionary_for_offer_target(target, &offer_runner_decl).await?;
525            let metadata = runner_metadata(Availability::Required);
526            metadata
527                .insert(
528                    Name::new(crate::bedrock::with_policy_check::SKIP_POLICY_CHECKS).unwrap(),
529                    Capability::Data(Data::Uint64(1)),
530                )
531                .unwrap();
532            route_capability_inner::<Connector, _>(
533                &target_dictionary,
534                &offer_runner_decl.target_name,
535                metadata,
536                target,
537            )
538            .await
539        }
540        RouteRequest::OfferResolver(offer_resolver_decl) => {
541            let target_dictionary =
542                get_dictionary_for_offer_target(target, &offer_resolver_decl).await?;
543            let metadata = resolver_metadata(Availability::Required);
544            metadata
545                .insert(
546                    Name::new(crate::bedrock::with_policy_check::SKIP_POLICY_CHECKS).unwrap(),
547                    Capability::Data(Data::Uint64(1)),
548                )
549                .unwrap();
550            route_capability_inner::<Connector, _>(
551                &target_dictionary,
552                &offer_resolver_decl.target_name,
553                metadata,
554                target,
555            )
556            .await
557        }
558        RouteRequest::OfferConfig(offer) => route_config_from_offer(offer, target, mapper).await,
559    }
560}
561
562pub enum Never {}
563
564async fn route_capability_inner<T, C>(
565    dictionary: &Dict,
566    path: &impl IterablePath,
567    metadata: Dict,
568    target: &Arc<C>,
569) -> Result<RouteSource, RoutingError>
570where
571    C: ComponentInstanceInterface + 'static,
572    T: CapabilityBound,
573    Router<T>: TryFrom<Capability>,
574{
575    let router = dictionary
576        .get_capability(path)
577        .and_then(|c| Router::<T>::try_from(c).ok())
578        .ok_or_else(|| RoutingError::BedrockNotPresentInDictionary {
579            moniker: target.moniker().clone().into(),
580            name: path.iter_segments().join("/"),
581        })?;
582    perform_route::<T, C>(router, metadata, target).await
583}
584
585async fn perform_route<T, C>(
586    router: impl Routable<T>,
587    metadata: Dict,
588    target: &Arc<C>,
589) -> Result<RouteSource, RoutingError>
590where
591    C: ComponentInstanceInterface + 'static,
592    T: CapabilityBound,
593    Router<T>: TryFrom<Capability>,
594{
595    let request = Request { target: WeakComponentInstanceInterface::new(target).into(), metadata };
596    let data = match router.route(Some(request), true).await? {
597        RouterResponse::<T>::Debug(d) => d,
598        _ => panic!("Debug route did not return a debug response"),
599    };
600    Ok(RouteSource::new(data.try_into().unwrap()))
601}
602
603async fn get_dictionary_for_offer_target<C, O>(
604    target: &Arc<C>,
605    offer: &O,
606) -> Result<Dict, RoutingError>
607where
608    C: ComponentInstanceInterface + 'static,
609    O: OfferDeclCommon,
610{
611    match offer.target() {
612        OfferTarget::Child(child_ref) if child_ref.collection.is_none() => {
613            // For static children we can find their inputs in the component's sandbox.
614            let child_input_name = Name::new(child_ref.name.to_string())
615                .map_err(MonikerError::InvalidMonikerPart)
616                .expect("static child names must be short");
617            let target_sandbox = target.component_sandbox().await?;
618            let child_input = target_sandbox.child_inputs.get(&child_input_name).ok_or(
619                RoutingError::OfferFromChildInstanceNotFound {
620                    child_moniker: child_ref.clone().into(),
621                    moniker: target.moniker().clone(),
622                    capability_id: offer.target_name().clone().to_string(),
623                },
624            )?;
625            Ok(child_input.capabilities())
626        }
627        OfferTarget::Child(child_ref) => {
628            // Offers targeting dynamic children are trickier. The input to the dynamic
629            // child wasn't created as part of the parent's sandbox, and dynamic offers
630            // (like the one we're currently looking at) won't have their routes reflected
631            // in the general component input for the collection. To work around this, we
632            // look up the dynamic child from the parent and access its component input
633            // from there. Unlike the code path for static children, this causes the child
634            // to be resolved.
635            let child =
636                target.lock_resolved_state().await?.get_child(&child_ref.clone().into()).ok_or(
637                    RoutingError::OfferFromChildInstanceNotFound {
638                        child_moniker: child_ref.clone().into(),
639                        moniker: target.moniker().clone(),
640                        capability_id: offer.target_name().clone().to_string(),
641                    },
642                )?;
643            Ok(child.component_sandbox().await?.component_input.capabilities())
644        }
645        OfferTarget::Collection(collection_name) => {
646            // Offers targeting collections start at the component input generated for the
647            // collection, which is in the component's sandbox.
648            let target_sandbox = target.component_sandbox().await?;
649            let collection_input = target_sandbox.collection_inputs.get(collection_name).ok_or(
650                RoutingError::OfferFromCollectionNotFound {
651                    collection: collection_name.to_string(),
652                    moniker: target.moniker().clone(),
653                    capability: offer.target_name().clone(),
654                },
655            )?;
656            Ok(collection_input.capabilities())
657        }
658        OfferTarget::Capability(dictionary_name) => {
659            // Offers targeting another capability are for adding the capability to a dictionary
660            // declared by the same component. These dictionaries are stored in the target's
661            // sandbox.
662            let target_sandbox = target.component_sandbox().await?;
663            let capability =
664                target_sandbox.declared_dictionaries.get(dictionary_name).ok().flatten().ok_or(
665                    RoutingError::BedrockNotPresentInDictionary {
666                        name: dictionary_name.to_string(),
667                        moniker: target.moniker().clone().into(),
668                    },
669                )?;
670            match capability {
671                Capability::Dictionary(dictionary) => Ok(dictionary),
672                other_type => Err(RoutingError::BedrockWrongCapabilityType {
673                    actual: other_type.debug_typename().to_string(),
674                    expected: "Dictionary".to_string(),
675                    moniker: target.moniker().clone().into(),
676                }),
677            }
678        }
679    }
680}
681
682/// Routes a Directory capability from `target` to its source, starting from `offer_decl`.
683/// Returns the capability source, along with a `DirectoryState` accumulated from traversing
684/// the route.
685async fn route_directory_from_offer<C>(
686    offer_decl: OfferDirectoryDecl,
687    target: &Arc<C>,
688    mapper: &mut dyn DebugRouteMapper,
689) -> Result<RouteSource, RoutingError>
690where
691    C: ComponentInstanceInterface + 'static,
692{
693    let mut state = DirectoryState {
694        rights: WalkState::new(),
695        subdir: Default::default(),
696        availability_state: offer_decl.availability.into(),
697    };
698    let allowed_sources =
699        Sources::new(CapabilityTypeName::Directory).framework().namespace().component();
700    let source = legacy_router::route_from_offer(
701        RouteBundle::from_offer(offer_decl.into()),
702        target.clone(),
703        allowed_sources,
704        &mut state,
705        mapper,
706    )
707    .await?;
708    Ok(RouteSource::new_with_relative_path(source, state.subdir))
709}
710
711/// Routes an EventStream capability from `target` to its source, starting from `offer_decl`.
712async fn route_event_stream_from_offer<C>(
713    offer_decl: OfferEventStreamDecl,
714    target: &Arc<C>,
715    mapper: &mut dyn DebugRouteMapper,
716) -> Result<RouteSource, RoutingError>
717where
718    C: ComponentInstanceInterface + 'static,
719{
720    let allowed_sources = Sources::new(CapabilityTypeName::EventStream).builtin();
721
722    let mut availability_visitor = offer_decl.availability;
723    let source = legacy_router::route_from_offer(
724        RouteBundle::from_offer(offer_decl.into()),
725        target.clone(),
726        allowed_sources,
727        &mut availability_visitor,
728        mapper,
729    )
730    .await?;
731    Ok(RouteSource::new(source))
732}
733
734async fn route_storage_from_offer<C>(
735    offer_decl: OfferStorageDecl,
736    target: &Arc<C>,
737    mapper: &mut dyn DebugRouteMapper,
738) -> Result<RouteSource, RoutingError>
739where
740    C: ComponentInstanceInterface + 'static,
741{
742    let mut availability_visitor = offer_decl.availability;
743    let allowed_sources = Sources::new(CapabilityTypeName::Storage).component();
744    let source = legacy_router::route_from_offer(
745        RouteBundle::from_offer(offer_decl.into()),
746        target.clone(),
747        allowed_sources,
748        &mut availability_visitor,
749        mapper,
750    )
751    .await?;
752    Ok(RouteSource::new(source))
753}
754
755async fn route_config_from_offer<C>(
756    offer_decl: OfferConfigurationDecl,
757    target: &Arc<C>,
758    mapper: &mut dyn DebugRouteMapper,
759) -> Result<RouteSource, RoutingError>
760where
761    C: ComponentInstanceInterface + 'static,
762{
763    let allowed_sources = Sources::new(CapabilityTypeName::Config).builtin().component();
764    let source = legacy_router::route_from_offer(
765        RouteBundle::from_offer(offer_decl.into()),
766        target.clone(),
767        allowed_sources,
768        &mut NoopVisitor::new(),
769        mapper,
770    )
771    .await?;
772    Ok(RouteSource::new(source))
773}
774
775async fn route_config_from_expose<C>(
776    expose_decl: ExposeConfigurationDecl,
777    target: &Arc<C>,
778    mapper: &mut dyn DebugRouteMapper,
779) -> Result<RouteSource, RoutingError>
780where
781    C: ComponentInstanceInterface + 'static,
782{
783    let allowed_sources = Sources::new(CapabilityTypeName::Config).component().capability();
784    let source = legacy_router::route_from_expose(
785        RouteBundle::from_expose(expose_decl.into()),
786        target.clone(),
787        allowed_sources,
788        &mut NoopVisitor::new(),
789        mapper,
790    )
791    .await?;
792
793    target.policy_checker().can_route_capability(&source, target.moniker())?;
794    Ok(RouteSource::new(source))
795}
796
797/// The accumulated state of routing a Directory capability.
798#[derive(Clone, Debug)]
799pub struct DirectoryState {
800    rights: WalkState<RightsWalker>,
801    pub subdir: RelativePath,
802    availability_state: Availability,
803}
804
805impl DirectoryState {
806    fn new(rights: RightsWalker, subdir: RelativePath, availability: &Availability) -> Self {
807        DirectoryState {
808            rights: WalkState::at(rights),
809            subdir,
810            availability_state: availability.clone(),
811        }
812    }
813
814    fn advance_with_offer(
815        &mut self,
816        moniker: &ExtendedMoniker,
817        offer: &OfferDirectoryDecl,
818    ) -> Result<(), RoutingError> {
819        self.availability_state =
820            availability::advance_with_offer(moniker, self.availability_state, offer)?;
821        self.advance(moniker, offer.rights.clone(), offer.subdir.clone())
822    }
823
824    fn advance_with_expose(
825        &mut self,
826        moniker: &ExtendedMoniker,
827        expose: &ExposeDirectoryDecl,
828    ) -> Result<(), RoutingError> {
829        self.availability_state =
830            availability::advance_with_expose(moniker, self.availability_state, expose)?;
831        self.advance(moniker, expose.rights.clone(), expose.subdir.clone())
832    }
833
834    fn advance(
835        &mut self,
836        moniker: &ExtendedMoniker,
837        rights: Option<fio::Operations>,
838        mut subdir: RelativePath,
839    ) -> Result<(), RoutingError> {
840        self.rights = self.rights.advance(rights.map(|r| RightsWalker::new(r, moniker.clone())))?;
841        subdir.extend(self.subdir.clone());
842        self.subdir = subdir;
843        Ok(())
844    }
845
846    fn finalize(
847        &mut self,
848        rights: RightsWalker,
849        mut subdir: RelativePath,
850    ) -> Result<(), RoutingError> {
851        self.rights = self.rights.finalize(Some(rights))?;
852        subdir.extend(self.subdir.clone());
853        self.subdir = subdir;
854        Ok(())
855    }
856}
857
858impl OfferVisitor for DirectoryState {
859    fn visit(
860        &mut self,
861        moniker: &ExtendedMoniker,
862        offer: &cm_rust::OfferDecl,
863    ) -> Result<(), RoutingError> {
864        match offer {
865            cm_rust::OfferDecl::Directory(dir) => match dir.source {
866                OfferSource::Framework => self.finalize(
867                    RightsWalker::new(fio::RX_STAR_DIR, moniker.clone()),
868                    dir.subdir.clone(),
869                ),
870                _ => self.advance_with_offer(moniker, dir),
871            },
872            _ => Ok(()),
873        }
874    }
875}
876
877impl ExposeVisitor for DirectoryState {
878    fn visit(
879        &mut self,
880        moniker: &ExtendedMoniker,
881        expose: &cm_rust::ExposeDecl,
882    ) -> Result<(), RoutingError> {
883        match expose {
884            cm_rust::ExposeDecl::Directory(dir) => match dir.source {
885                ExposeSource::Framework => self.finalize(
886                    RightsWalker::new(fio::RX_STAR_DIR, moniker.clone()),
887                    dir.subdir.clone(),
888                ),
889                _ => self.advance_with_expose(moniker, dir),
890            },
891            _ => Ok(()),
892        }
893    }
894}
895
896impl CapabilityVisitor for DirectoryState {
897    fn visit(
898        &mut self,
899        moniker: &ExtendedMoniker,
900        capability: &cm_rust::CapabilityDecl,
901    ) -> Result<(), RoutingError> {
902        match capability {
903            cm_rust::CapabilityDecl::Directory(dir) => {
904                self.finalize(RightsWalker::new(dir.rights, moniker.clone()), Default::default())
905            }
906            _ => Ok(()),
907        }
908    }
909}
910
911/// Routes a Directory capability from `target` to its source, starting from `use_decl`.
912/// Returns the capability source, along with a `DirectoryState` accumulated from traversing
913/// the route.
914async fn route_directory<C>(
915    use_decl: UseDirectoryDecl,
916    target: &Arc<C>,
917    mapper: &mut dyn DebugRouteMapper,
918) -> Result<RouteSource, RoutingError>
919where
920    C: ComponentInstanceInterface + 'static,
921{
922    match use_decl.source {
923        UseSource::Self_ => {
924            let mut availability_visitor = use_decl.availability;
925            let allowed_sources = Sources::new(CapabilityTypeName::Dictionary).component();
926            let source = legacy_router::route_from_self(
927                use_decl.into(),
928                target.clone(),
929                allowed_sources,
930                &mut availability_visitor,
931                mapper,
932            )
933            .await?;
934            Ok(RouteSource::new(source))
935        }
936        _ => {
937            let mut state = DirectoryState::new(
938                RightsWalker::new(use_decl.rights, target.moniker().clone()),
939                use_decl.subdir.clone(),
940                &use_decl.availability,
941            );
942            if let UseSource::Framework = &use_decl.source {
943                state.finalize(
944                    RightsWalker::new(fio::RX_STAR_DIR, target.moniker().clone()),
945                    Default::default(),
946                )?;
947            }
948            let allowed_sources =
949                Sources::new(CapabilityTypeName::Directory).framework().namespace().component();
950            let source = legacy_router::route_from_use(
951                use_decl.into(),
952                target.clone(),
953                allowed_sources,
954                &mut state,
955                mapper,
956            )
957            .await?;
958
959            target.policy_checker().can_route_capability(&source, target.moniker())?;
960            Ok(RouteSource::new_with_relative_path(source, state.subdir))
961        }
962    }
963}
964
965/// Routes a Directory capability from `target` to its source, starting from `expose_decl`.
966/// Returns the capability source, along with a `DirectoryState` accumulated from traversing
967/// the route.
968async fn route_directory_from_expose<C>(
969    expose_decl: ExposeDirectoryDecl,
970    target: &Arc<C>,
971    mapper: &mut dyn DebugRouteMapper,
972) -> Result<RouteSource, RoutingError>
973where
974    C: ComponentInstanceInterface + 'static,
975{
976    let mut state = DirectoryState {
977        rights: WalkState::new(),
978        subdir: Default::default(),
979        availability_state: expose_decl.availability.into(),
980    };
981    let allowed_sources =
982        Sources::new(CapabilityTypeName::Directory).framework().namespace().component();
983    let source = legacy_router::route_from_expose(
984        RouteBundle::from_expose(expose_decl.into()),
985        target.clone(),
986        allowed_sources,
987        &mut state,
988        mapper,
989    )
990    .await?;
991
992    target.policy_checker().can_route_capability(&source, target.moniker())?;
993    Ok(RouteSource::new_with_relative_path(source, state.subdir))
994}
995
996/// Verifies that the given component is in the index if its `storage_id` is StaticInstanceId.
997/// - On success, Ok(()) is returned
998/// - RoutingError::ComponentNotInIndex is returned on failure.
999pub async fn verify_instance_in_component_id_index<C>(
1000    source: &CapabilitySource,
1001    instance: &Arc<C>,
1002) -> Result<(), RoutingError>
1003where
1004    C: ComponentInstanceInterface + 'static,
1005{
1006    let (storage_decl, source_moniker) = match source {
1007        CapabilitySource::Component(ComponentSource {
1008            capability: ComponentCapability::Storage(storage_decl),
1009            moniker,
1010        }) => (storage_decl, moniker.clone()),
1011        CapabilitySource::Void(VoidSource { .. }) => return Ok(()),
1012        _ => unreachable!("unexpected storage source"),
1013    };
1014
1015    if storage_decl.storage_id == fdecl::StorageId::StaticInstanceId
1016        && instance.component_id_index().id_for_moniker(instance.moniker()).is_none()
1017    {
1018        return Err(RoutingError::ComponentNotInIdIndex {
1019            source_moniker,
1020            target_name: instance.moniker().leaf().cloned(),
1021        });
1022    }
1023    Ok(())
1024}
1025
1026/// Routes a Storage capability from `target` to its source, starting from `use_decl`.
1027/// Returns the StorageDecl and the storage component's instance.
1028pub async fn route_to_storage_decl<C>(
1029    use_decl: UseStorageDecl,
1030    target: &Arc<C>,
1031    mapper: &mut dyn DebugRouteMapper,
1032) -> Result<CapabilitySource, RoutingError>
1033where
1034    C: ComponentInstanceInterface + 'static,
1035{
1036    let mut availability_visitor = use_decl.availability;
1037    let allowed_sources = Sources::new(CapabilityTypeName::Storage).component();
1038    let source = legacy_router::route_from_use(
1039        use_decl.into(),
1040        target.clone(),
1041        allowed_sources,
1042        &mut availability_visitor,
1043        mapper,
1044    )
1045    .await?;
1046    Ok(source)
1047}
1048
1049/// Routes a Storage capability from `target` to its source, starting from `use_decl`.
1050/// The backing Directory capability is then routed to its source.
1051async fn route_storage<C>(
1052    use_decl: UseStorageDecl,
1053    target: &Arc<C>,
1054    mapper: &mut dyn DebugRouteMapper,
1055) -> Result<RouteSource, RoutingError>
1056where
1057    C: ComponentInstanceInterface + 'static,
1058{
1059    let source = route_to_storage_decl(use_decl, &target, mapper).await?;
1060    verify_instance_in_component_id_index(&source, target).await?;
1061    target.policy_checker().can_route_capability(&source, target.moniker())?;
1062    Ok(RouteSource::new(source))
1063}
1064
1065/// Routes the backing Directory capability of a Storage capability from `target` to its source,
1066/// starting from `storage_decl`.
1067async fn route_storage_backing_directory<C>(
1068    storage_decl: StorageDecl,
1069    target: &Arc<C>,
1070    mapper: &mut dyn DebugRouteMapper,
1071) -> Result<RouteSource, RoutingError>
1072where
1073    C: ComponentInstanceInterface + 'static,
1074{
1075    // Storage rights are always READ+WRITE.
1076    let mut state = DirectoryState::new(
1077        RightsWalker::new(fio::RW_STAR_DIR, target.moniker().clone()),
1078        Default::default(),
1079        &Availability::Required,
1080    );
1081    let allowed_sources = Sources::new(CapabilityTypeName::Directory).component().namespace();
1082    let source = legacy_router::route_from_registration(
1083        StorageDeclAsRegistration::from(storage_decl.clone()),
1084        target.clone(),
1085        allowed_sources,
1086        &mut state,
1087        mapper,
1088    )
1089    .await?;
1090
1091    target.policy_checker().can_route_capability(&source, target.moniker())?;
1092
1093    Ok(RouteSource::new_with_relative_path(source, state.subdir))
1094}
1095
1096/// Finds a Configuration capability that matches the given use.
1097async fn route_config<C>(
1098    use_decl: UseConfigurationDecl,
1099    target: &Arc<C>,
1100    mapper: &mut dyn DebugRouteMapper,
1101) -> Result<RouteSource, RoutingError>
1102where
1103    C: ComponentInstanceInterface + 'static,
1104{
1105    let allowed_sources = Sources::new(CapabilityTypeName::Config).component().capability();
1106    let mut availability_visitor = use_decl.availability().clone();
1107    let source = legacy_router::route_from_use(
1108        use_decl.clone().into(),
1109        target.clone(),
1110        allowed_sources,
1111        &mut availability_visitor,
1112        mapper,
1113    )
1114    .await;
1115    // If the route was not found, but it's a transitional availability then return
1116    // a successful Void capability.
1117    let source = match source {
1118        Ok(s) => s,
1119        Err(e) => {
1120            if *use_decl.availability() == Availability::Transitional
1121                && e.as_zx_status() == zx::Status::NOT_FOUND
1122            {
1123                CapabilitySource::Void(VoidSource {
1124                    capability: InternalCapability::Config(use_decl.source_name),
1125                    moniker: target.moniker().clone(),
1126                })
1127            } else {
1128                return Err(e);
1129            }
1130        }
1131    };
1132
1133    target.policy_checker().can_route_capability(&source, target.moniker())?;
1134    Ok(RouteSource::new(source))
1135}
1136
1137/// Routes an EventStream capability from `target` to its source, starting from `use_decl`.
1138///
1139/// If the capability is not allowed to be routed to the `target`, per the
1140/// [`crate::model::policy::GlobalPolicyChecker`], then an error is returned.
1141pub async fn route_event_stream<C>(
1142    use_decl: UseEventStreamDecl,
1143    target: &Arc<C>,
1144    mapper: &mut dyn DebugRouteMapper,
1145) -> Result<RouteSource, RoutingError>
1146where
1147    C: ComponentInstanceInterface + 'static,
1148{
1149    let allowed_sources = Sources::new(CapabilityTypeName::EventStream).builtin();
1150    let mut availability_visitor = use_decl.availability;
1151    let source = legacy_router::route_from_use(
1152        use_decl.into(),
1153        target.clone(),
1154        allowed_sources,
1155        &mut availability_visitor,
1156        mapper,
1157    )
1158    .await?;
1159    target.policy_checker().can_route_capability(&source, target.moniker())?;
1160    Ok(RouteSource::new(source))
1161}
1162
1163/// Intermediate type to masquerade as Registration-style routing start point for the storage
1164/// backing directory capability.
1165#[cfg_attr(feature = "serde", derive(Deserialize, Serialize), serde(rename_all = "snake_case"))]
1166#[derive(Debug, Clone, PartialEq, Eq)]
1167pub struct StorageDeclAsRegistration {
1168    source: RegistrationSource,
1169    name: Name,
1170}
1171
1172impl From<StorageDecl> for StorageDeclAsRegistration {
1173    fn from(decl: StorageDecl) -> Self {
1174        Self {
1175            name: decl.backing_dir,
1176            source: match decl.source {
1177                StorageDirectorySource::Parent => RegistrationSource::Parent,
1178                StorageDirectorySource::Self_ => RegistrationSource::Self_,
1179                StorageDirectorySource::Child(child) => RegistrationSource::Child(child),
1180            },
1181        }
1182    }
1183}
1184
1185impl SourceName for StorageDeclAsRegistration {
1186    fn source_name(&self) -> &Name {
1187        &self.name
1188    }
1189}
1190
1191impl RegistrationDeclCommon for StorageDeclAsRegistration {
1192    const TYPE: &'static str = "storage";
1193
1194    fn source(&self) -> &RegistrationSource {
1195        &self.source
1196    }
1197}
1198
1199/// An umbrella type for registration decls, making it more convenient to record route
1200/// maps for debug use.
1201#[cfg_attr(feature = "serde", derive(Deserialize, Serialize), serde(rename_all = "snake_case"))]
1202#[derive(FromEnum, Debug, Clone, PartialEq, Eq)]
1203pub enum RegistrationDecl {
1204    Resolver(ResolverRegistration),
1205    Runner(RunnerRegistration),
1206    Debug(DebugRegistration),
1207    Directory(StorageDeclAsRegistration),
1208}
1209
1210impl From<&RegistrationDecl> for cm_rust::CapabilityTypeName {
1211    fn from(registration: &RegistrationDecl) -> Self {
1212        match registration {
1213            RegistrationDecl::Directory(_) => Self::Directory,
1214            RegistrationDecl::Resolver(_) => Self::Resolver,
1215            RegistrationDecl::Runner(_) => Self::Runner,
1216            RegistrationDecl::Debug(_) => Self::Protocol,
1217        }
1218    }
1219}
1220
1221// Error trait impls
1222
1223impl ErrorNotFoundFromParent for cm_rust::UseDecl {
1224    fn error_not_found_from_parent(moniker: Moniker, capability_name: Name) -> RoutingError {
1225        RoutingError::UseFromParentNotFound { moniker, capability_id: capability_name.into() }
1226    }
1227}
1228
1229impl ErrorNotFoundFromParent for DebugRegistration {
1230    fn error_not_found_from_parent(moniker: Moniker, capability_name: Name) -> RoutingError {
1231        RoutingError::EnvironmentFromParentNotFound {
1232            moniker,
1233            capability_name,
1234            capability_type: DebugRegistration::TYPE.to_string(),
1235        }
1236    }
1237}
1238
1239impl ErrorNotFoundInChild for DebugRegistration {
1240    fn error_not_found_in_child(
1241        moniker: Moniker,
1242        child_moniker: ChildName,
1243        capability_name: Name,
1244    ) -> RoutingError {
1245        RoutingError::EnvironmentFromChildExposeNotFound {
1246            moniker,
1247            child_moniker,
1248            capability_name,
1249            capability_type: DebugRegistration::TYPE.to_string(),
1250        }
1251    }
1252}
1253
1254impl ErrorNotFoundInChild for cm_rust::UseDecl {
1255    fn error_not_found_in_child(
1256        moniker: Moniker,
1257        child_moniker: ChildName,
1258        capability_name: Name,
1259    ) -> RoutingError {
1260        RoutingError::UseFromChildExposeNotFound {
1261            child_moniker,
1262            moniker,
1263            capability_id: capability_name.into(),
1264        }
1265    }
1266}
1267
1268impl ErrorNotFoundInChild for cm_rust::ExposeDecl {
1269    fn error_not_found_in_child(
1270        moniker: Moniker,
1271        child_moniker: ChildName,
1272        capability_name: Name,
1273    ) -> RoutingError {
1274        RoutingError::ExposeFromChildExposeNotFound {
1275            moniker,
1276            child_moniker,
1277            capability_id: capability_name.into(),
1278        }
1279    }
1280}
1281
1282impl ErrorNotFoundInChild for cm_rust::OfferDecl {
1283    fn error_not_found_in_child(
1284        moniker: Moniker,
1285        child_moniker: ChildName,
1286        capability_name: Name,
1287    ) -> RoutingError {
1288        RoutingError::OfferFromChildExposeNotFound {
1289            moniker,
1290            child_moniker,
1291            capability_id: capability_name.into(),
1292        }
1293    }
1294}
1295
1296impl ErrorNotFoundFromParent for cm_rust::OfferDecl {
1297    fn error_not_found_from_parent(moniker: Moniker, capability_name: Name) -> RoutingError {
1298        RoutingError::OfferFromParentNotFound { moniker, capability_id: capability_name.into() }
1299    }
1300}
1301
1302impl ErrorNotFoundInChild for StorageDeclAsRegistration {
1303    fn error_not_found_in_child(
1304        moniker: Moniker,
1305        child_moniker: ChildName,
1306        capability_name: Name,
1307    ) -> RoutingError {
1308        RoutingError::StorageFromChildExposeNotFound {
1309            moniker,
1310            child_moniker,
1311            capability_id: capability_name.into(),
1312        }
1313    }
1314}
1315
1316impl ErrorNotFoundFromParent for StorageDeclAsRegistration {
1317    fn error_not_found_from_parent(moniker: Moniker, capability_name: Name) -> RoutingError {
1318        RoutingError::StorageFromParentNotFound { moniker, capability_id: capability_name.into() }
1319    }
1320}
1321
1322impl ErrorNotFoundFromParent for RunnerRegistration {
1323    fn error_not_found_from_parent(moniker: Moniker, capability_name: Name) -> RoutingError {
1324        RoutingError::UseFromEnvironmentNotFound {
1325            moniker,
1326            capability_name,
1327            capability_type: "runner".to_string(),
1328        }
1329    }
1330}
1331
1332impl ErrorNotFoundInChild for RunnerRegistration {
1333    fn error_not_found_in_child(
1334        moniker: Moniker,
1335        child_moniker: ChildName,
1336        capability_name: Name,
1337    ) -> RoutingError {
1338        RoutingError::EnvironmentFromChildExposeNotFound {
1339            moniker,
1340            child_moniker,
1341            capability_name,
1342            capability_type: "runner".to_string(),
1343        }
1344    }
1345}
1346
1347impl ErrorNotFoundFromParent for ResolverRegistration {
1348    fn error_not_found_from_parent(moniker: Moniker, capability_name: Name) -> RoutingError {
1349        RoutingError::EnvironmentFromParentNotFound {
1350            moniker,
1351            capability_name,
1352            capability_type: "resolver".to_string(),
1353        }
1354    }
1355}
1356
1357impl ErrorNotFoundInChild for ResolverRegistration {
1358    fn error_not_found_in_child(
1359        moniker: Moniker,
1360        child_moniker: ChildName,
1361        capability_name: Name,
1362    ) -> RoutingError {
1363        RoutingError::EnvironmentFromChildExposeNotFound {
1364            moniker,
1365            child_moniker,
1366            capability_name,
1367            capability_type: "resolver".to_string(),
1368        }
1369    }
1370}
routing/lib.rs

routing/
lib.rs
