fuchsia_component_server/
service.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
5//! The `Service` trait and its trait-object wrappers.
6
7use fidl::endpoints::{DiscoverableProtocolMarker, RequestStream, ServerEnd, ServiceRequest};
8use fuchsia_async as fasync;
9use std::marker::PhantomData;
10
11/// `Service` connects channels to service instances.
12///
13/// Note that this trait is implemented by the `FidlService` type.
14pub trait Service {
15    /// The type of the value yielded by the `spawn_service` callback.
16    type Output;
17
18    /// Create a new instance of the service on the provided `zx::Channel`.
19    ///
20    /// The value returned by this function will be yielded from the stream
21    /// output of the `ServiceFs` type.
22    fn connect(&mut self, channel: zx::Channel) -> Option<Self::Output>;
23}
24
25impl<F, O> Service for F
26where
27    F: FnMut(zx::Channel) -> Option<O>,
28{
29    type Output = O;
30    fn connect(&mut self, channel: zx::Channel) -> Option<Self::Output> {
31        (self)(channel)
32    }
33}
34
35/// A wrapper for functions from `RequestStream` to `Output` which implements
36/// `Service`.
37///
38/// This type throws away channels that cannot be converted to the appropriate
39/// `RequestStream` type.
40pub struct FidlService<F, RS, Output>
41where
42    F: FnMut(RS) -> Output,
43    RS: RequestStream,
44{
45    f: F,
46    marker: PhantomData<(RS, Output)>,
47}
48
49impl<F, RS, Output> From<F> for FidlService<F, RS, Output>
50where
51    F: FnMut(RS) -> Output,
52    RS: RequestStream,
53{
54    fn from(f: F) -> Self {
55        Self { f, marker: PhantomData }
56    }
57}
58
59impl<F, RS, Output> Service for FidlService<F, RS, Output>
60where
61    F: FnMut(RS) -> Output,
62    RS: RequestStream,
63{
64    type Output = Output;
65    fn connect(&mut self, channel: zx::Channel) -> Option<Self::Output> {
66        let chan = fasync::Channel::from_channel(channel);
67        Some((self.f)(RS::from_channel(chan)))
68    }
69}
70
71/// A wrapper for functions from `ServerEnd` to `Output` which implements
72/// `Service`.
73pub struct FidlServiceServerConnector<F, P, Output>
74where
75    F: FnMut(ServerEnd<P>) -> Output,
76    P: DiscoverableProtocolMarker,
77{
78    f: F,
79    marker: PhantomData<(P, Output)>,
80}
81
82impl<F, P, Output> From<F> for FidlServiceServerConnector<F, P, Output>
83where
84    F: FnMut(ServerEnd<P>) -> Output,
85    P: DiscoverableProtocolMarker,
86{
87    fn from(f: F) -> Self {
88        Self { f, marker: PhantomData }
89    }
90}
91
92impl<F, P, Output> Service for FidlServiceServerConnector<F, P, Output>
93where
94    F: FnMut(ServerEnd<P>) -> Output,
95    P: DiscoverableProtocolMarker,
96{
97    type Output = Output;
98    fn connect(&mut self, channel: zx::Channel) -> Option<Self::Output> {
99        let FidlServiceServerConnector { f, marker: _ } = self;
100        Some(f(ServerEnd::new(channel)))
101    }
102}
103
104/// A wrapper for functions from `ServiceRequest` to `Output` which implements
105/// `Service`.
106///
107/// This type throws away channels that cannot be converted to the appropriate
108/// `ServiceRequest` type.
109pub struct FidlServiceMember<F, SR, Output>
110where
111    F: FnMut(SR) -> Output,
112    SR: ServiceRequest,
113{
114    f: F,
115    member: &'static str,
116    marker: PhantomData<(SR, Output)>,
117}
118
119impl<F, SR, Output> FidlServiceMember<F, SR, Output>
120where
121    F: FnMut(SR) -> Output,
122    SR: ServiceRequest,
123{
124    /// Creates an object that handles connections to a service member.
125    pub fn new(f: F, member: &'static str) -> Self {
126        Self { f, member, marker: PhantomData }
127    }
128}
129
130impl<F, SR, Output> Service for FidlServiceMember<F, SR, Output>
131where
132    F: FnMut(SR) -> Output,
133    SR: ServiceRequest,
134{
135    type Output = Output;
136
137    fn connect(&mut self, channel: zx::Channel) -> Option<Self::Output> {
138        let chan = fasync::Channel::from_channel(channel);
139        Some((self.f)(SR::dispatch(self.member, chan)))
140    }
141}
142
143/// A `!Send` (non-thread-safe) trait object encapsulating a `Service` with
144/// the given `Output` type.
145///
146/// Types which implement the `Service` trait can be converted to objects of
147/// this type via the `From`/`Into` traits.
148pub struct ServiceObjLocal<'a, Output>(Box<dyn Service<Output = Output> + 'a>);
149
150impl<'a, S: Service + 'a> From<S> for ServiceObjLocal<'a, S::Output> {
151    fn from(service: S) -> Self {
152        ServiceObjLocal(Box::new(service))
153    }
154}
155
156/// A thread-safe (`Send`) trait object encapsulating a `Service` with
157/// the given `Output` type.
158///
159/// Types which implement the `Service` trait and the `Send` trait can
160/// be converted to objects of this type via the `From`/`Into` traits.
161pub struct ServiceObj<'a, Output>(Box<dyn Service<Output = Output> + Send + 'a>);
162
163impl<'a, S: Service + Send + 'a> From<S> for ServiceObj<'a, S::Output> {
164    fn from(service: S) -> Self {
165        ServiceObj(Box::new(service))
166    }
167}
168
169/// A trait implemented by both `ServiceObj` and `ServiceObjLocal` that
170/// allows code to be generic over thread-safety.
171///
172/// Code that uses `ServiceObj` will require `Send` bounds but will be
173/// multithreaded-capable, while code that uses `ServiceObjLocal` will
174/// allow non-`Send` types but will be restricted to singlethreaded
175/// executors.
176pub trait ServiceObjTrait {
177    /// The output type of the underlying `Service`.
178    type Output;
179
180    /// Get a mutable reference to the underlying `Service` trait object.
181    fn service(&mut self) -> &mut dyn Service<Output = Self::Output>;
182}
183
184impl<'a, Output> ServiceObjTrait for ServiceObjLocal<'a, Output> {
185    type Output = Output;
186
187    fn service(&mut self) -> &mut dyn Service<Output = Self::Output> {
188        &mut *self.0
189    }
190}
191
192impl<'a, Output> ServiceObjTrait for ServiceObj<'a, Output> {
193    type Output = Output;
194
195    fn service(&mut self) -> &mut dyn Service<Output = Self::Output> {
196        &mut *self.0
197    }
198}
fuchsia_component_server/service.rs

fuchsia_component_server/
service.rs
