sl4f_lib/server/
sl4f_types.rs

1// Copyright 2018 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 anyhow::Error;
6use async_trait::async_trait;
7use futures::channel::oneshot;
8use serde::{Deserialize, Serialize};
9use serde_json::Value;
10use std::fmt::Debug;
11use std::str::FromStr;
12use thiserror::Error;
13
14use crate::server::constants::{COMMAND_DELIMITER, COMMAND_SIZE};
15
16/// An Sl4f facade that can handle incoming requests.
17#[async_trait(?Send)]
18pub trait Facade: Debug {
19    /// Asynchronously handle the incoming request for the given method and arguments, returning a
20    /// future object representing the pending operation.
21    async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error>;
22
23    /// In response to a request to /cleanup, cleanup any cross-request state.
24    fn cleanup(&self) {}
25
26    /// In response to a request to /print, log relevant facade state.
27    fn print(&self) {}
28}
29
30/// Information about each client that has connected
31#[derive(Serialize, Deserialize, Debug, Clone)]
32pub struct ClientData {
33    // client_id: String ID of client (ACTS test suite)
34    pub command_id: Value,
35
36    // command_result: The response of running the command (to be stored in the table)
37    pub command_result: AsyncResponse,
38}
39
40impl ClientData {
41    pub fn new(id: Value, result: AsyncResponse) -> ClientData {
42        ClientData { command_id: id, command_result: result }
43    }
44}
45
46/// The parsed `id` field from an incoming json-rpc request.
47#[derive(Debug, PartialEq, Clone)]
48pub struct RequestId {
49    /// If the request ID is a string that contains a single '.', the text leading up to the '.' is
50    /// extracted as the client identifier.
51    client: Option<String>,
52
53    /// The ID to send in the response.  If client is Some(_), this will be a substring of the
54    /// request ID.
55    id: Value,
56}
57
58impl RequestId {
59    /// Parse a raw request ID into its session id (if present) and response id.
60    pub fn new(raw: Value) -> Self {
61        if let Some(s) = raw.as_str() {
62            let parts = s.split('.').collect::<Vec<_>>();
63            if parts.len() == 2 {
64                return Self {
65                    client: Some(parts[0].to_owned()),
66                    id: Value::String(parts[1..].join(".")),
67                };
68            }
69        }
70
71        // If the raw ID wasn't a string that contained exactly 1 '.', pass it through to the
72        // response unmodified.
73        Self { client: None, id: raw }
74    }
75
76    /// Returns a reference to the session id, if present.
77    pub fn session_id(&self) -> Option<&str> {
78        self.client.as_ref().map(String::as_str)
79    }
80
81    /// Returns a reference to the response id.
82    pub fn response_id(&self) -> &Value {
83        &self.id
84    }
85
86    /// Returns the response id, consuming self.
87    pub fn into_response_id(self) -> Value {
88        self.id
89    }
90}
91
92/// The parsed `method` field from an incoming json-rpc request.
93#[derive(Debug, PartialEq, Eq, Clone, Default)]
94pub struct MethodId {
95    /// Method type of the request (e.g bluetooth, wlan, etc...)
96    pub facade: String,
97
98    /// Name of the method
99    pub method: String,
100}
101
102impl FromStr for MethodId {
103    type Err = MethodIdParseError;
104
105    fn from_str(s: &str) -> Result<Self, Self::Err> {
106        let parts = s.split(COMMAND_DELIMITER).collect::<Vec<_>>();
107
108        if parts.len() != COMMAND_SIZE {
109            return Err(MethodIdParseError(s.to_string()));
110        }
111
112        Ok(Self { facade: parts[0].to_string(), method: parts[1].to_string() })
113    }
114}
115
116#[derive(Debug, PartialEq, Eq, Clone, Error)]
117#[error("invalid method id: {}", _0)]
118pub struct MethodIdParseError(String);
119
120/// Required fields for making a request
121#[derive(Serialize, Deserialize, Debug, Clone)]
122pub struct CommandRequest {
123    // method: name of method to be called
124    pub method: String,
125
126    // id: String id of command
127    pub id: Value,
128
129    // params: Arguments required for method
130    pub params: Value,
131}
132
133/// Return packet after SL4F runs command
134#[derive(Serialize, Clone, Debug)]
135pub struct CommandResponse {
136    // id: String id of command
137    pub id: Value,
138
139    // result: Result value of method call, can be None
140    pub result: Option<Value>,
141
142    // error: Error message of method call, can be None
143    pub error: Option<String>,
144}
145
146impl CommandResponse {
147    pub fn new(id: Value, result: Option<Value>, error: Option<String>) -> CommandResponse {
148        CommandResponse { id, result, error }
149    }
150}
151
152/// Represents a RPC request to be fulfilled by the FIDL event loop
153#[derive(Debug)]
154pub enum AsyncRequest {
155    Cleanup(oneshot::Sender<()>),
156    Command(AsyncCommandRequest),
157}
158
159/// Represents a RPC command request to be fulfilled by the FIDL event loop
160#[derive(Debug)]
161pub struct AsyncCommandRequest {
162    // tx: Transmit channel from FIDL event loop to RPC request side
163    pub tx: oneshot::Sender<AsyncResponse>,
164
165    // method_id: struct containing:
166    //  * facade: Method type of the request (e.g bluetooth, wlan, etc...)
167    //  * method: Name of the method
168    pub method_id: MethodId,
169
170    // params: serde_json::Value representing args for method
171    pub params: Value,
172}
173
174impl AsyncCommandRequest {
175    pub fn new(
176        tx: oneshot::Sender<AsyncResponse>,
177        method_id: MethodId,
178        params: Value,
179    ) -> AsyncCommandRequest {
180        AsyncCommandRequest { tx, method_id, params }
181    }
182}
183
184/// Represents a RPC response from the FIDL event loop to the RPC request side
185#[derive(Debug, Clone, Serialize, Deserialize)]
186pub struct AsyncResponse {
187    // res: serde_json::Value of FIDL method result
188    pub result: Option<Value>,
189
190    pub error: Option<String>,
191}
192
193impl AsyncResponse {
194    pub fn new(res: Result<Value, Error>) -> AsyncResponse {
195        match res {
196            Ok(v) => AsyncResponse { result: Some(v), error: None },
197            Err(e) => AsyncResponse { result: None, error: Some(e.to_string()) },
198        }
199    }
200}
201
202#[cfg(test)]
203mod tests {
204    use super::*;
205    use serde_json::json;
206
207    #[test]
208    fn parse_method_id_ok() {
209        assert_eq!(
210            "bt.send".parse(),
211            Ok(MethodId { facade: "bt".to_string(), method: "send".to_string() })
212        );
213        assert_eq!(
214            "FooFacade.BarMethod".parse(),
215            Ok(MethodId { facade: "FooFacade".to_string(), method: "BarMethod".to_string() })
216        );
217        assert_eq!(
218            "EmptyMethod.".parse(),
219            Ok(MethodId { facade: "EmptyMethod".to_string(), method: "".to_string() })
220        );
221        assert_eq!(
222            ".EmptyFacade".parse(),
223            Ok(MethodId { facade: "".to_string(), method: "EmptyFacade".to_string() })
224        );
225    }
226
227    #[test]
228    fn parse_method_id_invalid() {
229        fn assert_parse_error(s: &str) {
230            assert_eq!(s.parse::<MethodId>(), Err(MethodIdParseError(s.to_string())));
231        }
232
233        // Invalid command (should result in empty result)
234        assert_parse_error("bluetooth_send");
235
236        // Too many separators in command
237        assert_parse_error("wlan.scan.start");
238
239        // Empty command
240        assert_parse_error("");
241
242        // No separator
243        assert_parse_error("BluetoothSend");
244
245        // Invalid separator
246        assert_parse_error("Bluetooth,Scan");
247    }
248
249    #[test]
250    fn parse_request_id_int() {
251        let id = RequestId::new(json!(42));
252        assert_eq!(id, RequestId { client: None, id: json!(42) });
253        assert_eq!(id.session_id(), None);
254        assert_eq!(id.response_id(), &json!(42));
255        assert_eq!(id.into_response_id(), json!(42));
256    }
257
258    #[test]
259    fn parse_request_id_single_str() {
260        assert_eq!(RequestId::new(json!("123")), RequestId { client: None, id: json!("123") });
261    }
262
263    #[test]
264    fn parse_request_id_too_many_dots() {
265        assert_eq!(RequestId::new(json!("1.2.3")), RequestId { client: None, id: json!("1.2.3") });
266    }
267
268    #[test]
269    fn parse_request_id_with_session_id() {
270        let id = RequestId::new(json!("12.34"));
271        assert_eq!(id, RequestId { client: Some("12".to_string()), id: json!("34") });
272        assert_eq!(id.session_id(), Some("12"));
273        assert_eq!(id.response_id(), &json!("34"));
274        assert_eq!(id.into_response_id(), json!("34"));
275    }
276}
sl4f_lib/server/sl4f_types.rs

sl4f_lib/server/
sl4f_types.rs
