pooly 0.2.1

A protobuf to Postgres adapter + connection pooling middleware.
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

use std::collections::HashSet;
use std::sync::Arc;

use dashmap::mapref::one::Ref;
use sled::Db;

use crate::LocalSecretsService;
use crate::models::auth::access::{LiteralConnectionIdAccessEntry, WildcardPatternConnectionIdAccessEntry};
use crate::models::errors::StorageError;
use crate::models::versioning::updatable::{StringSetCommand, WildcardPatternSetCommand};
use crate::models::versioning::versioned::Versioned;
use crate::services::updatable::{CacheBackedService, UpdatableService};

const LITERAL_CONNECTION_IDS: &str = "literal_connection_id_aces_v1";
const PATTERN_CONNECTION_IDS: &str = "pattern_connection_id_aces_v1";

pub struct LiteralConnectionIdAccessEntryService {

    delegate: CacheBackedService<StringSetCommand, LiteralConnectionIdAccessEntry>

}

pub struct WildcardPatternConnectionIdAccessEntryService {

    delegate: CacheBackedService<WildcardPatternSetCommand, WildcardPatternConnectionIdAccessEntry>

}

impl LiteralConnectionIdAccessEntryService {

    pub fn new(db: Arc<Db>,
               secrets_service: Arc<LocalSecretsService>)
               -> Result<LiteralConnectionIdAccessEntryService, StorageError> {
        Ok(
            LiteralConnectionIdAccessEntryService {
                delegate: CacheBackedService::new(
                    db, LITERAL_CONNECTION_IDS, secrets_service)?
            }
        )
    }

}

impl WildcardPatternConnectionIdAccessEntryService {

    pub fn new(db: Arc<Db>,
               secrets_service: Arc<LocalSecretsService>)
               -> Result<WildcardPatternConnectionIdAccessEntryService, StorageError> {
        Ok(
            WildcardPatternConnectionIdAccessEntryService {
                delegate: CacheBackedService::new(
                    db, PATTERN_CONNECTION_IDS, secrets_service)?
            }
        )
    }

}

impl UpdatableService<StringSetCommand, LiteralConnectionIdAccessEntry> for LiteralConnectionIdAccessEntryService {
    fn get(&self, id: &str) -> Result<Option<Ref<String, Versioned<LiteralConnectionIdAccessEntry>>>, StorageError> {
        self.delegate.get(id)
    }

    fn get_all_keys(&self) -> Result<HashSet<String>, StorageError> {
        self.delegate.get_all_keys()
    }

    fn create(&self, payload: LiteralConnectionIdAccessEntry) -> Result<Versioned<LiteralConnectionIdAccessEntry>, StorageError> {
        self.delegate.create(payload)
    }

    fn update(&self, id: &str, command: StringSetCommand) -> Result<Versioned<LiteralConnectionIdAccessEntry>, StorageError> {
        self.delegate.update(id, command)
    }

    fn delete(&self, id: &str) -> Result<(), StorageError> {
        self.delegate.delete(id)
    }

    fn clear(&self) -> Result<(), ()> {
        self.delegate.clear()
    }
}

impl UpdatableService<WildcardPatternSetCommand, WildcardPatternConnectionIdAccessEntry> for WildcardPatternConnectionIdAccessEntryService {
    fn get(&self, id: &str) -> Result<Option<Ref<String, Versioned<WildcardPatternConnectionIdAccessEntry>>>, StorageError> {
        self.delegate.get(id)
    }

    fn get_all_keys(&self) -> Result<HashSet<String>, StorageError> {
        self.delegate.get_all_keys()
    }

    fn create(&self, payload: WildcardPatternConnectionIdAccessEntry) -> Result<Versioned<WildcardPatternConnectionIdAccessEntry>, StorageError> {
        self.delegate.create(payload)
    }

    fn update(&self, id: &str, command: WildcardPatternSetCommand) -> Result<Versioned<WildcardPatternConnectionIdAccessEntry>, StorageError> {
        self.delegate.update(id, command)
    }

    fn delete(&self, id: &str) -> Result<(), StorageError> {
        self.delegate.delete(id)
    }

    fn clear(&self) -> Result<(), ()> {
        self.delegate.clear()
    }
}