terrazzo-terminal 0.2.8

A simple web-based terminal emulator built on Terrazzo.
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

use std::fmt::Debug;
use std::ops::Deref;
use std::sync::Arc;

use serde::Deserialize;
use serde::Serialize;
use trz_gateway_common::dynamic_config::DynamicConfig;
use trz_gateway_common::dynamic_config::has_diff::DiffArc;
use trz_gateway_common::dynamic_config::has_diff::DiffOption;
use trz_gateway_common::dynamic_config::mode::RO;
use trz_gateway_server::server::acme::AcmeConfig;
use trz_gateway_server::server::acme::DynamicAcmeConfig;

use self::mesh::DynamicMeshConfig;
use self::mesh::MeshConfig;
use self::server::DynamicServerConfig;
use self::server::ServerConfig;
use self::types::ConfigFileTypes;
use self::types::ConfigTypes;
use self::types::RuntimeTypes;

mod into_dyn;
pub(in crate::backend) mod io;
pub(in crate::backend) mod kill;
mod merge;
pub mod mesh;
pub(in crate::backend) mod password;
pub(in crate::backend) mod pidfile;
pub mod server;
pub(in crate::backend) mod types;

#[derive(Debug, Default, Serialize, Deserialize)]
#[serde(transparent)]
pub struct ConfigFile(ConfigImpl<ConfigFileTypes>);

impl Deref for ConfigFile {
    type Target = ConfigImpl<ConfigFileTypes>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

pub struct DynConfig {
    config: Arc<DynamicConfig<DiffArc<Config>>>,
    pub server: DynamicServerConfig,
    pub mesh: DynamicMeshConfig,
    pub letsencrypt: DynamicAcmeConfig,

    #[expect(unused)]
    dyn_config_file: Arc<DynamicConfig<(), RO>>,
}

impl Deref for DynConfig {
    type Target = Arc<DynamicConfig<DiffArc<Config>>>;

    fn deref(&self) -> &Self::Target {
        &self.config
    }
}

#[derive(Clone, Debug)]
pub struct Config(ConfigImpl<RuntimeTypes>);

impl Deref for Config {
    type Target = ConfigImpl<RuntimeTypes>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl From<ConfigImpl<RuntimeTypes>> for Config {
    fn from(value: ConfigImpl<RuntimeTypes>) -> Self {
        Self(value)
    }
}

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(default)]
pub struct ConfigImpl<T: ConfigTypes> {
    pub server: DiffArc<ServerConfig<T>>,
    pub mesh: DiffOption<DiffArc<MeshConfig<T>>>,
    pub letsencrypt: DiffOption<DiffArc<AcmeConfig>>,
}

impl Default for ConfigImpl<ConfigFileTypes> {
    fn default() -> Self {
        Self {
            server: Default::default(),
            mesh: Default::default(),
            letsencrypt: Default::default(),
        }
    }
}