bt_test_harness/
host_watcher.rs

1// Copyright 2021 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::{format_err, Context, Error};
6use fidl_fuchsia_bluetooth_sys::{HostWatcherMarker, HostWatcherProxy};
7use fidl_fuchsia_hardware_bluetooth::EmulatorProxy;
8use fuchsia_bluetooth::expectation::asynchronous::{
9    expectable, Expectable, ExpectableExt, ExpectableState, ExpectableStateExt,
10};
11use fuchsia_bluetooth::expectation::Predicate;
12use fuchsia_bluetooth::types::{Address, HostId, HostInfo};
13
14use futures::future::{self, BoxFuture, FutureExt, TryFutureExt};
15use hci_emulator_client::Emulator;
16use log::error;
17use std::collections::HashMap;
18use std::ops::{Deref, DerefMut};
19use std::sync::Arc;
20use test_harness::{SharedState, TestHarness, SHARED_STATE_TEST_COMPONENT_INDEX};
21
22use crate::core_realm::{CoreRealm, SHARED_STATE_INDEX};
23use crate::timeout_duration;
24
25#[derive(Clone, Default)]
26pub struct HostWatcherState {
27    /// Current hosts
28    pub hosts: HashMap<HostId, HostInfo>,
29}
30
31#[derive(Clone)]
32pub struct HostWatcherHarness {
33    pub expect: Expectable<HostWatcherState, HostWatcherProxy>,
34    pub realm: Arc<CoreRealm>,
35}
36
37impl Deref for HostWatcherHarness {
38    type Target = Expectable<HostWatcherState, HostWatcherProxy>;
39
40    fn deref(&self) -> &Self::Target {
41        &self.expect
42    }
43}
44
45impl DerefMut for HostWatcherHarness {
46    fn deref_mut(&mut self) -> &mut Self::Target {
47        &mut self.expect
48    }
49}
50
51async fn watch_hosts(harness: HostWatcherHarness) -> Result<(), Error> {
52    let proxy = harness.aux().clone();
53    loop {
54        let hosts = proxy
55            .watch()
56            .await
57            .context("Error calling fuchsia.bluetooth.sys.HostWatcher.watch()")?;
58        let hosts: HashMap<HostId, HostInfo> = hosts
59            .into_iter()
60            .map(|info| {
61                let info = HostInfo::try_from(info).expect("valid host");
62                (info.id, info)
63            })
64            .collect();
65        harness.write_state().hosts = hosts;
66        harness.notify_state_changed();
67    }
68}
69
70pub async fn new_host_watcher_harness(realm: Arc<CoreRealm>) -> Result<HostWatcherHarness, Error> {
71    let proxy = realm
72        .instance()
73        .connect_to_protocol_at_exposed_dir::<HostWatcherMarker>()
74        .context("Failed to connect to host_watcher service")?;
75
76    Ok(HostWatcherHarness { expect: expectable(Default::default(), proxy), realm })
77}
78
79impl TestHarness for HostWatcherHarness {
80    type Env = Arc<CoreRealm>;
81    type Runner = BoxFuture<'static, Result<(), Error>>;
82
83    fn init(
84        shared_state: &Arc<SharedState>,
85    ) -> BoxFuture<'static, Result<(Self, Self::Env, Self::Runner), Error>> {
86        let shared_state = shared_state.clone();
87        async move {
88            let test_component: Arc<String> = shared_state
89                .get(SHARED_STATE_TEST_COMPONENT_INDEX)
90                .expect("SharedState must have TEST-COMPONENT")?;
91            let inserter = move || CoreRealm::create(test_component.to_string());
92            let realm = shared_state.get_or_insert_with(SHARED_STATE_INDEX, inserter).await?;
93            let harness = new_host_watcher_harness(realm.clone()).await?;
94            let run_host_watcher = watch_hosts(harness.clone())
95                .map_err(|e| e.context("Error running HostWatcher harness"))
96                .boxed();
97            Ok((harness, realm, run_host_watcher))
98        }
99        .boxed()
100    }
101    fn terminate(_env: Self::Env) -> BoxFuture<'static, Result<(), Error>> {
102        future::ok(()).boxed()
103    }
104}
105
106/// An activated fake host.
107/// Must be released with `host.release().await` before drop.
108pub struct ActivatedFakeHost {
109    host_watcher: HostWatcherHarness,
110    host: HostId,
111    hci: Option<Emulator>,
112}
113
114// All Fake HCI Devices have this address
115pub const FAKE_HCI_ADDRESS: Address = Address::Public([0, 0, 0, 0, 0, 0]);
116
117/// Create and publish an emulated HCI device, and wait until the host is bound and registered to
118/// bt-gap
119pub async fn activate_fake_host(
120    host_watcher: HostWatcherHarness,
121) -> Result<(HostId, Emulator), Error> {
122    let initial_hosts: Vec<HostId> = host_watcher.read().hosts.keys().cloned().collect();
123    let initial_hosts_ = initial_hosts.clone();
124
125    let dev_dir = host_watcher.realm.dev().context("failed to open dev directory")?;
126    let hci = Emulator::create_and_publish(dev_dir).await?;
127
128    let host_watcher_state = host_watcher
129        .when_satisfied(
130            expectation::host_exists(Predicate::predicate(
131                move |host: &HostInfo| {
132                    host.addresses.contains(&FAKE_HCI_ADDRESS) && !initial_hosts_.contains(&host.id)
133                },
134                &format!("A fake host that is not in {:?}", initial_hosts),
135            )),
136            timeout_duration(),
137        )
138        .await?;
139
140    let host = host_watcher_state
141        .hosts
142        .iter()
143        .find(|(id, host)| {
144            host.addresses.contains(&FAKE_HCI_ADDRESS) && !initial_hosts.contains(id)
145        })
146        .unwrap()
147        .1
148        .id; // We can safely unwrap here as this is guarded by the previous expectation
149
150    let fut = host_watcher.aux().set_active(&host.into());
151    fut.await?
152        .or_else(zx::Status::ok)
153        .map_err(|e| format_err!("failed to set active host to emulator: {}", e))?;
154
155    let _ = host_watcher
156        .when_satisfied(expectation::active_host_is(host.clone()), timeout_duration())
157        .await?;
158    Ok((host, hci))
159}
160
161impl ActivatedFakeHost {
162    pub async fn new(realm: Arc<CoreRealm>) -> Result<ActivatedFakeHost, Error> {
163        let host_watcher = new_host_watcher_harness(realm).await?;
164        fuchsia_async::Task::spawn(
165            watch_hosts(host_watcher.clone())
166                .unwrap_or_else(|e| error!("Error watching hosts: {:?}", e)),
167        )
168        .detach();
169        let (host, hci) = activate_fake_host(host_watcher.clone()).await?;
170        Ok(ActivatedFakeHost { host_watcher, host, hci: Some(hci) })
171    }
172
173    pub async fn release(mut self) -> Result<(), Error> {
174        // Wait for the test device to be destroyed.
175        if let Some(hci) = &mut self.hci {
176            hci.destroy_and_wait().await?;
177        }
178        self.hci = None;
179
180        // Wait for BT-GAP to unregister the associated fake host
181        let _ = self
182            .host_watcher
183            .when_satisfied(expectation::host_not_present(self.host.clone()), timeout_duration())
184            .await?;
185        Ok(())
186    }
187
188    pub fn emulator(&self) -> &EmulatorProxy {
189        self.hci.as_ref().expect("emulator proxy requested after shut down").emulator()
190    }
191}
192
193impl Drop for ActivatedFakeHost {
194    fn drop(&mut self) {
195        assert!(self.hci.is_none());
196    }
197}
198
199pub mod expectation {
200    use super::*;
201
202    pub(crate) fn host_not_present(id: HostId) -> Predicate<HostWatcherState> {
203        let msg = format!("Host not present: {}", id);
204        Predicate::predicate(move |state: &HostWatcherState| !state.hosts.contains_key(&id), &msg)
205    }
206
207    pub(crate) fn host_exists(p: Predicate<HostInfo>) -> Predicate<HostWatcherState> {
208        let msg = format!("Host exists satisfying {:?}", p);
209        Predicate::predicate(
210            move |state: &HostWatcherState| state.hosts.iter().any(|(_, host)| p.satisfied(&host)),
211            &msg,
212        )
213    }
214
215    pub(crate) fn active_host_is(id: HostId) -> Predicate<HostWatcherState> {
216        let msg = format!("Active host is: {}", id);
217        Predicate::predicate(
218            move |state: &HostWatcherState| {
219                state.hosts.get(&id).and_then(|h| Some(h.active)) == Some(true)
220            },
221            &msg,
222        )
223    }
224}
bt_test_harness/host_watcher.rs

bt_test_harness/
host_watcher.rs
