d-engine-core 0.2.3

Pure Raft consensus algorithm - for building custom Raft-based systems
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

//! SnapshotGuard: A simple RAII-style guard to ensure that only one snapshot operation
//! is in progress at a time.
//!
//! This module provides a concurrency-safe mechanism to guard snapshot creation
//! using an `AtomicBool`. It prevents multiple threads or async tasks from
//! concurrently creating snapshots.
//!
//! When `SnapshotGuard::new` is called, it attempts to acquire exclusive access
//! by atomically setting the flag. If another snapshot is already in progress,
//! it returns an error. When the guard is dropped, the flag is reset automatically.

use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering;

use crate::Result;
use crate::SnapshotError;

// Snapshot state guard (RAII mode)
pub(crate) struct SnapshotGuard<'a> {
    flag: &'a AtomicBool,
}

impl<'a> SnapshotGuard<'a> {
    pub(crate) fn new(flag: &'a AtomicBool) -> Result<Self> {
        // Use compare_exchange to implement atomic state acquisition
        let already_in_progress = flag
            .compare_exchange(
                false,
                true,
                Ordering::AcqRel, // Ensure memory order
                Ordering::Relaxed,
            )
            .map_err(|e| {
                SnapshotError::OperationFailed(format!("SnapshotGuard::compare_exchange, {e:?}"))
            })?;

        if already_in_progress {
            return Err(
                SnapshotError::OperationFailed("Snapshot already in progress".to_string()).into(),
            );
        }

        Ok(Self { flag })
    }
}

impl Drop for SnapshotGuard<'_> {
    fn drop(&mut self) {
        // Always reset when guard goes out of scope
        self.flag.store(false, Ordering::SeqCst);
    }
}