qubit_dcl::double_checked::executor_ready_builder

Struct ExecutorReadyBuilder

pub struct ExecutorReadyBuilder<L, T> { /* private fields */ }

Expand description

Builder state after the required condition tester has been configured.

This state can configure prepare lifecycle callbacks and build the final DoubleCheckedLockExecutor.

§Type Parameters

L - The lock type implementing Lock<T>.
T - The data type protected by the lock.

§Author

Haixing Hu

Implementations§

Source §

impl<L, T> ExecutorReadyBuilder<L, T>
where L: Lock<T>,

Source

pub fn log_unmet_condition( self, level: Level, message: impl Into<String>, ) -> Self

Configures logging when the double-checked condition is not met.

Source

pub fn log_prepare_failure( self, level: Level, message_prefix: impl Into<String>, ) -> Self

Configures logging when the prepare action fails.

Source

pub fn log_prepare_commit_failure( self, level: Level, message_prefix: impl Into<String>, ) -> Self

Configures logging when the prepare commit action fails.

Source

pub fn log_prepare_rollback_failure( self, level: Level, message_prefix: impl Into<String>, ) -> Self

Configures logging when the prepare rollback action fails.

Source

pub fn prepare<Rn, E>(self, prepare_action: Rn) -> Self
where Rn: Runnable<E> + Send + 'static, E: Display + Send + 'static,

Sets the prepare action.

The action runs after the first condition check succeeds and before the lock is acquired. If it succeeds, the executor will later run either rollback or commit according to the final task result.

Errors returned by this action are converted to String and reported by execution methods as super::ExecutionResult::Failed.

§Parameters

prepare_action - The fallible action to run before locking.

§Returns

This builder with prepare configured.

Source

pub fn rollback_prepare<Rn, E>(self, rollback_prepare_action: Rn) -> Self
where Rn: Runnable<E> + Send + 'static, E: Display + Send + 'static,

Sets the rollback action for a successfully completed prepare action.

Errors returned by this action are converted to String and replace the original execution result with a prepare-rollback failure.

§Parameters

rollback_prepare_action - The action to run if the second condition check or task execution fails after prepare succeeds.

§Returns

This builder with prepare rollback configured.

Source

pub fn commit_prepare<Rn, E>(self, commit_prepare_action: Rn) -> Self
where Rn: Runnable<E> + Send + 'static, E: Display + Send + 'static,

Sets the commit action for a successfully completed prepare action.

Errors returned by this action are converted to String and replace an otherwise successful execution result with a prepare-commit failure.

§Parameters

commit_prepare_action - The action to run if the task succeeds after prepare succeeds.

§Returns

This builder with prepare commit configured.

Source

pub fn build(self) -> DoubleCheckedLockExecutor<L, T>

Builds the reusable executor.

§Returns

A DoubleCheckedLockExecutor containing the configured lock, tester, execution logger, and prepare lifecycle callbacks.

Examples found in repository ?

examples/double_checked_lock_executor_demo.rs (line 55)

38fn main() -> Result<(), Box<dyn std::error::Error>> {
39    // Create shared state
40    let running = Arc::new(AtomicBool::new(false));
41    let data = ArcMutex::new(42);
42
43    println!(
44        "Initial state: running = {}",
45        running.load(Ordering::Acquire)
46    );
47    println!("Initial data: {}", data.read(|d| *d));
48
49    let executor = DoubleCheckedLockExecutor::builder()
50        .on(data.clone())
51        .when({
52            let running = running.clone();
53            move || running.load(Ordering::Acquire)
54        })
55        .build();
56
57    // Try to execute when service is not running (should fail)
58    let result = executor
59        .call_with(|value: &mut i32| {
60            *value += 1;
61            Ok::<_, ServiceError>(*value)
62        })
63        .get_result();
64
65    if result.is_success() {
66        println!("Unexpected success: {}", result.unwrap());
67    } else {
68        println!("Expected failure: Condition not met.");
69    }
70
71    // Start the service
72    running.store(true, Ordering::Release);
73    println!(
74        "Service started: running = {}",
75        running.load(Ordering::Acquire)
76    );
77
78    // Now execute should succeed
79    let result = executor
80        .call_with(|value: &mut i32| {
81            *value += 1;
82            Ok::<_, ServiceError>(*value)
83        })
84        .get_result();
85
86    if result.is_success() {
87        println!("Success: new value = {}", result.unwrap());
88    } else {
89        println!("Unexpected failure: {:?}", result);
90    }
91
92    // Verify the data was updated
93    println!("Final data: {}", data.read(|d| *d));
94
95    // Stop the service
96    running.store(false, Ordering::Release);
97    println!(
98        "Service stopped: running = {}",
99        running.load(Ordering::Acquire)
100    );
101
102    // Try to execute when service is stopped (should fail)
103    let result = executor
104        .call_with(|value: &mut i32| {
105            *value += 1;
106            Ok::<_, ServiceError>(*value)
107        })
108        .get_result();
109
110    if result.is_success() {
111        println!("Unexpected success: {}", result.unwrap());
112    } else {
113        println!("Expected failure: Condition not met.");
114    }
115
116    Ok(())
117}