safir_core/
lib.rs

1pub mod config;
2pub mod disk;
3pub mod mem;
4pub mod utils;
5
6use anyhow::Result;
7use async_trait::async_trait;
8use std::any::Any;
9
10use config::SafirConfig;
11use disk::SafirStore;
12use mem::SafirMemcache;
13
14#[derive(Debug, PartialEq)]
15pub enum SafirEngineType {
16    Store,
17    Memcache,
18}
19
20#[async_trait]
21pub trait SafirEngine {
22    async fn add_entry(&mut self, key: String, value: String) -> Result<()>;
23    async fn get_entry(&self, key: String) -> Result<()>;
24    async fn remove_entry(&mut self, keys: Vec<String>) -> Result<()>;
25    async fn clear_entries(&mut self) -> Result<()>;
26    async fn set_commands(&mut self, prefix: &str, keys: &Vec<String>);
27    fn to_type(&self) -> &dyn Any;
28}
29
30pub struct Safir {
31    pub engine: Box<dyn SafirEngine>,
32    pub config: SafirConfig,
33}
34
35impl Safir {
36    pub async fn new(engine_type: SafirEngineType) -> Result<Self> {
37        let config = utils::init().await?;
38        match engine_type {
39            SafirEngineType::Store => {
40                let e = crate::disk::SafirStore::new(&config).await?;
41                Ok(Self {
42                    engine: Box::new(e),
43                    config,
44                })
45            }
46            SafirEngineType::Memcache => {
47                let e = crate::mem::SafirMemcache::new(&config).await?;
48                Ok(Self {
49                    engine: Box::new(e),
50                    config,
51                })
52            }
53        }
54    }
55
56    pub async fn add_entry(&mut self, key: String, value: String) -> Result<()> {
57        self.engine.add_entry(key, value).await?;
58        Ok(())
59    }
60
61    pub async fn get_entry(&self, key: String) -> Result<()> {
62        self.engine.get_entry(key).await?;
63        Ok(())
64    }
65
66    pub async fn remove_entry(&mut self, keys: Vec<String>) -> Result<()> {
67        self.engine.remove_entry(keys).await?;
68        Ok(())
69    }
70
71    pub async fn clear_entries(&mut self) -> Result<()> {
72        self.engine.clear_entries().await?;
73        Ok(())
74    }
75
76    pub async fn set_commands(&mut self, prefix: &str, keys: &Vec<String>) {
77        self.engine.set_commands(prefix, keys).await;
78    }
79
80    pub fn as_safir_store(&self) -> &SafirStore {
81        self.engine
82            .to_type()
83            .downcast_ref::<SafirStore>()
84            .expect("unable to get Safir store type")
85    }
86
87    pub fn as_safir_memcache(&self) -> &SafirMemcache {
88        self.engine
89            .to_type()
90            .downcast_ref::<SafirMemcache>()
91            .expect("unable to get Safir memcache type")
92    }
93}