swindon 0.7.8

An HTTP edge (frontend) server with smart websockets support 
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

use std::time::Duration;

use quire::validate::{Structure, Scalar, Enum, Numeric, Nothing};
use quire::validate::{Sequence};

#[derive(Deserialize, Debug, PartialEq, Eq)]
#[allow(non_camel_case_types)]
pub enum LoadBalancing {
    queue,
}

#[derive(Deserialize, Debug, PartialEq, Eq)]
pub struct Destination {
    pub load_balancing: LoadBalancing,
    pub queue_size_for_503: usize,
    pub backend_connections_per_ip_port: u32,
    pub in_flight_requests_per_backend_connection: usize,
    pub addresses: Vec<String>,
    #[serde(with="::quire::duration")]
    pub keep_alive_timeout: Duration,
    #[serde(with="::quire::duration")]
    pub max_request_timeout: Duration,
    #[serde(with="::quire::duration")]
    pub safe_pipeline_timeout: Duration,
    pub override_host_header: Option<String>,
    pub request_id_header: Option<String>,
}

pub fn validator<'x>() -> Structure<'x> {
    Structure::new()
    .member("load_balancing", Enum::new()
        .option("queue", Nothing)
        .allow_plain()
        .plain_default("queue"))
    .member("queue_size_for_503",
        Numeric::new().min(0).max(1 << 32).default(100_000))
    .member("backend_connections_per_ip_port",
        Numeric::new().min(1).max(100_000).default(100))
    .member("in_flight_requests_per_backend_connection",
        Numeric::new().min(1).max(1000).default(2))
    .member("addresses", Sequence::new(Scalar::new()).min_length(1))
    .member("keep_alive_timeout", Scalar::new().default("4 sec"))
    .member("max_request_timeout", Scalar::new().default("30 secs"))
    .member("safe_pipeline_timeout", Scalar::new().default("300 ms"))
    .member("override_host_header", Scalar::new().optional())
    .member("request_id_header", Scalar::new().optional())
}