public-appservice 0.2.0

An appservice to make Matrix spaces publicly accessible.
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

use serde::{Serialize, Deserialize};
use std::{fs, process};
use std::path::Path;


#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Config {
    pub server: Server,
    pub appservice: AppService,
    pub matrix: Matrix,
    pub redis: Redis,
    pub cache: Cache,
    pub public_rooms: PublicRooms,
    pub spaces: Spaces,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Server {
    pub port: u16,
    pub allow_origin: Option<Vec<String>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AppService {
    pub id: String,
    pub sender_localpart: String,
    pub access_token: String,
    pub hs_access_token: String,
    pub rules: AppServiceRules,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AppServiceRules {
    pub auto_join: bool,
    pub invite_by_local_user: bool,
    pub federation_domain_whitelist: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Matrix {
    pub homeserver: String,
    pub server_name: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Redis {
    pub url: String,
    #[serde(default = "default_pool_size")]
    pub pool_size: u32,
    #[serde(default = "default_timeout_secs")]
    pub timeout_secs: u64,
    #[serde(default = "default_cache_ttl")]
    pub cache_ttl: u64,
}

fn default_pool_size() -> u32 {
    10
}

fn default_timeout_secs() -> u64 {
    5
}

fn default_cache_ttl() -> u64 {
    300 
}

fn default_false() -> bool {
    false
}


#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Cache {
    pub requests: CacheOptions,
    pub public_rooms: CacheOptions,
    pub room_state: CacheOptions,
    pub messages: CacheOptions,
    pub media: CacheOptions,
    pub search: CacheOptions,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CacheOptions {
    #[serde(default = "default_false")]
    pub enabled: bool,
    #[serde(default = "default_cache_ttl")]
    pub expire_after: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PublicRooms {
    pub curated: bool,
    pub include_rooms: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Spaces {
    pub default: Vec<String>,
    pub cache: bool,
    pub ttl: u64,
}

impl Default for Spaces {
    fn default() -> Self {
        Spaces {
            default: Vec::new(),
            cache: false,
            ttl: 3600, 
        }
    }
}

impl Config {
    pub fn new(path: impl AsRef<Path>) -> Self {

        let path = path.as_ref();

        let config_content = match fs::read_to_string(path) {
            Ok(content) => content,
            Err(e) => {
                tracing::info!("Failed to read config.toml: {}", e);
                process::exit(1);
            }
        };
        
        match toml::from_str(&config_content) {
            Ok(config) => config,
            Err(e) => {
                tracing::info!("Failed to parse config.toml: {}", e);
                process::exit(1);
            }
        }
    }
}