fdf_component/
incoming.rs

1// Copyright 2024 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 std::marker::PhantomData;
6
7use anyhow::{anyhow, Context, Error};
8use cm_types::{IterablePath, RelativePath};
9use fidl::endpoints::{DiscoverableProtocolMarker, Proxy, ServiceMarker, ServiceProxy};
10use fidl_fuchsia_io::Flags;
11use fuchsia_component::client::{
12    connect_to_protocol_at_dir_svc, connect_to_service_instance_at_dir_svc,
13};
14use fuchsia_component::directory::{AsRefDirectory, Directory};
15use fuchsia_component::DEFAULT_SERVICE_INSTANCE;
16use namespace::{Entry, Namespace};
17use log::error;
18use zx::Status;
19
20/// Implements access to the incoming namespace for a driver. It provides methods
21/// for accessing incoming protocols and services by either their marker or proxy
22/// types, and can be used as a [`Directory`] with the functions in
23/// [`fuchsia_component::client`].
24pub struct Incoming(Vec<Entry>);
25
26impl Incoming {
27    /// Creates a connector to the given protocol by its marker type. This can be convenient when
28    /// the compiler can't deduce the [`Proxy`] type on its own.
29    ///
30    /// # Example
31    ///
32    /// ```ignore
33    /// let proxy = context.incoming.protocol_marker(fidl_fuchsia_logger::LogSinkMarker).connect()?;
34    /// ```
35    pub fn protocol_marker<M: DiscoverableProtocolMarker>(
36        &self,
37        _marker: M,
38    ) -> ProtocolConnector<'_, M::Proxy> {
39        ProtocolConnector(self, PhantomData)
40    }
41
42    /// Creates a connector to the given protocol by its proxy type. This can be convenient when
43    /// the compiler can deduce the [`Proxy`] type on its own.
44    ///
45    /// # Example
46    ///
47    /// ```ignore
48    /// struct MyProxies {
49    ///     log_sink: fidl_fuchsia_logger::LogSinkProxy,
50    /// }
51    /// let proxies = MyProxies {
52    ///     log_sink: context.incoming.protocol().connect()?;
53    /// };
54    /// ```
55    pub fn protocol<P>(&self) -> ProtocolConnector<'_, P> {
56        ProtocolConnector(self, PhantomData)
57    }
58
59    /// Creates a connector to the given service's default instance by its marker type. This can be
60    /// convenient when the compiler can't deduce the [`ServiceProxy`] type on its own.
61    ///
62    /// See [`ServiceConnector`] for more about what you can do with the connector.
63    ///
64    /// # Example
65    ///
66    /// ```ignore
67    /// let service = context.incoming.service_marker(fidl_fuchsia_hardware_i2c::ServiceMarker).connect()?;
68    /// let device = service.connect_to_device()?;
69    /// ```
70    pub fn service_marker<M: ServiceMarker>(&self, _marker: M) -> ServiceConnector<'_, M::Proxy> {
71        ServiceConnector { incoming: self, instance: DEFAULT_SERVICE_INSTANCE, _p: PhantomData }
72    }
73
74    /// Creates a connector to the given service's default instance by its proxy type. This can be
75    /// convenient when the compiler can deduce the [`ServiceProxy`] type on its own.
76    ///
77    /// See [`ServiceConnector`] for more about what you can do with the connector.
78    ///
79    /// # Example
80    ///
81    /// ```ignore
82    /// struct MyProxies {
83    ///     i2c_service: fidl_fuchsia_hardware_i2c::ServiceProxy,
84    /// }
85    /// let proxies = MyProxies {
86    ///     i2c_service: context.incoming.service().connect()?;
87    /// };
88    /// ```
89    pub fn service<P>(&self) -> ServiceConnector<'_, P> {
90        ServiceConnector { incoming: self, instance: DEFAULT_SERVICE_INSTANCE, _p: PhantomData }
91    }
92}
93
94/// A builder for connecting to a protocol in the driver's incoming namespace.
95pub struct ProtocolConnector<'incoming, Proxy>(&'incoming Incoming, PhantomData<Proxy>);
96
97impl<'a, P: Proxy> ProtocolConnector<'a, P>
98where
99    P::Protocol: DiscoverableProtocolMarker,
100{
101    /// Connects to the service instance's path in the incoming namespace. Logs and returns
102    /// a [`Status::CONNECTION_REFUSED`] if the service instance couldn't be opened.
103    pub fn connect(self) -> Result<P, Status> {
104        connect_to_protocol_at_dir_svc::<P::Protocol>(&self.0).map_err(|e| {
105            error!(
106                "Failed to connect to discoverable protocol `{}`: {e}",
107                P::Protocol::PROTOCOL_NAME
108            );
109            Status::CONNECTION_REFUSED
110        })
111    }
112}
113
114/// A builder for connecting to an aggregated service instance in the driver's incoming namespace.
115/// By default, it will connect to the default instance, named `default`. You can override this
116/// by calling [`Self::instance`].
117pub struct ServiceConnector<'incoming, ServiceProxy> {
118    incoming: &'incoming Incoming,
119    instance: &'incoming str,
120    _p: PhantomData<ServiceProxy>,
121}
122
123impl<'a, S: ServiceProxy> ServiceConnector<'a, S>
124where
125    S::Service: ServiceMarker,
126{
127    /// Overrides the instance name to connect to when [`Self::connect`] is called.
128    pub fn instance(self, instance: &'a str) -> Self {
129        let Self { incoming, _p, .. } = self;
130        Self { incoming, instance, _p }
131    }
132
133    /// Connects to the service instance's path in the incoming namespace. Logs and returns
134    /// a [`Status::CONNECTION_REFUSED`] if the service instance couldn't be opened.
135    pub fn connect(self) -> Result<S, Status> {
136        connect_to_service_instance_at_dir_svc::<S::Service>(self.incoming, self.instance).map_err(
137            |e| {
138                error!(
139                    "Failed to connect to aggregated service connector `{}`, instance `{}`: {e}",
140                    S::Service::SERVICE_NAME,
141                    self.instance
142                );
143                Status::CONNECTION_REFUSED
144            },
145        )
146    }
147}
148
149impl From<Namespace> for Incoming {
150    fn from(value: Namespace) -> Self {
151        Incoming(value.flatten())
152    }
153}
154
155/// Returns the remainder of a prefix match of `prefix` against `self` in terms of path segments.
156///
157/// For example:
158/// ```ignore
159/// match_prefix("pkg/data", "pkg") == Some("/data")
160/// match_prefix("pkg_data", "pkg") == None
161/// ```
162fn match_prefix(match_in: &impl IterablePath, prefix: &impl IterablePath) -> Option<RelativePath> {
163    let mut my_segments = match_in.iter_segments();
164    let mut prefix_segments = prefix.iter_segments();
165    while let Some(prefix) = prefix_segments.next() {
166        if prefix != my_segments.next()? {
167            return None;
168        }
169    }
170    if prefix_segments.next().is_some() {
171        // did not match all prefix segments
172        return None;
173    }
174    let segments = Vec::from_iter(my_segments.cloned());
175    Some(RelativePath::from(segments))
176}
177
178impl Directory for Incoming {
179    fn open(&self, path: &str, flags: Flags, server_end: zx::Channel) -> Result<(), Error> {
180        let path = path.strip_prefix("/").unwrap_or(path);
181        let path = RelativePath::new(path)?;
182
183        for entry in &self.0 {
184            if let Some(remain) = match_prefix(&path, &entry.path) {
185                return entry.directory.open(&format!("/{}", remain), flags, server_end);
186            }
187        }
188        Err(Status::NOT_FOUND)
189            .with_context(|| anyhow!("Path {path} not found in incoming namespace"))
190    }
191}
192
193impl AsRefDirectory for Incoming {
194    fn as_ref_directory(&self) -> &dyn Directory {
195        self
196    }
197}
198
199#[cfg(test)]
200mod tests {
201    use super::*;
202    use cm_types::NamespacePath;
203    use fuchsia_async::Task;
204    use fuchsia_component::server::ServiceFs;
205    use futures::stream::StreamExt;
206
207    enum IncomingServices {
208        I2cDevice(fidl_fuchsia_hardware_i2c::DeviceRequestStream),
209        I2cDefaultService(fidl_fuchsia_hardware_i2c::ServiceRequest),
210        I2cOtherService(fidl_fuchsia_hardware_i2c::ServiceRequest),
211    }
212
213    impl IncomingServices {
214        async fn handle_device_stream(
215            stream: fidl_fuchsia_hardware_i2c::DeviceRequestStream,
216            name: &str,
217        ) {
218            stream
219                .for_each(|msg| async move {
220                    match msg.unwrap() {
221                        fidl_fuchsia_hardware_i2c::DeviceRequest::GetName { responder } => {
222                            responder.send(Ok(name)).unwrap();
223                        }
224                        _ => unimplemented!(),
225                    }
226                })
227                .await
228        }
229
230        async fn handle(self) {
231            use fidl_fuchsia_hardware_i2c::ServiceRequest::*;
232            use IncomingServices::*;
233            match self {
234                I2cDevice(stream) => Self::handle_device_stream(stream, "device").await,
235                I2cDefaultService(Device(stream)) => {
236                    Self::handle_device_stream(stream, "default").await
237                }
238                I2cOtherService(Device(stream)) => {
239                    Self::handle_device_stream(stream, "other").await
240                }
241            }
242        }
243    }
244
245    async fn make_incoming() -> Incoming {
246        let (client, server) = fidl::endpoints::create_endpoints();
247        let mut fs = ServiceFs::new();
248        fs.dir("svc")
249            .add_fidl_service(IncomingServices::I2cDevice)
250            .add_fidl_service_instance("default", IncomingServices::I2cDefaultService)
251            .add_fidl_service_instance("other", IncomingServices::I2cOtherService);
252        fs.serve_connection(server).expect("error serving handle");
253
254        Task::spawn(fs.for_each_concurrent(100, IncomingServices::handle)).detach_on_drop();
255
256        Incoming(vec![Entry { path: NamespacePath::new("/").unwrap(), directory: client }])
257    }
258
259    #[fuchsia::test]
260    async fn protocol_connect_present() -> anyhow::Result<()> {
261        let incoming = make_incoming().await;
262        // try a protocol that we did set up
263        incoming
264            .protocol_marker(fidl_fuchsia_hardware_i2c::DeviceMarker)
265            .connect()?
266            .get_name()
267            .await?
268            .unwrap();
269        incoming
270            .protocol::<fidl_fuchsia_hardware_i2c::DeviceProxy>()
271            .connect()?
272            .get_name()
273            .await?
274            .unwrap();
275        Ok(())
276    }
277
278    #[fuchsia::test]
279    async fn protocol_connect_not_present() -> anyhow::Result<()> {
280        let incoming = make_incoming().await;
281        // try one we didn't
282        incoming
283            .protocol_marker(fidl_fuchsia_hwinfo::DeviceMarker)
284            .connect()?
285            .get_info()
286            .await
287            .unwrap_err();
288        incoming
289            .protocol::<fidl_fuchsia_hwinfo::DeviceProxy>()
290            .connect()?
291            .get_info()
292            .await
293            .unwrap_err();
294        Ok(())
295    }
296
297    #[fuchsia::test]
298    async fn service_connect_default_instance() -> anyhow::Result<()> {
299        let incoming = make_incoming().await;
300        // try the default service instance that we did set up
301        assert_eq!(
302            "default",
303            &incoming
304                .service_marker(fidl_fuchsia_hardware_i2c::ServiceMarker)
305                .connect()?
306                .connect_to_device()?
307                .get_name()
308                .await?
309                .unwrap()
310        );
311        assert_eq!(
312            "default",
313            &incoming
314                .service::<fidl_fuchsia_hardware_i2c::ServiceProxy>()
315                .connect()?
316                .connect_to_device()?
317                .get_name()
318                .await?
319                .unwrap()
320        );
321        Ok(())
322    }
323
324    #[fuchsia::test]
325    async fn service_connect_other_instance() -> anyhow::Result<()> {
326        let incoming = make_incoming().await;
327        // try the other service instance that we did set up
328        assert_eq!(
329            "other",
330            &incoming
331                .service_marker(fidl_fuchsia_hardware_i2c::ServiceMarker)
332                .instance("other")
333                .connect()?
334                .connect_to_device()?
335                .get_name()
336                .await?
337                .unwrap()
338        );
339        assert_eq!(
340            "other",
341            &incoming
342                .service::<fidl_fuchsia_hardware_i2c::ServiceProxy>()
343                .instance("other")
344                .connect()?
345                .connect_to_device()?
346                .get_name()
347                .await?
348                .unwrap()
349        );
350        Ok(())
351    }
352
353    #[fuchsia::test]
354    async fn service_connect_invalid_instance() -> anyhow::Result<()> {
355        let incoming = make_incoming().await;
356        // try the invalid service instance that we did not set up
357        incoming
358            .service_marker(fidl_fuchsia_hardware_i2c::ServiceMarker)
359            .instance("invalid")
360            .connect()?
361            .connect_to_device()?
362            .get_name()
363            .await
364            .unwrap_err();
365        incoming
366            .service::<fidl_fuchsia_hardware_i2c::ServiceProxy>()
367            .instance("invalid")
368            .connect()?
369            .connect_to_device()?
370            .get_name()
371            .await
372            .unwrap_err();
373        Ok(())
374    }
375}
fdf_component/incoming.rs

fdf_component/
incoming.rs
