slatedb 0.12.1

A cloud native embedded storage engine built on object 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

use std::fmt::Debug;
use std::sync::Arc;

use crate::cached_object_store::LocalCacheEntry;

#[derive(Debug, Clone, Copy)]
pub enum AdmitResult {
    /// The object was admitted to the disk cache.
    Admitted,
    /// The object was rejected
    Rejected,
}

impl AdmitResult {
    pub fn admitted(&self) -> bool {
        matches!(self, AdmitResult::Admitted)
    }

    #[allow(unused)]
    pub fn rejected(&self) -> bool {
        matches!(self, AdmitResult::Rejected)
    }
}

impl From<bool> for AdmitResult {
    fn from(value: bool) -> Self {
        if value {
            AdmitResult::Admitted
        } else {
            AdmitResult::Rejected
        }
    }
}

pub trait AdmissionPolicy: Send + Sync + 'static + Debug {
    /// Determines whether the given entry should be admitted to the disk cache.
    fn pick(&self, entry: &dyn LocalCacheEntry) -> AdmitResult;

    /// A human-readable name for the policy
    #[allow(unused)]
    fn name(&self) -> &str;
}

/// A policy that admits all objects to the disk cache without any checks.
#[derive(Debug, Clone)]
pub struct AdmitAll;

impl AdmissionPolicy for AdmitAll {
    fn pick(&self, _: &dyn LocalCacheEntry) -> AdmitResult {
        AdmitResult::Admitted
    }

    fn name(&self) -> &str {
        "AdmitAll"
    }
}

/// The admission picker is responsible for deciding whether an object should be admitted to the disk cache or not.
#[derive(Debug, Clone)]
pub struct AdmissionPicker {
    policies: Vec<Arc<dyn AdmissionPolicy>>,
}

impl AdmissionPicker {
    pub fn new() -> Self {
        Self {
            policies: vec![Arc::new(AdmitAll)],
        }
    }

    #[allow(unused)]
    pub fn build_with_policies(policies: Vec<Arc<dyn AdmissionPolicy>>) -> Self {
        Self { policies }
    }

    pub fn pick(&self, entry: &dyn LocalCacheEntry) -> AdmitResult {
        for policy in self.policies.iter() {
            match policy.pick(entry) {
                AdmitResult::Admitted => {}
                AdmitResult::Rejected => return AdmitResult::Rejected,
            }
        }

        AdmitResult::Admitted
    }
}

impl Default for AdmissionPicker {
    fn default() -> Self {
        Self::new()
    }
}