Struct BlockingManagedClient 

pub struct BlockingManagedClient { /* private fields */ }

Blocking completion owner for one unified managed Tokio task.

This owner runs exactly one ManagedClient task on one dedicated OS thread with its own current-thread Tokio runtime. Dropping a live owner requests a graceful stop and synchronously joins that worker, so drop may block while bounded managed cleanup completes.

Implementations

impl BlockingManagedClient

pub fn start( config: ManagedClientConfig, targets: Vec<ManagedTargetConfig>, ) -> Result<Self, BlockingManagedStartError>

Validate configuration, create a dedicated runtime, and start its worker.

pub fn start_with_subscription( config: ManagedClientConfig, targets: Vec<ManagedTargetConfig>, ) -> Result<(Self, ManagedEventSubscription), BlockingManagedStartError>

Validate configuration, subscribe to presentation events, and start a dedicated managed worker.

The returned subscription exists before the managed task receives its first poll, so it cannot miss startup events because of subscription ordering.

Examples found in repository

examples/managed_client.rs (line 46)

fn main() {
    let config = ManagedClientConfig {
        client: ClientConfig {
            open: OpenPolicy {
                timeouts: vec![Duration::from_millis(300)],
                ..Default::default()
            },
            request: SessionRequest {
                duration: None,
                interval: Duration::from_millis(200),
                ..Default::default()
            },
            ..Default::default()
        },
        completion: ManagedCompletionPolicy::ExplicitStop,
        ..Default::default()
    };
    let targets = vec![ManagedTargetConfig::new("local", "127.0.0.1:2112")];

    let (owner, mut events) = match BlockingManagedClient::start_with_subscription(config, targets)
    {
        Ok(started) => started,
        Err(err) => {
            eprintln!("failed to start managed client: {err}");
            return;
        }
    };

    let stop_after = Duration::from_secs(1);
    let deadline = std::time::Instant::now() + stop_after;
    while std::time::Instant::now() < deadline {
        match events.try_recv() {
            Ok(event) => print_event(&event),
            Err(_) => std::thread::sleep(Duration::from_millis(50)),
        }
    }

    // `stop()` requests the stop synchronously; the returned receipt is only
    // useful for awaiting durable acknowledgement, which this blocking
    // example does not need.
    std::mem::drop(owner.handle().stop());
    match owner.join() {
        Ok(outcome) => println!("managed run ended: {:?}", outcome.end_reason),
        Err(err) => eprintln!("managed worker did not join cleanly: {err}"),
    }
}

pub fn handle(&self) -> ManagedClientHandle

Return a cloned managed control and observation capability.

Examples found in repository

examples/managed_client.rs (line 67)

fn main() {
    let config = ManagedClientConfig {
        client: ClientConfig {
            open: OpenPolicy {
                timeouts: vec![Duration::from_millis(300)],
                ..Default::default()
            },
            request: SessionRequest {
                duration: None,
                interval: Duration::from_millis(200),
                ..Default::default()
            },
            ..Default::default()
        },
        completion: ManagedCompletionPolicy::ExplicitStop,
        ..Default::default()
    };
    let targets = vec![ManagedTargetConfig::new("local", "127.0.0.1:2112")];

    let (owner, mut events) = match BlockingManagedClient::start_with_subscription(config, targets)
    {
        Ok(started) => started,
        Err(err) => {
            eprintln!("failed to start managed client: {err}");
            return;
        }
    };

    let stop_after = Duration::from_secs(1);
    let deadline = std::time::Instant::now() + stop_after;
    while std::time::Instant::now() < deadline {
        match events.try_recv() {
            Ok(event) => print_event(&event),
            Err(_) => std::thread::sleep(Duration::from_millis(50)),
        }
    }

    // `stop()` requests the stop synchronously; the returned receipt is only
    // useful for awaiting durable acknowledgement, which this blocking
    // example does not need.
    std::mem::drop(owner.handle().stop());
    match owner.join() {
        Ok(outcome) => println!("managed run ended: {:?}", outcome.end_reason),
        Err(err) => eprintln!("managed worker did not join cleanly: {err}"),
    }
}

pub fn join(self) -> Result<ManagedOutcome, BlockingManagedJoinError>

Wait synchronously for the managed task’s authoritative outcome.

Examples found in repository

examples/managed_client.rs (line 68)

fn main() {
    let config = ManagedClientConfig {
        client: ClientConfig {
            open: OpenPolicy {
                timeouts: vec![Duration::from_millis(300)],
                ..Default::default()
            },
            request: SessionRequest {
                duration: None,
                interval: Duration::from_millis(200),
                ..Default::default()
            },
            ..Default::default()
        },
        completion: ManagedCompletionPolicy::ExplicitStop,
        ..Default::default()
    };
    let targets = vec![ManagedTargetConfig::new("local", "127.0.0.1:2112")];

    let (owner, mut events) = match BlockingManagedClient::start_with_subscription(config, targets)
    {
        Ok(started) => started,
        Err(err) => {
            eprintln!("failed to start managed client: {err}");
            return;
        }
    };

    let stop_after = Duration::from_secs(1);
    let deadline = std::time::Instant::now() + stop_after;
    while std::time::Instant::now() < deadline {
        match events.try_recv() {
            Ok(event) => print_event(&event),
            Err(_) => std::thread::sleep(Duration::from_millis(50)),
        }
    }

    // `stop()` requests the stop synchronously; the returned receipt is only
    // useful for awaiting durable acknowledgement, which this blocking
    // example does not need.
    std::mem::drop(owner.handle().stop());
    match owner.join() {
        Ok(outcome) => println!("managed run ended: {:?}", outcome.end_reason),
        Err(err) => eprintln!("managed worker did not join cleanly: {err}"),
    }
}

Trait Implementations

impl Drop for BlockingManagedClient

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.