path: root/crates/core/tedge/src/cli/connect/bridge_config.rs

use crate::cli::connect::ConnectError;

use tedge_config::FilePath;
use url::Url;

#[derive(Debug, Eq, PartialEq)]
pub struct BridgeConfig {
    pub cloud_name: String,
    pub config_file: String,
    pub connection: String,
    pub address: String,
    pub remote_username: Option<String>,
    pub bridge_root_cert_path: FilePath,
    pub remote_clientid: String,
    pub local_clientid: String,
    pub bridge_certfile: FilePath,
    pub bridge_keyfile: FilePath,
    pub use_mapper: bool,
    pub use_agent: bool,
    pub try_private: bool,
    pub start_type: String,
    pub clean_session: bool,
    pub notifications: bool,
    pub notifications_local_only: bool,
    pub notification_topic: String,
    pub bridge_attempt_unsubscribe: bool,
    pub topics: Vec<String>,
}

impl BridgeConfig {
    pub fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
        writeln!(writer, "### Bridge")?;
        writeln!(writer, "connection {}", self.connection)?;
        match &self.remote_username {
            Some(name) => {
                writeln!(writer, "remote_username {}", name)?;
            }
            None => {}
        }
        writeln!(writer, "address {}", self.address)?;

        if std::fs::metadata(&self.bridge_root_cert_path)?.is_dir() {
            writeln!(writer, "bridge_capath {}", self.bridge_root_cert_path)?;
        } else {
            writeln!(writer, "bridge_cafile {}", self.bridge_root_cert_path)?;
        }

        writeln!(writer, "remote_clientid {}", self.remote_clientid)?;
        writeln!(writer, "local_clientid {}", self.local_clientid)?;
        writeln!(writer, "bridge_certfile {}", self.bridge_certfile)?;
        writeln!(writer, "bridge_keyfile {}", self.bridge_keyfile)?;
        writeln!(writer, "try_private {}", self.try_private)?;
        writeln!(writer, "start_type {}", self.start_type)?;
        writeln!(writer, "cleansession {}", self.clean_session)?;
        writeln!(writer, "notifications {}", self.notifications)?;
        writeln!(
            writer,
            "notifications_local_only {}",
            self.notifications_local_only
        )?;
        writeln!(writer, "notification_topic {}", self.notification_topic)?;
        writeln!(
            writer,
            "bridge_attempt_unsubscribe {}",
            self.bridge_attempt_unsubscribe
        )?;

        writeln!(writer, "\n### Topics",)?;
        for topic in &self.topics {
            writeln!(writer, "topic {}", topic)?;
        }

        Ok(())
    }

    pub fn validate(&self) -> Result<(), ConnectError> {
        // XXX: This is actually wrong. Our address looks like this: `domain:port`
        // `Url::parse` will treat `domain` as `schema` ...
        Url::parse(&self.address)?;

        if !self.bridge_root_cert_path.as_ref().exists() {
            return Err(ConnectError::Certificate);
        }

        if !self.bridge_certfile.as_ref().exists() {
            return Err(ConnectError::Certificate);
        }

        if !self.bridge_keyfile.as_ref().exists() {
            return Err(ConnectError::Certificate);
        }

        Ok(())
    }
}

#[cfg(test)]
mod test {

    use super::*;

    #[test]
    fn test_serialize_with_cafile_correctly() -> anyhow::Result<()> {
        let file = tempfile::NamedTempFile::new()?;
        let bridge_root_cert_path: FilePath = file.path().into();

        let bridge = BridgeConfig {
            cloud_name: "test".into(),
            config_file: "test-bridge.conf".into(),
            connection: "edge_to_test".into(),
            address: "test.test.io:8883".into(),
            remote_username: None,
            bridge_root_cert_path: bridge_root_cert_path.clone(),
            remote_clientid: "alpha".into(),
            local_clientid: "test".into(),
            bridge_certfile: "./test-certificate.pem".into(),
            bridge_keyfile: "./test-private-key.pem".into(),
            use_mapper: false,
            use_agent: false,
            topics: vec![],
            try_private: false,
            start_type: "automatic".into(),
            clean_session: true,
            notifications: false,
            notifications_local_only: false,
            notification_topic: "test_topic".into(),
            bridge_attempt_unsubscribe: false,
        };

        let mut serialized_config = Vec::<u8>::new();
        bridge.serialize(&mut serialized_config)?;

        let bridge_cafile = format!("bridge_cafile {}", bridge_root_cert_path);
        let mut expected = r#"### Bridge
connection edge_to_test
address test.test.io:8883
"#
        .to_owned();

        expected.push_str(&bridge_cafile);
        expected.push_str(
            r#"
remote_clientid alpha
local_clientid test
bridge_certfile ./test-certificate.pem
bridge_keyfile ./test-private-key.pem
try_private false
start_type automatic
cleansession true
notifications false
notifications_local_only false
notification_topic test_topic
bridge_attempt_unsubscribe false

### Topics
"#,
        );

        assert_eq!(serialized_config, expected.as_bytes());

        Ok(())
    }

    #[test]
    fn test_serialize_with_capath_correctly() -> anyhow::Result<()> {
        let dir = tempfile::TempDir::new()?;
        let bridge_root_cert_path: FilePath = dir.path().into();

        let bridge = BridgeConfig {
            cloud_name: "test".into(),
            config_file: "test-bridge.conf".into(),
            connection: "edge_to_test".into(),
            address: "test.test.io:8883".into(),
            remote_username: None,
            bridge_root_cert_path: bridge_root_cert_path.clone(),
            remote_clientid: "alpha".into(),
            local_clientid: "test".into(),
            bridge_certfile: "./test-certificate.pem".into(),
            bridge_keyfile: "./test-private-key.pem".into(),
            use_mapper: false,
            use_agent: false,
            topics: vec![],
            try_private: false,
            start_type: "automatic".into(),
            clean_session: true,
            notifications: false,
            notifications_local_only: false,
            notification_topic: "test_topic".into(),
            bridge_attempt_unsubscribe: false,
        };
        let mut serialized_config = Vec::<u8>::new();
        bridge.serialize(&mut serialized_config)?;

        let bridge_capath = format!("bridge_capath {}", bridge_root_cert_path);
        let mut expected = r#"### Bridge
connection edge_to_test
address test.test.io:8883
"#
        .to_owned();

        expected.push_str(&bridge_capath);
        expected.push_str(
            r#"
remote_clientid alpha
local_clientid test
bridge_certfile ./test-certificate.pem
bridge_keyfile ./test-private-key.pem
try_private false
start_type automatic
cleansession true
notifications false
notifications_local_only false
notification_topic test_topic
bridge_attempt_unsubscribe false

### Topics
"#,
        );

        assert_eq!(serialized_config, expected.as_bytes());

        Ok(())
    }

    #[test]
    fn test_serialize() -> anyhow::Result<()> {
        let file = tempfile::NamedTempFile::new()?;
        let bridge_root_cert_path: FilePath = file.path().into();

        let config = BridgeConfig {
            cloud_name: "az".into(),
            config_file: "az-bridge.conf".into(),
            connection: "edge_to_az".into(),
            address: "test.test.io:8883".into(),
            remote_username: Some("test.test.io/alpha/?api-version=2018-06-30".into()),
            bridge_root_cert_path: bridge_root_cert_path.clone(),
            remote_clientid: "alpha".into(),
            local_clientid: "Azure"