enderpearl 1.0.1

Async proxy for Minecraft and HTTP traffic with automated server wake-up.
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

use crate::core::types::{EnderConfig, EnderRoute, StartupOn};
use crate::errors::{EnderError, Result};
use crate::protocols::ProtocolMeta;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(deny_unknown_fields)]
pub struct TomlConfig {
    pub server: ServerConfig,
    pub upstream: HashMap<String, TomlRoute>,
}

#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(deny_unknown_fields)]
pub struct ServerConfig {
    #[serde(default = "default_bind")]
    pub bind: String,
    pub port: u16,
    #[serde(default = "default_peek_buffer")]
    pub peek_buffer_size: usize,
    #[serde(default = "default_peek_timeout")]
    pub peek_timeout_ms: u64,
    #[serde(default)]
    pub debug: bool,
}

#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(deny_unknown_fields)]
pub struct TomlRoute {
    pub forward_to: TomlTarget,
    #[serde(alias = "wake_command")]
    pub startup_cmd: Option<String>,
    #[serde(default = "default_startup_on")]
    pub startup_on: TomlStartupOn,
    pub shutdown_cmd: Option<String>,
    #[serde(default = "default_shutdown_timeout")]
    pub shutdown_timeout: u64,
    #[serde(default = "default_check_interval")]
    pub check_interval: u64,
    #[serde(default)]
    pub min_players: usize,
    pub startup_webhook: Option<String>,
    pub shutdown_webhook: Option<String>,
    pub offline_motd: Option<String>,
    pub offline_message: Option<String>,
}

#[derive(Debug, Deserialize, Serialize, Clone, Copy)]
#[serde(rename_all = "snake_case")]
pub enum TomlStartupOn {
    Join,
    Ping,
    Always,
}

fn default_startup_on() -> TomlStartupOn {
    TomlStartupOn::Join
}

#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(untagged)]
pub enum TomlTarget {
    Address(String),
    Pool(Vec<String>),
}

fn default_bind() -> String {
    "0.0.0.0".to_string()
}

const fn default_peek_buffer() -> usize {
    1024
}

const fn default_peek_timeout() -> u64 {
    3000
}

const fn default_shutdown_timeout() -> u64 {
    300
}

const fn default_check_interval() -> u64 {
    60
}

impl TryFrom<TomlConfig> for EnderConfig {
    type Error = EnderError;

    fn try_from(toml: TomlConfig) -> Result<Self> {
        let upstreams = toml
            .upstream
            .into_iter()
            .map(|(name, route)| {
                let targets = match route.forward_to {
                    TomlTarget::Address(s) => vec![s],
                    TomlTarget::Pool(v) => v,
                };

                let meta = ProtocolMeta::lookup(&name).ok_or_else(|| {
                    EnderError::Config(name.clone(), "unknown protocol".to_string())
                })?;

                let protocol = meta.kind.instantiate(toml.server.debug).ok_or_else(|| {
                    EnderError::Config(name.clone(), format!("requires '{}' feature", meta.feature))
                })?;

                Ok(EnderRoute {
                    protocol,
                    targets,
                    proxy: None,
                    startup_on: match route.startup_on {
                        TomlStartupOn::Join => StartupOn::Join,
                        TomlStartupOn::Ping => StartupOn::Ping,
                        TomlStartupOn::Always => StartupOn::Always,
                    },
                    handler: None, // Will be injected by the caller (CLI or Lib user)
                    shutdown_timeout_secs: route.shutdown_timeout,
                    check_interval_secs: route.check_interval,
                    min_players: route.min_players,
                    startup_webhook: route.startup_webhook,
                    shutdown_webhook: route.shutdown_webhook,
                    offline_motd: route.offline_motd,
                    offline_message: route.offline_message,
                })
            })
            .collect::<Result<Vec<_>>>()?;

        Ok(Self {
            bind: toml.server.bind,
            port: toml.server.port,
            peek_buffer_size: toml.server.peek_buffer_size,
            peek_timeout_ms: toml.server.peek_timeout_ms,
            upstreams,
            debug: toml.server.debug,
        })
    }
}