nautalid 0.1.0

Scratch container substrate — TLS 1.3 HTTP/2+3 kernel, LID/AetherDB, optional filter bus (GPL-3.0-or-later).
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

use std::sync::{Arc, RwLock};

use super::FilterPolicy;
use thiserror::Error;

#[derive(Debug, Error)]
pub enum FilterStoreError {
    #[error("filter policy lock poisoned")]
    Poisoned,
}

/// Shared filter policy (startup env + runtime reload via **`bus`**).
#[derive(Clone)]
pub struct FilterStore(Arc<RwLock<FilterPolicy>>);

impl FilterStore {
    #[must_use]
    pub fn new(policy: FilterPolicy) -> Self {
        Self(Arc::new(RwLock::new(policy)))
    }

    #[must_use]
    pub fn default_allow_all() -> Self {
        Self::new(FilterPolicy::default())
    }

    pub fn replace(&self, policy: FilterPolicy) -> Result<(), FilterStoreError> {
        self.0
            .write()
            .map_err(|_| FilterStoreError::Poisoned)
            .map(|mut guard| *guard = policy)
    }

    #[must_use]
    pub fn snapshot(&self) -> FilterPolicy {
        self.0.read().map(|g| g.clone()).unwrap_or_default()
    }

    pub fn read<R>(&self, f: impl FnOnce(&FilterPolicy) -> R) -> R {
        let guard = self.0.read().expect("filter lock poisoned");
        f(&guard)
    }
}

impl Default for FilterStore {
    fn default() -> Self {
        Self::default_allow_all()
    }
}