msg_store_server_api 0.1.1

The backbone of the msg-store api that can be embedded into various server implementations
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

use crate::{
    Database,
    stats::Stats
};
use crate::file_storage::{rm_from_file_storage, FileStorage, FileStorageError};
use msg_store::{Store, StoreError};
use msg_store_uuid::Uuid;
use msg_store_database_plugin::DatabaseError;
use std::fmt::Display;
use std::sync::{Arc, Mutex};

#[derive(Debug)]
pub enum RemoveErrorTy {
    DatabaseError(DatabaseError),
    FileStorageError(FileStorageError),
    StoreError(StoreError),
    CouldNotFindFileStorage,
    LockingError,
    CouldNotGetNextChunkFromPayload,
    CouldNotParseChunk
}
impl Display for RemoveErrorTy {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::DatabaseError(err) => write!(f, "({})", err),
            Self::FileStorageError(err) => write!(f, "({})", err),
            Self::StoreError(err) => write!(f, "({})", err),
            Self::CouldNotFindFileStorage |
            Self::LockingError |
            Self::CouldNotGetNextChunkFromPayload |
            Self::CouldNotParseChunk => write!(f, "{:#?}", self)
        }
    }
}

#[derive(Debug)]
pub struct RemoveError {
    pub err_ty: RemoveErrorTy,
    pub file: &'static str,
    pub line: u32,
    pub msg: Option<String>
}

impl Display for RemoveError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if let Some(msg) = &self.msg {
            write!(f, "REMOVE_MSG_ERROR: {}. file: {}, line: {}, msg: {}", self.err_ty, self.file, self.line, msg)
        } else {
            write!(f, "REMOVE_MSG_ERROR: {}. file: {}, line: {}.", self.err_ty, self.file, self.line)
        }
    }   
}

macro_rules! rm_msg_error {
    ($err_ty:expr) => {
        RemoveError {
            err_ty: $err_ty,
            file: file!(),
            line: line!(),
            msg: None
        }
    };
    ($err_ty:expr, $msg:expr) => {
        RemoveError {
            err_ty: $err_ty,
            file: file!(),
            line: line!(),
            msg: Some($msg.to_string())
        }
    };
}

pub async fn handle(
    store_mutex: &Mutex<Store>,
    database_mutex: &Mutex<Database>,
    file_storage_option: &Option<Mutex<FileStorage>>,
    stats_mutex: &Mutex<Stats>, uuid: Arc<Uuid>
) -> Result<(), RemoveError> {
    let mut store = match store_mutex.lock() {
        Ok(gaurd) => Ok(gaurd),
        Err(err) => Err(rm_msg_error!(RemoveErrorTy::LockingError, err))
    }?;
    let mut stats = match stats_mutex.lock() {
        Ok(gaurd) => Ok(gaurd),
        Err(err) => Err(rm_msg_error!(RemoveErrorTy::LockingError, err))
    }?;
    let mut db = match database_mutex.lock() {
        Ok(gaurd) => Ok(gaurd),
        Err(err) => Err(rm_msg_error!(RemoveErrorTy::LockingError, err))
    }?;
    if let Err(error) = store.del(uuid.clone()) {
        return Err(rm_msg_error!(RemoveErrorTy::StoreError(error)))
    }    
    if let Err(error) = db.del(uuid.clone()) {
        return Err(rm_msg_error!(RemoveErrorTy::DatabaseError(error)));
    }
    if let Some(file_storage_mutex) = &file_storage_option {
        let mut file_storage = match file_storage_mutex.lock() {
            Ok(gaurd) => Ok(gaurd),
            Err(err) => Err(rm_msg_error!(RemoveErrorTy::LockingError, err))
        }?;
        if let Err(error) = rm_from_file_storage(&mut file_storage, &uuid) {
            return Err(rm_msg_error!(RemoveErrorTy::FileStorageError(error)))
        }
    }
    stats.deleted += 1;
    Ok(())
}