Struct ExecutorLockBuilder

Source

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

Expand description

Builder state after a lock has been attached.

Call Self::when to configure the required condition tester.

§Type Parameters

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

Implementations§

Source §

impl<L, T> ExecutorLockBuilder<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.

§Parameters

level - Log level used for unmet-condition messages.
message - Full log message emitted when the condition is not met.

§Returns

This builder with unmet-condition logging configured.

Source

pub fn disable_unmet_condition_logging(self) -> Self

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

§Returns

This builder with unmet-condition logging disabled.

Source

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

Configures logging when the prepare action fails.

§Parameters

level - Log level used for prepare failure messages.
message_prefix - Prefix placed before the prepare failure text.

§Returns

This builder with prepare failure logging configured.

Source

pub fn disable_prepare_failure_logging(self) -> Self

Disables logging when the prepare action fails.

§Returns

This builder with prepare failure logging disabled.

Source

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

Configures logging when the prepare commit action fails.

§Parameters

level - Log level used for prepare-commit failure messages.
message_prefix - Prefix placed before the prepare-commit failure text.

§Returns

This builder with prepare-commit failure logging configured.

Source

pub fn disable_prepare_commit_failure_logging(self) -> Self

Disables logging when the prepare commit action fails.

§Returns

This builder with prepare-commit failure logging disabled.

Source

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

Configures logging when the prepare rollback action fails.

§Parameters

level - Log level used for prepare-rollback failure messages.
message_prefix - Prefix placed before the prepare-rollback failure text.

§Returns

This builder with prepare-rollback failure logging configured.

Source

pub fn disable_prepare_rollback_failure_logging(self) -> Self

Disables logging when the prepare rollback action fails.

§Returns

This builder with prepare-rollback failure logging disabled.

Source

pub fn when<Tst>(self, tester: Tst) -> ExecutorReadyBuilder<L, T>
where Tst: Tester + Send + Sync + 'static,

Configures the required double-checked condition.

The tester is executed outside and inside the lock. State read by the outside check must be safe to access without this executor’s lock.

§Parameters

tester - The reusable condition tester.

§Returns

The builder state that can configure prepare callbacks and build the executor.

Examples found in repository ?

examples/double_checked_lock_executor_demo.rs (lines 42-45)

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