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

/*
 * DMNTK - Decision Model and Notation Toolkit
 *
 * Common definitions
 *
 * Copyright 2018-2021 Dariusz Depta Engos Software <dariusz.depta@engos.software>
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

//! Configuration.

use {self::errors::*, crate::Result, serde_derive::Deserialize};

/// Configuration.
#[derive(Debug, Default, Deserialize)]
pub struct Configuration {
  pub server: ServerConfiguration,
}

/// Server configuration.
#[derive(Debug, Deserialize)]
pub struct ServerConfiguration {
  pub host: String,
  pub port: u16,
}

impl Default for ServerConfiguration {
  fn default() -> Self {
    Self {
      host: "0.0.0.0".to_string(),
      port: 17000,
    }
  }
}

const CONFIGURATION_FILE: &str = include_str!("config.yml");

/// Returns configuration.
pub fn get_configuration() -> Result<Configuration> {
  serde_yaml::from_str(CONFIGURATION_FILE).map_err(|e| parse_error(e.to_string()))
}

/// Definitions of errors reported by the server.
mod errors {
  use crate::DmntkError;

  /// Server errors.
  #[derive(Debug, PartialEq)]
  enum ConfigurationError {
    ParseError(String),
  }

  impl From<ConfigurationError> for DmntkError {
    fn from(e: ConfigurationError) -> Self {
      DmntkError::new("ConfigurationError", &format!("{}", e))
    }
  }

  impl std::fmt::Display for ConfigurationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
      match self {
        ConfigurationError::ParseError(reason) => {
          write!(f, "parsing configuration file failed with reason: {}", reason)
        }
      }
    }
  }

  pub fn parse_error(reason: String) -> DmntkError {
    ConfigurationError::ParseError(reason).into()
  }
}

#[cfg(test)]
mod tests {
  use crate::config::{get_configuration, ServerConfiguration};

  #[test]
  fn test_default_server_configuration() {
    let server_configuration = ServerConfiguration::default();
    assert_eq!("0.0.0.0", server_configuration.host);
    assert_eq!(17000, server_configuration.port);
  }

  #[test]
  fn test_configuration_file() {
    let configuration = get_configuration().unwrap();
    assert_eq!("127.0.0.1", configuration.server.host);
    assert_eq!(12000, configuration.server.port);
  }
}