routing/
mapper.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::RegistrationDecl;
6use cm_rust::{
7    CapabilityDecl, ExposeDecl, ExposeDeclCommon, OfferDecl, OfferDeclCommon, SourceName, UseDecl,
8    UseDeclCommon,
9};
10use cm_types::Name;
11use moniker::Moniker;
12
13#[cfg(feature = "serde")]
14use serde::{Deserialize, Serialize};
15
16/// Describes a single step taken by the capability routing algorithm.
17#[cfg_attr(
18    feature = "serde",
19    derive(Deserialize, Serialize),
20    serde(rename_all = "snake_case", tag = "action")
21)]
22#[derive(Clone, Debug, PartialEq)]
23pub enum RouteSegment {
24    /// The capability was used by a component instance in its manifest.
25    UseBy { moniker: Moniker, capability: UseDecl },
26
27    /// The capability was offered by a component instance in its manifest.
28    OfferBy { moniker: Moniker, capability: OfferDecl },
29
30    /// The capability was exposed by a component instance in its manifest.
31    ExposeBy { moniker: Moniker, capability: ExposeDecl },
32
33    /// The capability was declared by a component instance in its manifest.
34    DeclareBy { moniker: Moniker, capability: CapabilityDecl },
35
36    /// The capability was registered in a component instance's environment in its manifest.
37    RegisterBy { moniker: Moniker, capability: RegistrationDecl },
38
39    /// This is a framework capability served by component manager.
40    ProvideFromFramework { capability: Name },
41
42    /// This is a builtin capability served by component manager.
43    ProvideAsBuiltin { capability: CapabilityDecl },
44
45    /// This is a capability available in component manager's namespace.
46    ProvideFromNamespace { capability: CapabilityDecl },
47}
48
49impl std::fmt::Display for RouteSegment {
50    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
51        match self {
52            Self::UseBy { moniker, capability } => {
53                write!(
54                    f,
55                    "`{}` used `{}` from {}",
56                    moniker,
57                    capability.source_name(),
58                    capability.source()
59                )
60            }
61            Self::OfferBy { moniker, capability } => {
62                write!(
63                    f,
64                    "`{}` offered `{}` from {} to {}",
65                    moniker,
66                    capability.source_name(),
67                    capability.source(),
68                    capability.target()
69                )
70            }
71            Self::ExposeBy { moniker, capability } => {
72                write!(
73                    f,
74                    "`{}` exposed `{}` from {} to {}",
75                    moniker,
76                    capability.source_name(),
77                    capability.source(),
78                    capability.target()
79                )
80            }
81            Self::DeclareBy { moniker, capability } => {
82                write!(f, "`{}` declared capability `{}`", moniker, capability.name())
83            }
84            Self::RegisterBy { moniker, capability } => {
85                write!(f, "`{}` registered capability {:?}", moniker, capability)
86            }
87            Self::ProvideAsBuiltin { capability } => {
88                write!(f, "`{}` is a built-in capability", capability.name())
89            }
90            Self::ProvideFromFramework { capability } => {
91                write!(f, "`{}` is a framework capability", capability)
92            }
93            Self::ProvideFromNamespace { capability } => {
94                write!(f, "`{}` exists in component manager's namespace", capability.name())
95            }
96        }
97    }
98}
99
100impl RouteSegment {
101    /// Get the moniker of the component instance where this segment occurred, if any.
102    pub fn moniker(&self) -> Option<Moniker> {
103        match self {
104            Self::UseBy { moniker, .. }
105            | Self::DeclareBy { moniker, .. }
106            | Self::ExposeBy { moniker, .. }
107            | Self::OfferBy { moniker, .. }
108            | Self::RegisterBy { moniker, .. } => Some(moniker.clone()),
109            _ => None,
110        }
111    }
112}
113
114#[derive(Clone, Debug)]
115pub struct RouteMapper {
116    route: Vec<RouteSegment>,
117}
118
119impl RouteMapper {
120    pub fn new() -> Self {
121        Self { route: vec![] }
122    }
123
124    pub fn get_route(self) -> Vec<RouteSegment> {
125        self.route
126    }
127}
128
129impl DebugRouteMapper for RouteMapper {
130    fn add_use(&mut self, moniker: Moniker, use_decl: &UseDecl) {
131        self.route.push(RouteSegment::UseBy { moniker: moniker, capability: use_decl.clone() })
132    }
133
134    fn add_offer(&mut self, moniker: Moniker, offer_decl: &OfferDecl) {
135        self.route.push(RouteSegment::OfferBy { moniker: moniker, capability: offer_decl.clone() })
136    }
137
138    fn add_expose(&mut self, moniker: Moniker, expose_decl: ExposeDecl) {
139        self.route.push(RouteSegment::ExposeBy { moniker: moniker, capability: expose_decl })
140    }
141
142    fn add_registration(&mut self, moniker: Moniker, registration_decl: &RegistrationDecl) {
143        self.route.push(RouteSegment::RegisterBy {
144            moniker: moniker,
145            capability: registration_decl.clone(),
146        })
147    }
148
149    fn add_component_capability(&mut self, moniker: Moniker, capability_decl: &CapabilityDecl) {
150        self.route
151            .push(RouteSegment::DeclareBy { moniker: moniker, capability: capability_decl.clone() })
152    }
153
154    fn add_framework_capability(&mut self, capability_name: Name) {
155        self.route.push(RouteSegment::ProvideFromFramework { capability: capability_name })
156    }
157
158    fn add_builtin_capability(&mut self, capability_decl: &CapabilityDecl) {
159        self.route.push(RouteSegment::ProvideAsBuiltin { capability: capability_decl.clone() })
160    }
161
162    fn add_namespace_capability(&mut self, capability_decl: &CapabilityDecl) {
163        self.route.push(RouteSegment::ProvideFromNamespace { capability: capability_decl.clone() })
164    }
165}
166
167#[derive(Clone, Debug)]
168pub struct NoopRouteMapper;
169
170impl DebugRouteMapper for NoopRouteMapper {}
171
172/// Provides methods to record and retrieve a summary of a capability route.
173pub trait DebugRouteMapper: Send + Sync {
174    #[allow(unused_variables)]
175    fn add_use(&mut self, moniker: Moniker, use_decl: &UseDecl) {}
176
177    #[allow(unused_variables)]
178    fn add_offer(&mut self, moniker: Moniker, offer_decl: &OfferDecl) {}
179
180    #[allow(unused_variables)]
181    fn add_expose(&mut self, moniker: Moniker, expose_decl: ExposeDecl) {}
182
183    #[allow(unused_variables)]
184    fn add_registration(&mut self, moniker: Moniker, registration_decl: &RegistrationDecl) {}
185
186    #[allow(unused_variables)]
187    fn add_component_capability(&mut self, moniker: Moniker, capability_decl: &CapabilityDecl) {}
188
189    #[allow(unused_variables)]
190    fn add_framework_capability(&mut self, capability_name: Name) {}
191
192    #[allow(unused_variables)]
193    fn add_builtin_capability(&mut self, capability_decl: &CapabilityDecl) {}
194
195    #[allow(unused_variables)]
196    fn add_namespace_capability(&mut self, capability_decl: &CapabilityDecl) {}
197}
routing/mapper.rs

routing/
mapper.rs
