logfs 0.1.1

Simple append-only log based filesystem with encryption and compression
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

pub mod v2;
pub use v2::{Journal2, Superblock};

use std::{collections::BTreeMap, num::NonZeroU64, path::PathBuf, sync::Arc};

use crate::{
    Batch, KeyLock, LogConfig, LogFsError,
    crypto::Crypto,
    state::{KeyPointer, SharedTree},
};

use self::v2::{
    read::{KeyChunkIter, StdKeyReader},
    write::KeyWriter,
};

use super::Path;

pub type NextEntryOffset = usize;

/// Monotonically increasing, unique sequence numer of a log entry.
/// This is important for proper encryption with AEAD.
#[derive(
    serde::Serialize, serde::Deserialize, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug,
)]
pub struct SequenceId(NonZeroU64);

impl SequenceId {
    // TODO: remove! only needed for now until state is refactored.
    pub fn from_u64(value: u64) -> Self {
        Self(NonZeroU64::new(value).unwrap())
    }

    pub fn first() -> Self {
        Self(NonZeroU64::new(1).unwrap())
    }

    pub fn try_increment(self) -> Result<Self, LogFsError> {
        self.0
            .get()
            .checked_add(1)
            .map(|x| Self(NonZeroU64::new(x).unwrap()))
            .ok_or_else(|| {
                // TODO: use special error variant.
                LogFsError::new_internal(
                    "Number of log entries exceeds the maximum. Rewrite the log to fix this.",
                )
            })
    }

    pub fn try_decrement(self) -> Result<Self, LogFsError> {
        self.0
            .get()
            .checked_sub(1)
            .map(|x| Self(NonZeroU64::new(x).unwrap()))
            .ok_or_else(|| {
                // TODO: use special error variant.
                LogFsError::new_internal(
                    "Number of log entries exceeds the maximum. Rewrite the log to fix this.",
                )
            })
    }

    pub fn as_u64(self) -> u64 {
        self.0.get()
    }
}

pub struct RepairConfig {
    pub dry_run: bool,
    pub start_sequence: Option<SequenceId>,
    pub skip_bytes: Option<u64>,
    /// The path to which a recovered log should be written.
    pub recovery_path: Option<PathBuf>,
}

pub trait JournalStore {
    fn open(
        path: std::path::PathBuf,
        tree: SharedTree,
        crypto: Option<Arc<Crypto>>,
        config: &LogConfig,
    ) -> Result<Self, LogFsError>
    where
        Self: Sized;

    fn repair(
        log_config: &LogConfig,
        crypto: Option<Arc<Crypto>>,
        repair_config: RepairConfig,
    ) -> Result<(), LogFsError>
    where
        Self: Sized;

    fn write_batch(&self, batch: Batch) -> Result<(), LogFsError>;

    fn write_insert(&self, path: Path, data: Vec<u8>) -> Result<KeyPointer, LogFsError>;

    fn insert_writer(
        &self,
        path: Path,
        tree: SharedTree,
        writer_lock: KeyLock,
    ) -> Result<KeyWriter, LogFsError>;

    fn write_rename(&self, old_path: Path, new_path: Path) -> Result<(), LogFsError>;

    fn write_remove(&self, paths: Vec<Path>) -> Result<(), LogFsError>;

    fn write_index(
        &self,
        tree: &BTreeMap<String, KeyPointer>,
        full: bool,
    ) -> Result<(), LogFsError>;

    fn read_data(&self, pointer: &KeyPointer) -> Result<Vec<u8>, LogFsError>;

    fn reader(&self, pointer: &KeyPointer) -> Result<StdKeyReader, LogFsError>;

    fn read_chunks(&self, pointer: &KeyPointer) -> Result<KeyChunkIter, LogFsError>;

    fn size_log(&self) -> Result<u64, LogFsError>;
    fn supberlock(&self) -> Result<Superblock, LogFsError>;
}