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

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

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

use crate::models::errors::StorageError;
use crate::models::query::connections::{ConnectionConfig, ConnectionConfigUpdateCommand};
use crate::models::versioning::versioned::Versioned;
use crate::services::secrets::LocalSecretsService;
use crate::services::updatable::{CacheBackedService, UpdatableService};

const CONNECTION_CONFIGS_KEYSPACE: &str = "connection_configs_v1";

pub struct ConnectionConfigService {

    delegate: CacheBackedService<ConnectionConfigUpdateCommand, ConnectionConfig>

}

impl ConnectionConfigService {

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

}

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

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

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

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

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

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