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

//! # Config
//!
//! Define and implement config options for module

use anyhow::Result;
use config::{ConfigError, Environment};
use dotenv::dotenv;
use serde::Deserialize;

/// struct holding configuration options
#[derive(Debug, Deserialize, Clone)]
pub struct Config {
    /// port to be used for gRPC server
    pub docker_port_grpc: u16,
    /// port to be used for REST server
    pub docker_port_rest: u16,
    /// path to log configuration YAML file
    pub log_config: String,
    /// Rate limit - requests per second for REST requests
    pub rest_request_limit_per_second: u8,
    /// Enforces a limit on the concurrent number of requests the underlying service can handle
    pub rest_concurrency_limit_per_service: u8,
    /// Full url (including port number) to be allowed as request origin for
    /// REST requests
    pub rest_cors_allowed_origin: String,
}

impl Default for Config {
    fn default() -> Self {
        log::warn!("Creating Config object with default values.");
        Self::new()
    }
}

impl Config {
    /// Default values for Config
    pub fn new() -> Self {
        Config {
            docker_port_grpc: 50051,
            docker_port_rest: 8000,
            log_config: String::from("log4rs.yaml"),
            rest_request_limit_per_second: 2,
            rest_concurrency_limit_per_service: 5,
            rest_cors_allowed_origin: String::from("http://localhost:3000"),
        }
    }

    /// Create a new `Config` object using environment variables
    pub fn try_from_env() -> Result<Self, ConfigError> {
        // read .env file if present
        dotenv().ok();
        let default_config = Config::default();

        config::Config::builder()
            .set_default("docker_port_grpc", default_config.docker_port_grpc)?
            .set_default("docker_port_rest", default_config.docker_port_rest)?
            .set_default("log_config", default_config.log_config)?
            .set_default(
                "rest_concurrency_limit_per_service",
                default_config.rest_concurrency_limit_per_service,
            )?
            .set_default(
                "rest_request_limit_per_seconds",
                default_config.rest_request_limit_per_second,
            )?
            .set_default(
                "rest_cors_allowed_origin",
                default_config.rest_cors_allowed_origin,
            )?
            .add_source(Environment::default().separator("__"))
            .build()?
            .try_deserialize()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_config_from_default() {
        let config = Config::default();

        assert_eq!(config.docker_port_grpc, 50051);
        assert_eq!(config.docker_port_rest, 8000);
        assert_eq!(config.log_config, String::from("log4rs.yaml"));
        assert_eq!(config.rest_concurrency_limit_per_service, 5);
        assert_eq!(config.rest_request_limit_per_second, 2);
        assert_eq!(
            config.rest_cors_allowed_origin,
            String::from("http://localhost:3000")
        );
    }

    #[tokio::test]
    async fn test_config_from_env() {
        async move {
            std::env::set_var("DOCKER_PORT_GRPC", "6789");
            std::env::set_var("DOCKER_PORT_REST", "9876");
            std::env::set_var("LOG_CONFIG", "config_file.yaml");
            std::env::set_var("REST_CONCURRENCY_LIMIT_PER_SERVICE", "255");
            std::env::set_var("REST_REQUEST_LIMIT_PER_SECOND", "255");
            std::env::set_var(
                "REST_CORS_ALLOWED_ORIGIN",
                "https://allowed.origin.host:443",
            );

            let config = Config::try_from_env();
            assert!(config.is_ok());
            let config = config.unwrap();

            assert_eq!(config.docker_port_grpc, 6789);
            assert_eq!(config.docker_port_rest, 9876);
            assert_eq!(config.log_config, String::from("config_file.yaml"));
            assert_eq!(config.rest_concurrency_limit_per_service, 255);
            assert_eq!(config.rest_request_limit_per_second, 255);
            assert_eq!(
                config.rest_cors_allowed_origin,
                String::from("https://allowed.origin.host:443")
            );
        }
        .await
    }
}