forked from auracaster/bumble_mirror
59d7717963
After adding test for feature combinations, I found a corner case where, when Transport is dropped and the process is terminated in a test, the `close` Python future is not awaited. I don't know what other situations this issue may arise, so I have safe-guarded it via `block_on` instead of spawning a thread.
87 lines
2.7 KiB
Rust
87 lines
2.7 KiB
Rust
// Copyright 2023 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
//! HCI packet transport
|
|
|
|
use crate::wrapper::controller::Controller;
|
|
use futures::executor::block_on;
|
|
use pyo3::{intern, types::PyModule, PyObject, PyResult, Python};
|
|
|
|
/// A source/sink pair for HCI packet I/O.
|
|
///
|
|
/// See <https://google.github.io/bumble/transports/index.html>.
|
|
pub struct Transport(PyObject);
|
|
|
|
impl Transport {
|
|
/// Open a new Transport for the provided spec, e.g. `"usb:0"` or `"android-netsim"`.
|
|
pub async fn open(transport_spec: impl Into<String>) -> PyResult<Self> {
|
|
Python::with_gil(|py| {
|
|
PyModule::import(py, intern!(py, "bumble.transport"))?
|
|
.call_method1(intern!(py, "open_transport"), (transport_spec.into(),))
|
|
.and_then(pyo3_asyncio::tokio::into_future)
|
|
})?
|
|
.await
|
|
.map(Self)
|
|
}
|
|
|
|
/// Close the transport.
|
|
pub async fn close(&mut self) -> PyResult<()> {
|
|
Python::with_gil(|py| {
|
|
self.0
|
|
.call_method0(py, intern!(py, "close"))
|
|
.and_then(|coroutine| pyo3_asyncio::tokio::into_future(coroutine.as_ref(py)))
|
|
})?
|
|
.await
|
|
.map(|_| ())
|
|
}
|
|
|
|
/// Returns the source half of the transport.
|
|
pub fn source(&self) -> PyResult<Source> {
|
|
Python::with_gil(|py| self.0.getattr(py, intern!(py, "source"))).map(Source)
|
|
}
|
|
|
|
/// Returns the sink half of the transport.
|
|
pub fn sink(&self) -> PyResult<Sink> {
|
|
Python::with_gil(|py| self.0.getattr(py, intern!(py, "sink"))).map(Sink)
|
|
}
|
|
}
|
|
|
|
impl Drop for Transport {
|
|
fn drop(&mut self) {
|
|
// don't spawn a thread to handle closing, as it may get dropped at program termination,
|
|
// resulting in `RuntimeWarning: coroutine ... was never awaited` from Python
|
|
let _ = block_on(self.close());
|
|
}
|
|
}
|
|
|
|
/// The source side of a [Transport].
|
|
#[derive(Clone)]
|
|
pub struct Source(pub(crate) PyObject);
|
|
|
|
impl From<Controller> for Source {
|
|
fn from(value: Controller) -> Self {
|
|
Self(value.0)
|
|
}
|
|
}
|
|
|
|
/// The sink side of a [Transport].
|
|
#[derive(Clone)]
|
|
pub struct Sink(pub(crate) PyObject);
|
|
|
|
impl From<Controller> for Sink {
|
|
fn from(value: Controller) -> Self {
|
|
Self(value.0)
|
|
}
|
|
}
|