shrike 0.1.5

AT Protocol library for Rust
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
125
126
127
128
129
130

use std::collections::HashMap;
use std::error::Error;
use std::fmt;

use crate::cbor::Cid;
use crate::syntax::Did;

/// Persisted chain head state for a repository.
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct ChainState {
    pub rev: String,
    pub data: Cid,
}

/// Persisted account hosting state for a repository.
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct HostingState {
    pub active: bool,
    pub status: Option<String>,
    pub seq: i64,
    pub time: String,
}

impl HostingState {
    /// Returns whether a repository should be treated as active.
    ///
    /// Missing hosting state is active by default so existing repos are not
    /// gated until an account event says otherwise.
    pub fn is_active(state: Option<&Self>) -> bool {
        state.map(|state| state.active).unwrap_or(true)
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum StateStoreOperation {
    LoadChain,
    SaveChain,
    LoadHosting,
    SaveHosting,
    Delete,
}

impl fmt::Display for StateStoreOperation {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let value = match self {
            Self::LoadChain => "load_chain",
            Self::SaveChain => "save_chain",
            Self::LoadHosting => "load_hosting",
            Self::SaveHosting => "save_hosting",
            Self::Delete => "delete",
        };
        f.write_str(value)
    }
}

#[derive(Debug, thiserror::Error)]
pub enum StateStoreError {
    #[error("state store {operation} failed for {did}: {source}")]
    Operation {
        did: Did,
        operation: StateStoreOperation,
        #[source]
        source: Box<dyn Error + Send + Sync + 'static>,
    },
}

impl StateStoreError {
    pub fn operation<E>(did: &Did, operation: StateStoreOperation, source: E) -> Self
    where
        E: Error + Send + Sync + 'static,
    {
        Self::Operation {
            did: did.clone(),
            operation,
            source: Box::new(source),
        }
    }
}

/// Storage for verifier chain and hosting state.
#[async_trait::async_trait]
pub trait StateStore: Send + Sync {
    async fn load_chain(&self, did: &Did) -> Result<Option<ChainState>, StateStoreError>;
    async fn save_chain(&self, did: &Did, state: ChainState) -> Result<(), StateStoreError>;
    async fn load_hosting(&self, did: &Did) -> Result<Option<HostingState>, StateStoreError>;
    async fn save_hosting(&self, did: &Did, state: HostingState) -> Result<(), StateStoreError>;
    async fn delete(&self, did: &Did) -> Result<(), StateStoreError>;
}

/// In-memory verifier state store.
#[derive(Debug, Default)]
pub struct MemStateStore {
    chains: tokio::sync::RwLock<HashMap<Did, ChainState>>,
    hosting: tokio::sync::RwLock<HashMap<Did, HostingState>>,
}

impl MemStateStore {
    pub fn new() -> Self {
        Self::default()
    }
}

#[async_trait::async_trait]
impl StateStore for MemStateStore {
    async fn load_chain(&self, did: &Did) -> Result<Option<ChainState>, StateStoreError> {
        Ok(self.chains.read().await.get(did).cloned())
    }

    async fn save_chain(&self, did: &Did, state: ChainState) -> Result<(), StateStoreError> {
        self.chains.write().await.insert(did.clone(), state);
        Ok(())
    }

    async fn load_hosting(&self, did: &Did) -> Result<Option<HostingState>, StateStoreError> {
        Ok(self.hosting.read().await.get(did).cloned())
    }

    async fn save_hosting(&self, did: &Did, state: HostingState) -> Result<(), StateStoreError> {
        self.hosting.write().await.insert(did.clone(), state);
        Ok(())
    }

    async fn delete(&self, did: &Did) -> Result<(), StateStoreError> {
        let mut chains = self.chains.write().await;
        let mut hosting = self.hosting.write().await;
        chains.remove(did);
        hosting.remove(did);
        Ok(())
    }
}