Struct BlockingAsyncProducer 

pub struct BlockingAsyncProducer<F, Fut>
where
    F: Fn() -> Fut,
    Fut: Future<Output = Report>,
{ /* private fields */ }

Adapter that wraps an async fn returning a Report and implements dev_report::Producer by calling tokio::runtime::Handle::current().block_on(...).

MUST be invoked from a sync context that is not itself running inside a current_thread runtime. Calling block_on from inside an async runtime would deadlock; if you need that, use AsyncProducer directly without going through Producer.

Example

use dev_async::{run_with_timeout, BlockingAsyncProducer};
use dev_report::{Producer, Report};
use std::time::Duration;

fn build_report() -> impl std::future::Future<Output = Report> {
    async {
        let check = run_with_timeout("op", Duration::from_millis(50), async {}).await;
        let mut r = Report::new("crate", "0.1.0").with_producer("dev-async");
        r.push(check);
        r.finish();
        r
    }
}

// From a sync test or main:
// let rt = tokio::runtime::Runtime::new().unwrap();
// let handle = rt.handle().clone();
// let producer = BlockingAsyncProducer::new(handle, build_report);
// let report = producer.produce();

Implementations

impl<F, Fut> BlockingAsyncProducer<F, Fut>

where F: Fn() -> Fut, Fut: Future<Output = Report>,

pub fn new(handle: Handle, factory: F) -> Self

Build a new adapter bound to handle.

factory is invoked once per produce() call and must return a fresh future each time.

Trait Implementations

impl<F, Fut> Producer for BlockingAsyncProducer<F, Fut>

where F: Fn() -> Fut, Fut: Future<Output = Report>,

fn produce(&self) -> Report

Run the producer and return a finalized report.