ps-datalake 0.1.0-16

Encrypted flat storage
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

use std::{fmt::Display, num::TryFromIntError, sync::PoisonError};
use thiserror::Error;

#[derive(Error, Debug)]
pub enum DataLakeError {
    #[error(transparent)]
    Alignment(#[from] AlignmentError),
    #[error(transparent)]
    DataStoreCorrupted(#[from] DataStoreCorrupted),
    #[error("Hkey construction error: {0}")]
    HkeyConstruction(#[from] ps_hkey::HkeyConstructionError),
    #[error(transparent)]
    Io(#[from] std::io::Error),
    #[error(transparent)]
    MmapMap(#[from] ps_mmap::MapError),
    #[error("Tried to get a RW-handle on a read-only store.")]
    MmapReadOnly,
    #[error(transparent)]
    Offset(#[from] OffsetError),
    #[error(transparent)]
    DataChunk(#[from] ps_datachunk::DataChunkError),
    #[error(transparent)]
    Hkey(#[from] ps_hkey::HkeyError),
    #[error(transparent)]
    TomlSer(#[from] Box<toml::ser::Error>),
    #[error(transparent)]
    TomlDeser(#[from] Box<toml::de::Error>),
    #[error("Integer conversion error")]
    TryFromInt(#[from] TryFromIntError),
    #[error("Index out of range")]
    Range,
    #[error("DataChunk not found")]
    NotFound,
    #[error("Index overflowed - too many index buckets")]
    IndexBucketOverflow,
    #[error("The store being written to is read-only")]
    DataStoreNotRw,
    #[error("DataStore is out of space!")]
    DataStoreOutOfSpace,
    #[error("DataLake is out of available stores!")]
    DataLakeOutOfStores,
    #[error("Failed to acquire a poisoned mutex")]
    MutexPoison,
    #[error("Failed to store data")]
    StorageFailure,
    #[error("Invalid input format")]
    Format,
    #[error("To initialize a DataStore, please provision at least 64 kB of space.")]
    InitFailedNotEnoughSpace(usize),
}

pub type Result<T> = std::result::Result<T, DataLakeError>;

#[derive(Error, Debug)]
pub struct AlignmentError;

impl Display for AlignmentError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str("DataStore is not memory-aligned properly.")
    }
}

#[derive(Error, Debug)]
pub enum OffsetError {
    #[error(transparent)]
    Alignment(#[from] AlignmentError),
    #[error("Integer conversion error")]
    TryFromInt(#[from] TryFromIntError),
}

impl<T> From<PoisonError<T>> for DataLakeError {
    fn from(_: PoisonError<T>) -> Self {
        Self::MutexPoison
    }
}

impl From<ps_mmap::DerefError> for DataLakeError {
    fn from(value: ps_mmap::DerefError) -> Self {
        match value {
            ps_mmap::DerefError::ReadOnly => Self::MmapReadOnly,
        }
    }
}

impl From<toml::ser::Error> for DataLakeError {
    fn from(value: toml::ser::Error) -> Self {
        Self::TomlSer(Box::from(value))
    }
}

impl From<toml::de::Error> for DataLakeError {
    fn from(value: toml::de::Error) -> Self {
        Self::TomlDeser(Box::from(value))
    }
}

#[derive(Clone, Debug, Error, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub enum DataStoreCorrupted {
    #[error("DataStore has a size of {0} bytes")]
    InvalidDataStoreSize(usize),
    #[error("DataStore has an invalid file signature: {0}")]
    InvalidMagic(String),
    #[error("Index offset out of bounds: {0} > {1}")]
    IndexOffsetOutOfBounds(u64, usize),
    #[error("Data offset out of bounds: {0} > {1}")]
    DataOffsetOutOfBounds(u64, usize),
    #[error("Index ends out of bounds: {0} > {1}")]
    IndexEndsOutOfBounds(usize, usize),
    #[error("Data ends out of bounds: {0} > {1}")]
    DataEndsOutOfBounds(usize, usize),
    #[error("Index overlaps with data: {0} > {1}")]
    IndexDataOverlap(usize, usize),
    #[error("Index modulo {0} > index length {1}")]
    IndexModuloTooSmall(u32, u32),
}