Struct ClientHandle 

pub struct ClientHandle { /* private fields */ }

Handle for a single client/task instance.

The handle owns the task identity and start time, and emits partial updates using those fields as a stable base.

Implementations

impl ClientHandle

pub fn id(&self) -> TaskId

Return the internal identifier for this client/task.

pub fn set_label(&self, label: impl Into<String>) -> Result<(), ReportError>

Update the display label for this client/task.

pub fn set_total(&self, total: Option<u64>) -> Result<(), ReportError>

Update the total units of work for this client/task.

Use None for an indeterminate total.

pub fn set_current(&self, current: u64) -> Result<(), ReportError>

Set the current completed units of work.

Examples found in repository

examples/dummy_project/dummy_cluster.rs (line 39)

    pub fn run(&self, steps: usize, reporter: ClientReporter) {
        let mut handles = Vec::with_capacity(self.count);
        for i in 0..self.count {
            let reporter = reporter.clone();
            let label = format!("sim-{i}");
            handles.push(thread::spawn(move || {
                let mut sim = DummySimulator::new();
                let client = reporter.start(label, Some(steps as u64));
                if let Ok(client) = client {
                    for _ in 0..steps {
                        sim.tick();
                        let _ = client.set_current(sim.step as u64);
                    }
                    let _ = client.complete();
                }
                sim
            }));
        }

        for handle in handles {
            let _ = handle.join();
        }
    }

pub fn complete(&self) -> Result<(), ReportError>

Mark this client/task as completed.

Examples found in repository

examples/dummy_project/dummy_cluster.rs (line 41)

    pub fn run(&self, steps: usize, reporter: ClientReporter) {
        let mut handles = Vec::with_capacity(self.count);
        for i in 0..self.count {
            let reporter = reporter.clone();
            let label = format!("sim-{i}");
            handles.push(thread::spawn(move || {
                let mut sim = DummySimulator::new();
                let client = reporter.start(label, Some(steps as u64));
                if let Ok(client) = client {
                    for _ in 0..steps {
                        sim.tick();
                        let _ = client.set_current(sim.step as u64);
                    }
                    let _ = client.complete();
                }
                sim
            }));
        }

        for handle in handles {
            let _ = handle.join();
        }
    }

pub fn fail(&self) -> Result<(), ReportError>

Mark this client/task as failed.

pub fn cancel(&self) -> Result<(), ReportError>

Mark this client/task as canceled.

Trait Implementations

impl Clone for ClientHandle

fn clone(&self) -> ClientHandle

Returns a duplicate of the value.

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

Performs copy-assignment from source.