Struct LongOperationManager 

pub struct LongOperationManager { /* private fields */ }

Implementations

impl LongOperationManager

pub fn new() -> Self

pub fn set_event_hub(&mut self, event_hub: &Arc<EventHub>)

Inject the event hub to allow sending long operation related events

pub fn start_operation<Op: LongOperation>(&self, operation: Op) -> String

Start a new long operation and return its ID

pub fn get_operation_status(&self, id: &str) -> Option<OperationStatus>

Get the status of an operation

pub fn get_operation_progress(&self, id: &str) -> Option<OperationProgress>

Get the progress of an operation

pub fn cancel_operation(&self, id: &str) -> bool

Cancel an operation

pub fn is_operation_finished(&self, id: &str) -> Option<bool>

Check if an operation is finished

pub fn cleanup_finished_operations(&self)

Remove finished operations from memory

pub fn list_operations(&self) -> Vec<String>

Get list of all operation IDs

pub fn get_operations_summary( &self, ) -> Vec<(String, OperationStatus, OperationProgress)>

Get summary of all operations

pub fn store_operation_result<T: Serialize>( &self, id: &str, result: T, ) -> Result<()>

Store an operation result

pub fn get_operation_result(&self, id: &str) -> Option<String>

Get an operation result

pub fn completion_signal(&self) -> Arc<OperationCompletion>

A cloneable handle to the completion signal — the supported way to block until an operation finishes instead of re-checking it on a timer.

Handed out as an Arc by design. A manager is normally reached through a shared lock, and blocking while holding that lock would stall every other operation query for as long as the wait lasts. So take the handle, drop the manager lock, then wait:

let completion = ctx.long_operation_manager.lock().completion_signal();
// manager lock released here
completion.wait_for(&op_id, Some(Duration::from_secs(30)));
let result = ctx.long_operation_manager.lock().get_operation_result(&op_id);

pub fn wait_for_operation(&self, id: &str, timeout: Option<Duration>) -> bool

Block until id finishes; true once it has.

Convenience for an owner holding the manager directly. Do not call this through a shared lock — it blocks for the operation’s whole duration and would hold that lock the entire time; take completion_signal and wait on that instead.

Trait Implementations

impl Debug for LongOperationManager

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

Formats the value using the given formatter.

impl Default for LongOperationManager

fn default() -> Self

Returns the “default value” for a type.