iridium_server 0.1.8

TDS 7.4 server for Iridium SQL
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
138
139
140
141
142

use std::path::PathBuf;

pub mod playground;
pub mod pool;
pub mod server;
pub mod session;
pub mod tds;
pub mod tds_tls_io;
pub mod tls;

use iridium_core::{SessionManager, SqlAnalyzer, StatementExecutor};

pub use server::TdsServer;

pub trait ServerDatabase: SessionManager + StatementExecutor + SqlAnalyzer + Send + Sync {}

impl<T> ServerDatabase for T where T: SessionManager + StatementExecutor + SqlAnalyzer + Send + Sync {}

#[derive(Debug, Clone)]
pub struct Credentials {
    pub user: String,
    pub password: String,
}

#[derive(Debug, Clone)]
pub struct ServerConfig {
    pub host: String,
    pub port: u16,
    pub auth: Option<Credentials>,
    pub database: String,
    pub packet_size: u16,
    pub tls_enabled: bool,
    pub tls_cert_path: Option<String>,
    pub tls_key_path: Option<String>,
    pub pool_min_size: usize,
    pub pool_max_size: usize,
    pub pool_idle_timeout_secs: u64,
    pub data_dir: Option<PathBuf>,
}

impl Default for ServerConfig {
    fn default() -> Self {
        Self {
            host: "127.0.0.1".to_string(),
            port: 1433,
            auth: None,
            database: "master".to_string(),
            packet_size: 4096,
            tls_enabled: true,
            tls_cert_path: None,
            tls_key_path: None,
            pool_min_size: 1,
            pool_max_size: 50,
            pool_idle_timeout_secs: 300,
            data_dir: None,
        }
    }
}

impl ServerConfig {
    pub fn no_auth() -> Self {
        Self::default()
    }

    pub fn with_auth(user: impl Into<String>, password: impl Into<String>) -> Self {
        Self {
            auth: Some(Credentials {
                user: user.into(),
                password: password.into(),
            }),
            ..Self::default()
        }
    }

    pub fn port(mut self, port: u16) -> Self {
        self.port = port;
        self
    }

    pub fn host(mut self, host: impl Into<String>) -> Self {
        self.host = host.into();
        self
    }

    pub fn database(mut self, db: impl Into<String>) -> Self {
        self.database = db.into();
        self
    }

    pub fn with_tls_cert(
        mut self,
        cert_path: impl Into<String>,
        key_path: impl Into<String>,
    ) -> Self {
        self.tls_enabled = true;
        self.tls_cert_path = Some(cert_path.into());
        self.tls_key_path = Some(key_path.into());
        self
    }

    pub fn disable_tls(mut self) -> Self {
        self.tls_enabled = false;
        self
    }

    pub fn pool_min_size(mut self, size: usize) -> Self {
        self.pool_min_size = size;
        self
    }

    pub fn pool_max_size(mut self, size: usize) -> Self {
        self.pool_max_size = size;
        self
    }

    pub fn pool_idle_timeout_secs(mut self, secs: u64) -> Self {
        self.pool_idle_timeout_secs = secs;
        self
    }

    pub fn data_dir(mut self, path: impl Into<PathBuf>) -> Self {
        self.data_dir = Some(path.into());
        self
    }

    pub fn resolved_data_dir(&self) -> PathBuf {
        self.data_dir.clone().unwrap_or_else(default_data_dir)
    }
}

pub fn default_data_dir() -> PathBuf {
    #[cfg(target_os = "windows")]
    {
        if let Some(program_data) = std::env::var_os("ProgramData") {
            return PathBuf::from(program_data)
                .join("Iridium SQL")
                .join("iridium_sql_data");
        }
    }

    PathBuf::from("iridium_sql_data")
}