settings/
service_context.rs

1// Copyright 2019 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::event::{Event, Publisher};
6use crate::message::base::MessengerType;
7use crate::{clock, service};
8use anyhow::{format_err, Error};
9use fidl::endpoints::{DiscoverableProtocolMarker, ProtocolMarker, Proxy};
10use fuchsia_async as fasync;
11use fuchsia_component::client::{connect_to_protocol, connect_to_protocol_at_path};
12use futures::future::{LocalBoxFuture, OptionFuture};
13use glob::glob;
14use std::borrow::Cow;
15use std::fmt::Debug;
16use std::future::Future;
17
18pub type GenerateService =
19    Box<dyn Fn(&str, zx::Channel) -> LocalBoxFuture<'static, Result<(), Error>>>;
20
21/// A wrapper around service operations, allowing redirection to a nested
22/// environment.
23pub struct ServiceContext {
24    generate_service: Option<GenerateService>,
25    delegate: Option<service::message::Delegate>,
26}
27
28impl ServiceContext {
29    pub(crate) fn new(
30        generate_service: Option<GenerateService>,
31        delegate: Option<service::message::Delegate>,
32    ) -> Self {
33        Self { generate_service, delegate }
34    }
35
36    async fn make_publisher(&self) -> Option<Publisher> {
37        let maybe: OptionFuture<_> = self
38            .delegate
39            .as_ref()
40            .map(|delegate| Publisher::create(delegate, MessengerType::Unbound))
41            .into();
42        maybe.await
43    }
44
45    /// Connect to a service with the given ProtocolMarker.
46    ///
47    /// If a GenerateService was specified at creation, the name of the service marker will be used
48    /// to generate a service.
49    pub(crate) async fn connect<P: DiscoverableProtocolMarker>(
50        &self,
51    ) -> Result<ExternalServiceProxy<P::Proxy>, Error> {
52        let proxy = if let Some(generate_service) = &self.generate_service {
53            let (client, server) = zx::Channel::create();
54            ((generate_service)(P::PROTOCOL_NAME, server)).await?;
55            P::Proxy::from_channel(fasync::Channel::from_channel(client))
56        } else {
57            connect_to_protocol::<P>()?
58        };
59
60        let publisher = self.make_publisher().await;
61        let external_proxy = ExternalServiceProxy::new(proxy, publisher.clone());
62        if let Some(p) = publisher {
63            let timestamp = clock::inspect_format_now();
64            p.send_event(Event::ExternalServiceEvent(ExternalServiceEvent::Created(
65                P::PROTOCOL_NAME,
66                timestamp.into(),
67            )));
68        }
69
70        Ok(external_proxy)
71    }
72
73    pub(crate) async fn connect_with_publisher<P: DiscoverableProtocolMarker>(
74        &self,
75        publisher: Publisher,
76    ) -> Result<ExternalServiceProxy<P::Proxy>, Error> {
77        let proxy = if let Some(generate_service) = &self.generate_service {
78            let (client, server) = zx::Channel::create();
79            ((generate_service)(P::PROTOCOL_NAME, server)).await?;
80            P::Proxy::from_channel(fasync::Channel::from_channel(client))
81        } else {
82            connect_to_protocol::<P>()?
83        };
84
85        let external_proxy = ExternalServiceProxy::new(proxy, Some(publisher.clone()));
86        publisher.send_event(Event::ExternalServiceEvent(ExternalServiceEvent::Created(
87            P::PROTOCOL_NAME,
88            clock::inspect_format_now().into(),
89        )));
90
91        Ok(external_proxy)
92    }
93
94    /// Connect to a service by discovering a hardware device at the given glob-style pattern.
95    ///
96    /// The first discovered path will be used to connected.
97    ///
98    /// If a GenerateService was specified at creation, the name of the service marker will be used
99    /// to generate a service and the path will be ignored.
100    pub(crate) async fn connect_device_path<P: DiscoverableProtocolMarker>(
101        &self,
102        glob_pattern: &str,
103    ) -> Result<ExternalServiceProxy<P::Proxy>, Error> {
104        if self.generate_service.is_some() {
105            // If a generate_service is already specified, just connect through there
106            return self.connect::<P>().await;
107        }
108
109        let found_path = glob(glob_pattern)?
110            .filter_map(|entry| entry.ok())
111            .next()
112            .ok_or_else(|| format_err!("failed to enumerate devices"))?;
113
114        let path_str =
115            found_path.to_str().ok_or_else(|| format_err!("failed to convert path to str"))?;
116
117        let publisher = self.make_publisher().await;
118        let external_proxy = ExternalServiceProxy::new(
119            connect_to_protocol_at_path::<P>(path_str)?,
120            publisher.clone(),
121        );
122        if let Some(p) = publisher {
123            p.send_event(Event::ExternalServiceEvent(ExternalServiceEvent::Created(
124                P::DEBUG_NAME,
125                clock::inspect_format_now().into(),
126            )));
127        }
128
129        Ok(external_proxy)
130    }
131}
132
133/// Definition of events related to external api calls outside of the setting service.
134#[derive(Clone, Debug, Eq, PartialEq)]
135pub enum ExternalServiceEvent {
136    /// Event sent when an external service proxy is created. Contains
137    /// the protocol name and the timestamp at which the connection
138    /// was created.
139    Created(
140        &'static str,      // Protocol
141        Cow<'static, str>, // Timestamp
142    ),
143
144    /// Event sent when a call is made on an external service proxy.
145    /// Contains the protocol name, the stringified request, and the
146    /// request timestamp.
147    ApiCall(
148        &'static str,      // Protocol
149        Cow<'static, str>, // Request
150        Cow<'static, str>, // Request timestamp
151    ),
152
153    /// Event sent when a non-error response is received on an external
154    /// service proxy. Contains the protocol name, the response, the
155    /// associated stringified request, and the request/response timestamps.
156    ApiResponse(
157        &'static str,      // Protocol
158        Cow<'static, str>, // Response
159        Cow<'static, str>, // Request
160        Cow<'static, str>, // Request Timestamp
161        Cow<'static, str>, // Response timestamp
162    ),
163
164    /// Event sent when an error is received on an external service proxy.
165    /// Contains the protocol name, the error message, the associated
166    /// stringified request, and the request/response timestamps.
167    ApiError(
168        &'static str,      // Protocol
169        Cow<'static, str>, // Error msg
170        Cow<'static, str>, // Request
171        Cow<'static, str>, // Request timestamp
172        Cow<'static, str>, // Error timestamp
173    ),
174
175    /// Event sent when an external service proxy is closed. Contains the
176    /// protocol name, the associated stringified request, and the
177    /// request/response timestamps.
178    Closed(
179        &'static str,      // Protocol
180        Cow<'static, str>, // Request
181        Cow<'static, str>, // Request timestamp
182        Cow<'static, str>, // Response timestamp
183    ),
184}
185
186/// A wrapper around a proxy, used to track disconnections.
187///
188/// This wraps any type implementing `Proxy`. Whenever any call returns a
189/// `ClientChannelClosed` error, this wrapper publishes a closed event for
190/// the wrapped proxy.
191#[derive(Clone, Debug)]
192pub struct ExternalServiceProxy<P>
193where
194    P: Proxy,
195{
196    proxy: P,
197    publisher: Option<Publisher>,
198}
199
200impl<P> ExternalServiceProxy<P>
201where
202    P: Proxy,
203{
204    pub(crate) fn new(proxy: P, publisher: Option<Publisher>) -> Self {
205        Self { proxy, publisher }
206    }
207
208    /// Handle the `result` of the event sent via the call or call_async methods
209    /// and send the corresponding information to be logged to inspect.
210    fn inspect_result<T>(
211        &self,
212        result: &Result<T, fidl::Error>,
213        arg_str: String,
214        req_timestamp: String,
215        resp_timestamp: String,
216    ) where
217        T: Debug,
218    {
219        if let Some(p) = self.publisher.as_ref() {
220            if let Err(fidl::Error::ClientChannelClosed { .. }) = result {
221                p.send_event(Event::ExternalServiceEvent(ExternalServiceEvent::Closed(
222                    P::Protocol::DEBUG_NAME,
223                    arg_str.into(),
224                    req_timestamp.into(),
225                    resp_timestamp.into(),
226                )));
227            } else if let Err(e) = result {
228                p.send_event(Event::ExternalServiceEvent(ExternalServiceEvent::ApiError(
229                    P::Protocol::DEBUG_NAME,
230                    format!("{e:?}").into(),
231                    arg_str.into(),
232                    req_timestamp.into(),
233                    resp_timestamp.into(),
234                )));
235            } else {
236                let payload = result.as_ref().expect("Could not extract external api call result");
237                p.send_event(Event::ExternalServiceEvent(ExternalServiceEvent::ApiResponse(
238                    P::Protocol::DEBUG_NAME,
239                    format!("{payload:?}").into(),
240                    arg_str.into(),
241                    req_timestamp.into(),
242                    resp_timestamp.into(),
243                )));
244            }
245        }
246    }
247
248    /// Make a call to a synchronous API of the wrapped proxy. This should not be called directly,
249    /// only from the call macro.
250    pub(crate) fn call<T, F>(&self, func: F, arg_str: String) -> Result<T, fidl::Error>
251    where
252        F: FnOnce(&P) -> Result<T, fidl::Error>,
253        T: std::fmt::Debug,
254    {
255        let req_timestamp = clock::inspect_format_now();
256        if let Some(p) = self.publisher.as_ref() {
257            p.send_event(Event::ExternalServiceEvent(ExternalServiceEvent::ApiCall(
258                P::Protocol::DEBUG_NAME,
259                arg_str.clone().into(),
260                req_timestamp.clone().into(),
261            )));
262        }
263        let result = func(&self.proxy);
264        self.inspect_result(&result, arg_str, req_timestamp, clock::inspect_format_now());
265        result
266    }
267
268    /// Make a call to an asynchronous API of the wrapped proxy. This should not be called directly,
269    /// only from the call_async macro.
270    pub(crate) async fn call_async<T, F, Fut>(
271        &self,
272        func: F,
273        arg_str: String,
274    ) -> Result<T, fidl::Error>
275    where
276        F: FnOnce(&P) -> Fut,
277        Fut: Future<Output = Result<T, fidl::Error>>,
278        T: std::fmt::Debug,
279    {
280        let req_timestamp = clock::inspect_format_now();
281        if let Some(p) = self.publisher.as_ref() {
282            p.send_event(Event::ExternalServiceEvent(ExternalServiceEvent::ApiCall(
283                P::Protocol::DEBUG_NAME,
284                arg_str.clone().into(),
285                req_timestamp.clone().into(),
286            )));
287        }
288        let result = func(&self.proxy).await;
289        self.inspect_result(&result, arg_str, req_timestamp, clock::inspect_format_now());
290        result
291    }
292}
293
294/// Helper macro to simplify calls to proxy objects.
295#[macro_export]
296macro_rules! call {
297    ($proxy:expr => $($call:tt)+) => {
298        {
299            let arg_string = $crate::format_call!($($call)+);
300            $proxy.call(|p| p.$($call)+, arg_string)
301        }
302    };
303}
304
305/// Helper macro to simplify async calls to proxy objects.
306#[macro_export]
307macro_rules! call_async {
308    ($proxy:expr => $($call:tt)+) => {
309        {
310            let arg_string = $crate::format_call!($($call)+);
311            $proxy.call_async(|p| p.$($call)+, arg_string)
312        }
313    };
314}
315
316/// Helper macro to parse and stringify the arguments to `call` and `call_async`.
317#[macro_export]
318macro_rules! format_call {
319    ($fn_name:ident($($arg:expr),*)) => {
320        {
321            let mut s = format!("{}(", stringify!($fn_name));
322            $(
323                s += &format!("{:?}", $arg);
324            )*
325
326            s += ")";
327            s
328        }
329    };
330}
settings/service_context.rs

settings/
service_context.rs
