settings/setup/
setup_fidl_handler.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::base::{SettingInfo, SettingType};
6use crate::handler::base::Request;
7use crate::ingress::{request, watch, Scoped};
8use crate::job::source::{Error as JobError, ErrorResponder};
9use crate::job::Job;
10use crate::setup::types::{
11    ConfigurationInterfaceFlags, SetConfigurationInterfacesParams, SetupInfo,
12};
13use fidl::prelude::*;
14use fidl_fuchsia_settings::{
15    SetupRequest, SetupSetResponder, SetupSetResult, SetupSettings, SetupWatchResponder,
16};
17
18impl ErrorResponder for SetupSetResponder {
19    fn id(&self) -> &'static str {
20        "Setup_Set"
21    }
22
23    fn respond(self: Box<Self>, error: fidl_fuchsia_settings::Error) -> Result<(), fidl::Error> {
24        self.send(Err(error))
25    }
26}
27
28impl From<SettingInfo> for SetupSettings {
29    fn from(response: SettingInfo) -> Self {
30        if let SettingInfo::Setup(info) = response {
31            return SetupSettings::from(info);
32        }
33        panic!("incorrect value sent");
34    }
35}
36
37impl From<fidl_fuchsia_settings::ConfigurationInterfaces> for ConfigurationInterfaceFlags {
38    fn from(interfaces: fidl_fuchsia_settings::ConfigurationInterfaces) -> Self {
39        let mut flags = ConfigurationInterfaceFlags::empty();
40
41        if interfaces.intersects(fidl_fuchsia_settings::ConfigurationInterfaces::ETHERNET) {
42            flags |= ConfigurationInterfaceFlags::ETHERNET;
43        }
44
45        if interfaces.intersects(fidl_fuchsia_settings::ConfigurationInterfaces::WIFI) {
46            flags |= ConfigurationInterfaceFlags::WIFI;
47        }
48
49        flags
50    }
51}
52
53impl From<ConfigurationInterfaceFlags> for fidl_fuchsia_settings::ConfigurationInterfaces {
54    fn from(flags: ConfigurationInterfaceFlags) -> Self {
55        let mut interfaces = fidl_fuchsia_settings::ConfigurationInterfaces::empty();
56
57        if flags.intersects(ConfigurationInterfaceFlags::ETHERNET) {
58            interfaces |= fidl_fuchsia_settings::ConfigurationInterfaces::ETHERNET;
59        }
60
61        if flags.intersects(ConfigurationInterfaceFlags::WIFI) {
62            interfaces |= fidl_fuchsia_settings::ConfigurationInterfaces::WIFI;
63        }
64
65        interfaces
66    }
67}
68
69impl From<SetupInfo> for SetupSettings {
70    fn from(info: SetupInfo) -> Self {
71        let mut settings = SetupSettings::default();
72        let interfaces =
73            fidl_fuchsia_settings::ConfigurationInterfaces::from(info.configuration_interfaces);
74
75        if !interfaces.is_empty() {
76            settings.enabled_configuration_interfaces = Some(interfaces);
77        }
78
79        settings
80    }
81}
82
83impl request::Responder<Scoped<SetupSetResult>> for SetupSetResponder {
84    fn respond(self, Scoped(response): Scoped<SetupSetResult>) {
85        let _ = self.send(response).ok();
86    }
87}
88
89impl watch::Responder<SetupSettings, zx::Status> for SetupWatchResponder {
90    fn respond(self, response: Result<SetupSettings, zx::Status>) {
91        match response {
92            Ok(settings) => {
93                let _ = self.send(&settings);
94            }
95            Err(error) => {
96                self.control_handle().shutdown_with_epitaph(error);
97            }
98        }
99    }
100}
101
102impl TryFrom<SetupRequest> for Job {
103    type Error = JobError;
104    fn try_from(item: SetupRequest) -> Result<Self, Self::Error> {
105        #[allow(unreachable_patterns)]
106        match item {
107            SetupRequest::Set { settings, reboot_device, responder } => {
108                match to_request(settings, reboot_device) {
109                    Some(request) => {
110                        Ok(request::Work::new(SettingType::Setup, request, responder).into())
111                    }
112                    None => Err(JobError::InvalidInput(Box::new(responder))),
113                }
114            }
115            SetupRequest::Watch { responder } => {
116                Ok(watch::Work::new_job(SettingType::Setup, responder))
117            }
118            _ => {
119                log::warn!("Received a call to an unsupported API: {:?}", item);
120                Err(JobError::Unsupported)
121            }
122        }
123    }
124}
125
126fn to_request(settings: SetupSettings, should_reboot: bool) -> Option<Request> {
127    if let Some(configuration_interfaces) = settings.enabled_configuration_interfaces {
128        return Some(Request::SetConfigurationInterfaces(SetConfigurationInterfacesParams {
129            config_interfaces_flags: ConfigurationInterfaceFlags::from(configuration_interfaces),
130            should_reboot,
131        }));
132    }
133
134    None
135}
136
137#[cfg(test)]
138mod tests {
139    use super::*;
140    use crate::job::{execution, work};
141    use assert_matches::assert_matches;
142    use fidl_fuchsia_settings::{SetupMarker, SetupRequestStream};
143    use futures::StreamExt;
144
145    #[fuchsia::test]
146    fn test_request_from_settings() {
147        const CONFIGURATION_INTERFACES: Option<fidl_fuchsia_settings::ConfigurationInterfaces> =
148            Some(fidl_fuchsia_settings::ConfigurationInterfaces::ETHERNET);
149        const CONFIGURATION_INTERFACE_FLAG: ConfigurationInterfaceFlags =
150            ConfigurationInterfaceFlags::ETHERNET;
151        const SHOULD_REBOOT: bool = true;
152
153        let setup_settings = SetupSettings {
154            enabled_configuration_interfaces: CONFIGURATION_INTERFACES,
155            ..Default::default()
156        };
157
158        let request = to_request(setup_settings, SHOULD_REBOOT);
159
160        assert_eq!(
161            request,
162            Some(Request::SetConfigurationInterfaces(SetConfigurationInterfacesParams {
163                config_interfaces_flags: CONFIGURATION_INTERFACE_FLAG,
164                should_reboot: SHOULD_REBOOT,
165            }))
166        );
167    }
168
169    #[fuchsia::test(allow_stalls = false)]
170    async fn try_from_set_converts_supplied_params() {
171        const CONFIGURATION_INTERFACES: Option<fidl_fuchsia_settings::ConfigurationInterfaces> =
172            Some(fidl_fuchsia_settings::ConfigurationInterfaces::ETHERNET);
173        const SHOULD_REBOOT: bool = true;
174
175        let (proxy, server) = fidl::endpoints::create_proxy::<SetupMarker>();
176        let _fut = proxy.set(
177            &SetupSettings {
178                enabled_configuration_interfaces: CONFIGURATION_INTERFACES,
179                ..Default::default()
180            },
181            SHOULD_REBOOT,
182        );
183        let mut request_stream: SetupRequestStream = server.into_stream();
184        let request = request_stream
185            .next()
186            .await
187            .expect("should have on request before stream is closed")
188            .expect("should have gotten a request");
189        let job = Job::try_from(request);
190        let job = job.as_ref();
191        assert_matches!(job.map(|j| j.workload()), Ok(work::Load::Independent(_)));
192        assert_matches!(job.map(|j| j.execution_type()), Ok(execution::Type::Independent));
193    }
194
195    #[fuchsia::test(allow_stalls = false)]
196    async fn try_from_watch_converts_supplied_params() {
197        let (proxy, server) = fidl::endpoints::create_proxy::<SetupMarker>();
198        let _fut = proxy.watch();
199        let mut request_stream: SetupRequestStream = server.into_stream();
200        let request = request_stream
201            .next()
202            .await
203            .expect("should have on request before stream is closed")
204            .expect("should have gotten a request");
205        let job = Job::try_from(request);
206        let job = job.as_ref();
207        assert_matches!(job.map(|j| j.workload()), Ok(work::Load::Sequential(_, _)));
208        assert_matches!(job.map(|j| j.execution_type()), Ok(execution::Type::Sequential(_)));
209    }
210}
settings/setup/setup_fidl_handler.rs

settings/setup/
setup_fidl_handler.rs
