linkrs-storage 0.1.0

Storage engine with CSR and memory-mapped containers
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
53
54
55
56
57
58
59
60
61

use super::SyncWrapper;
use crate::macros::forward_methods;
use crate::{StorageClient, StoragePersistenceOps};
use linkrs_core::StorageError;

impl<S: StorageClient + 'static> StoragePersistenceOps for SyncWrapper<S> {
    forward_methods!(inner;
        fn flush(&self) -> Result<(), StorageError>;
        fn save_data(&self) -> linkrs_core::StorageResult<()>;
        fn save_data_to_dir(&self, dir: &std::path::Path) -> linkrs_core::StorageResult<()>;
        fn verify_snapshot(&self, snapshot_id: u64) -> linkrs_core::StorageResult<bool>;
        fn cleanup_snapshots(&self) -> linkrs_core::StorageResult<usize>;
        fn snapshot_stats(&self) -> crate::SnapshotStats;
        fn persistence_diagnostics(&self) -> Option<crate::PersistenceDiagnostics>;
        fn compact(&self, config: &linkrs_core::types::CompactConfig) -> linkrs_core::StorageResult<()>;
        fn auto_flush_if_needed(&self) -> linkrs_core::StorageResult<bool>;
        fn should_flush(&self) -> bool;
        fn should_checkpoint(&self) -> bool;
    );

    fn create_checkpoint(&self) -> linkrs_core::StorageResult<Option<crate::CheckpointStats>> {
        if self.enabled {
            let manager = self.sync_manager.as_ref().ok_or_else(|| {
                StorageError::invalid_operation(
                    "Synchronization is enabled without an outbox manager",
                )
            })?;
            manager
                .create_checkpoint_outbox_snapshot()
                .map_err(|error| {
                    StorageError::db_error(format!(
                        "Failed to create checkpoint outbox snapshot: {error}"
                    ))
                })?;
        }
        self.inner.create_checkpoint()
    }

    fn auto_checkpoint_if_needed(
        &self,
    ) -> linkrs_core::StorageResult<Option<crate::CheckpointStats>> {
        if !self.should_checkpoint() {
            return Ok(None);
        }
        if self.enabled {
            let manager = self.sync_manager.as_ref().ok_or_else(|| {
                StorageError::invalid_operation(
                    "Synchronization is enabled without an outbox manager",
                )
            })?;
            manager
                .create_checkpoint_outbox_snapshot()
                .map_err(|error| {
                    StorageError::db_error(format!(
                        "Failed to create checkpoint outbox snapshot: {error}"
                    ))
                })?;
        }
        self.inner.auto_checkpoint_if_needed()
    }
}