secop-core 0.1.3

A Rust framework for a hardware server speaking the SECoP protocol (core library)
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

// -----------------------------------------------------------------------------
// Rust SECoP playground
//
// This program is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software
// Foundation; either version 2 of the License, or (at your option) any later
// version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
// details.
//
// You should have received a copy of the GNU General Public License along with
// this program; if not, write to the Free Software Foundation, Inc.,
// 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// Module authors:
//   Georg Brandl <g.brandl@fz-juelich.de>
//
// -----------------------------------------------------------------------------
//
//! Configuration file handling.

use std::path::Path;
use hashbrown::{HashMap, HashSet};
use serde_derive::{Serialize, Deserialize};
use serde_json::Value;
use toml;

use crate::types::TypeDesc;


#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Visibility {
    None,
    User,
    Advanced,
    Expert,
}

impl Default for Visibility {
    fn default() -> Self { Visibility::User }
}

#[derive(Deserialize, Debug)]
pub struct ServerConfig {
    #[serde(skip)] // provided by us
    pub equipment_id: String,
    pub description: String,
    pub modules: HashMap<String, ModuleConfig>,
}

#[derive(Deserialize, Debug, Clone)]
pub struct ModuleConfig {
    pub class: String,
    pub description: String,
    pub group: Option<String>,
    #[serde(default)]
    pub parameters: HashMap<String, Value>,
    #[serde(default)]
    pub visibility: Visibility,
}


pub fn load_config(filename: impl AsRef<Path>) -> Result<ServerConfig, String> {
    let data = std::fs::read(&filename).map_err(|e| e.to_string())?;
    let mut obj: ServerConfig = toml::from_slice(&data).map_err(|e| e.to_string())?;
    obj.equipment_id = filename.as_ref()
                               .file_stem()
                               .map_or("unknown".into(), |s| s.to_string_lossy().into_owned());

    // Check module names and groups for lowercase-uniqueness.
    let mut lc_names = HashSet::new();
    let mut lc_groups = HashSet::new();
    for modcfg in obj.modules.values() {
        if let Some(group) = modcfg.group.as_ref() {
            lc_groups.insert(group.to_string());
        }
    }
    for name in obj.modules.keys() {
        let lc_name = name.to_lowercase();
        if lc_groups.contains(&lc_name) || !lc_names.insert(lc_name) {
            return Err(format!("module name {} is not unique amoung modules and groups", name))
        }
    }

    // TODO: check presence of mandatory params

    Ok(obj)
}


// TODO: check if this is necessary vs. initialized parameters
impl ModuleConfig {
    pub fn extract_param<T: TypeDesc>(&self, param: &str, td: &T) -> Option<T::Repr> {
        self.parameters.get(param).and_then(|v| td.from_json(v).ok())
    }
}