taktwerk 0.5.2

Fixed-step model execution engine for Linux with its own OPC UA server
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

//! Model adapters and connectors by their project `kind`.

use std::path::Path;
use std::sync::Arc;

use clap::ValueEnum;
use taktwerk_core::connector::Connector;
use taktwerk_core::model::ModelAdapter;
use taktwerk_core::project::ConnectorConfig;

/// A model adapter kind.
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
pub enum ModelKind {
    /// FMI 2 or FMI 3 co-simulation FMU (`.fmu` or an extracted directory).
    Fmi,
    /// Raw C library package (`taktwerk-model.toml` and libraries).
    Raw,
}

impl ModelKind {
    /// The `kind` string of the project file.
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Fmi => "fmi",
            Self::Raw => "raw",
        }
    }

    /// Parse a project `kind`.
    ///
    /// # Errors
    /// An unknown kind, with the known ones listed.
    pub fn parse(kind: &str) -> Result<Self, String> {
        match kind {
            "fmi" => Ok(Self::Fmi),
            "raw" => Ok(Self::Raw),
            other => Err(format!(
                "unknown model kind `{other}`; known kinds: fmi, raw"
            )),
        }
    }

    /// Load the model at `path`.
    ///
    /// # Errors
    /// The adapter's load error, as text.
    pub fn load(self, path: &Path) -> Result<Arc<dyn ModelAdapter>, String> {
        match self {
            Self::Fmi => taktwerk_fmi::FmuAdapter::load(path)
                .map(|a| Arc::new(a) as Arc<dyn ModelAdapter>)
                .map_err(|e| e.to_string()),
            Self::Raw => taktwerk_raw::RawModel::load(path)
                .map(|a| Arc::new(a) as Arc<dyn ModelAdapter>)
                .map_err(|e| e.to_string()),
        }
    }
}

/// Connector kinds this binary builds.
pub const CONNECTOR_KINDS: &[&str] = &[taktwerk_opcua::server::KIND, taktwerk_opcua::client::KIND];

/// Build the connector `config` describes.
///
/// # Errors
/// An unknown kind, with the known ones listed, or the connector's own config error.
pub fn connector(config: &ConnectorConfig) -> Result<Box<dyn Connector>, String> {
    if taktwerk_opcua::handles(&config.kind) {
        return taktwerk_opcua::build(config).map_err(|e| e.to_string());
    }
    Err(format!(
        "connector `{}`: unknown kind `{}`; known kinds: {}",
        config.id,
        config.kind,
        CONNECTOR_KINDS.join(", ")
    ))
}

#[cfg(test)]
#[allow(
    clippy::unwrap_used,
    clippy::expect_used,
    clippy::panic,
    reason = "tests"
)]
mod tests {
    use super::*;

    #[test]
    fn unknown_kinds_list_the_known_ones() {
        let err = ModelKind::parse("onnx").unwrap_err();
        assert!(err.contains("fmi, raw"), "{err}");
        let config: ConnectorConfig = toml::from_str("id = \"bus\"\nkind = \"modbus\"\n").unwrap();
        let err = connector(&config).err().unwrap();
        assert!(err.contains("opcua-server, opcua-client"), "{err}");
        assert!(err.contains("`bus`"), "{err}");
    }

    #[test]
    fn builds_the_own_server() {
        let config: ConnectorConfig = toml::from_str(
            "id = \"ua\"\nkind = \"opcua-server\"\nendpoint = \"opc.tcp://127.0.0.1:4840\"\n",
        )
        .unwrap();
        assert_eq!(connector(&config).unwrap().id(), "ua");
    }
}