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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use async_trait::async_trait;
use cyfs_base::BuckyError;
use crate::get_cyfs_root_path;
use rusqlite::Connection;
use std::error::Error;
use std::path::PathBuf;

const TABLE_NAME: &str = "profile";

pub struct SqliteStorage {
    inited: bool,
    path: PathBuf,
    dirty: bool,
    //conn: Option<Connection>,
}

impl SqliteStorage {
    pub fn new() -> SqliteStorage {
        SqliteStorage {
            inited: false,
            path: PathBuf::from(""),
            dirty: false,
            //conn: None,
        }
    }

    pub async fn init(&mut self, service_name: &str) -> Result<(), Box<dyn Error>> {
        assert!(!self.inited);
        self.inited = true;

        let dir = get_cyfs_root_path().join("profile").join(service_name);
        if !dir.is_dir() {
            if let Err(e) = std::fs::create_dir_all(&dir) {
                let msg = format!("create profile dir error! dir={}, err={}", dir.display(), e);
                error!("{}", msg);

                return Err(Box::<dyn Error>::from(msg));
            }
        }

        let file = dir.join("profile.db");
        self.path = file;
        debug!(
            "sqlite storage service: {}, file path: {}",
            service_name,
            self.path.display()
        );
        if !self.path.exists() {
            info!("sqlite storage file not exists! db={}", self.path.display());
            self.create_db()?;
        }
        // let conn = Connection::open(self.path.as_path()).map_err(|e| {
        //     warn!("open db failed, db={}, e={}", self.path.display(), e);
        //     e
        // })?;
        //self.conn = Some(conn);

        Ok(())
    }

    fn create_db(&mut self) -> Result<(), Box<dyn Error>> {
        let conn = Connection::open(self.path.as_path()).map_err(|e| {
            warn!("open db failed, db={}, e={}", self.path.display(), e);
            e
        })?;
        let sql = format!(
            "CREATE TABLE IF NOT EXISTS {} (
                key TEXT PRIMARY KEY NOT NULL UNIQUE, 
                value BLOB NOT NULL
            );",
            TABLE_NAME
        );
        conn.execute(&sql, []).map_err(|e| e)?;
        Ok(())
    }
}

#[async_trait]
impl super::AsyncStorage for SqliteStorage {
    async fn set_item(&mut self, key: &str, value: String) -> Result<(), BuckyError> {
        assert!(self.inited);
        //let conn = self.conn.as_ref().unwrap();
        let conn = Connection::open(self.path.as_path()).map_err(|e| {
            warn!("open db failed, db={}, e={}", self.path.display(), e);
            e
        })?;
        let sql = format!("REPLACE INTO {} (key, value) VALUES (?1, ?2)", TABLE_NAME);
        conn.execute(&sql, rusqlite::params![key, value])
            .map_err(|e| {
                warn!("[sqlite] set item failed, e={}", e);
                e
            })?;
        Ok(())
    }

    async fn get_item(&self, key: &str) -> Option<String> {
        assert!(self.inited);
        let conn = Connection::open(self.path.as_path())
            .map_err(|e| {
                warn!("open db failed, db={}, e={}", self.path.display(), e);
                e
            })
            .ok()?;
        let sql = format!("SELECT value FROM {} WHERE key=?1", TABLE_NAME);
        match conn.query_row(&sql, rusqlite::params![key], |row| {
            let value: String = row.get(0)?;
            Ok(value)
        }) {
            Ok(value) => Some(value),
            Err(_e) => None,
        }
    }

    async fn remove_item(&mut self, key: &str) -> Option<()> {
        assert!(self.inited);
        let conn = Connection::open(self.path.as_path())
            .map_err(|e| {
                warn!("open db failed, db={}, e={}", self.path.display(), e);
                e
            })
            .ok()?;
        let sql = format!("DELETE FROM {} WHERE key=?1", TABLE_NAME);
        let r = conn.execute(&sql, rusqlite::params![key]).map_err(|e| {
            warn!("[sqlite] remove item failed, key={}, e={}", key, e);
        });
        debug!("remove item return: {:?}", r);

        if r.unwrap() > 0 {
            Some(())
        } else {
            None
        }
    }

    async fn clear(&mut self) {
        assert!(self.inited);
        if let Ok(conn) = Connection::open(self.path.as_path()) {
            let sql = format!("DELETE FROM {}", TABLE_NAME);
            let _r = conn.execute(&sql, []).map_err(|e| {
                warn!("[sqlite] clear failed e={}", e);
            });
        }
    }

    async fn clear_with_prefix(&mut self, prefix: &str) {
        assert!(self.inited);
        if let Ok(conn) = Connection::open(self.path.as_path()) {
            let sql = format!("DELETE FROM {} WHERE key LIKE ?1", TABLE_NAME);
            let _r = conn
                .execute(&sql, rusqlite::params![format!("{}%", prefix)])
                .map_err(|e| {
                    warn!(
                        "[sqlite] clear with prefix failed, prefix={}, e={}",
                        prefix, e
                    );
                });
        }
    }
}