Struct ManagedClientHandle 

pub struct ManagedClientHandle { /* private fields */ }

Cloneable control and observation capability for a managed task.

Implementations

impl ManagedClientHandle

pub fn status(&self) -> Arc<ManagedStatus>

Return the latest durable immutable status snapshot.

pub fn subscribe_status(&self) -> ManagedStatusSubscription

Subscribe to authoritative durable latest-state observation.

The current snapshot is marked as seen when subscribing. The current snapshot is immediately available through borrow(). Updates may coalesce; this is not a lossless event log. After the task terminates, the sender closes but the final snapshot remains readable. Use Self::subscribe for the lossy presentation-event stream.

pub fn subscribe( &self, ) -> Result<ManagedEventSubscription, ManagedSubscribeError>

Subscribe to future lossy presentation events.

pub fn stop(&self) -> ManagedStopReceipt

Request idempotent graceful stop and return a durable-status receipt.

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 update_targets( &self, targets: Vec<ManagedTargetConfig>, ) -> Result<ManagedCommandReceipt, ManagedCommandError>

Submit the complete desired target set, replacing any previous one.

targets is not a delta: any live target whose id is missing from targets is stopped and removed. A target that is still present with an unchanged configuration continues undisturbed — it is not restarted and does not get a new generation. A target present with a changed configuration, or whose current generation already reached a terminal state (e.g. failed, completed, or was closed by the peer), is treated as a fresh start: it is retired and a new generation is created for it, even if the configuration is byte-for-byte identical to the one that just finished.

This call enqueues the update without waiting for queue capacity; await the returned ManagedCommandReceipt to observe whether — and how — it was applied.

Trait Implementations

impl Clone for ManagedClientHandle

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ManagedClientHandle

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.