mxlink 1.15.0

A library for connecting (linking) to the Matrix Client Server API (for building bots, etc.)
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
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

use std::path::PathBuf;

use tokio::fs;

use thiserror::Error;

use crate::PersistenceConfig;
use crate::entity::session::FullSession;
use crate::helpers::encryption::Manager as EncryptionManager;

#[derive(Error, Debug)]
pub enum SessionPersistenceError {
    #[error("IO error: {0}")]
    Io(std::io::Error),

    #[error("Encryption error: {0}")]
    Encryption(String),

    #[error("Serialization/deserialization error: {0}")]
    SerializeDeserialize(serde_json::Error),
}

impl From<SessionPersistenceError> for matrix_sdk::Error {
    fn from(val: SessionPersistenceError) -> Self {
        matrix_sdk::Error::UnknownError(Box::new(val))
    }
}

#[derive(Debug)]
pub struct Manager {
    config: PersistenceConfig,

    encryption_manager: EncryptionManager,
}

impl Manager {
    pub fn new(config: PersistenceConfig) -> Self {
        let encryption_manager = EncryptionManager::new(config.session_encryption_key.clone());

        Self {
            config,
            encryption_manager,
        }
    }

    pub(crate) fn session_file_path(&self) -> PathBuf {
        self.config.session_file_path.clone()
    }

    pub(crate) fn db_state_file_path(&self) -> PathBuf {
        self.config.db_dir_path.join("matrix-sdk-state.sqlite3")
    }

    pub(crate) fn has_existing_session(&self) -> bool {
        self.session_file_path().exists()
    }

    pub(crate) fn has_existing_db_state_file(&self) -> bool {
        self.db_state_file_path().exists()
    }

    pub(crate) fn purge_database(&self) -> Result<(), std::io::Error> {
        let base_path = self.config.db_dir_path.clone();

        for entry in std::fs::read_dir(base_path)? {
            let entry = entry?;
            let path = entry.path();
            if !path.is_file() {
                continue;
            }

            // Out of precaution, we'll only be deleting *.sqlite3 files
            if path.extension().is_none_or(|ext| ext != "sqlite3") {
                continue;
            }

            std::fs::remove_file(path)?;
        }

        Ok(())
    }

    pub(crate) async fn read_full_session(&self) -> Result<FullSession, SessionPersistenceError> {
        let serialized_potentially_encrypted_session =
            fs::read_to_string(&self.config.session_file_path)
                .await
                .map_err(SessionPersistenceError::Io)?;

        let serialized_session = self
            .encryption_manager
            .decrypt_string(&serialized_potentially_encrypted_session)
            .map_err(SessionPersistenceError::Encryption)?;

        let full_sesson: FullSession = serde_json::from_str(&serialized_session)
            .map_err(SessionPersistenceError::SerializeDeserialize)?;

        Ok(full_sesson)
    }

    /// Persist the sync token for a future session.
    /// Note that this is needed only when using `sync_once`. Other sync methods get
    /// the sync token from the store.
    pub(crate) async fn persist_sync_token(
        &self,
        sync_token: String,
    ) -> Result<(), SessionPersistenceError> {
        let mut full_session = self.read_full_session().await?;

        full_session.sync_token = Some(sync_token);

        self.persist_full_session(&full_session).await?;

        Ok(())
    }

    pub(crate) async fn persist_full_session(
        &self,
        full_session: &FullSession,
    ) -> Result<(), SessionPersistenceError> {
        let serialized_session = serde_json::to_string(full_session)
            .map_err(SessionPersistenceError::SerializeDeserialize)?;

        let serialized_potentially_encrypted_session = self
            .encryption_manager
            .encrypt_string(&serialized_session)
            .map_err(SessionPersistenceError::Encryption)?;

        fs::write(
            &self.config.session_file_path,
            serialized_potentially_encrypted_session,
        )
        .await
        .map_err(SessionPersistenceError::Io)?;

        Ok(())
    }
}