Implement rupsc, clone of upsc (#5)

Fixes #4

rupsc/src/cmd.rs

@@ -0,0 +1,66 @@
+use crate::parser::UpsdName;
+use anyhow::Context;
+use core::convert::TryInto;
+use nut_client::blocking::Connection;
+
+/// Lists each UPS on the upsd server, one per line.
+pub fn list_devices(server: UpsdName, with_description: bool, debug: bool) -> anyhow::Result<()> {
+    let mut conn = connect(server, debug)?;
+
+    for (name, description) in conn.list_ups()? {
+        if with_description {
+            println!("{}: {}", name, description);
+        } else {
+            println!("{}", name);
+        }
+    }
+
+    Ok(())
+}
+
+pub fn print_variable(server: UpsdName, variable: &str, debug: bool) -> anyhow::Result<()> {
+    let ups_name = server
+        .upsname
+        .with_context(|| "ups name must be specified: <upsname>[@<hostname>[:<port>]]")?;
+    let mut conn = connect(server, debug)?;
+
+    let variable = conn.get_var(ups_name, variable)?;
+    println!("{}", variable.value());
+
+    Ok(())
+}
+
+pub fn list_variables(server: UpsdName, debug: bool) -> anyhow::Result<()> {
+    let ups_name = server
+        .upsname
+        .with_context(|| "ups name must be specified: <upsname>[@<hostname>[:<port>]]")?;
+    let mut conn = connect(server, debug)?;
+
+    for var in conn.list_vars(ups_name)? {
+        println!("{}", var);
+    }
+
+    Ok(())
+}
+
+pub fn list_clients(server: UpsdName, debug: bool) -> anyhow::Result<()> {
+    let ups_name = server
+        .upsname
+        .with_context(|| "ups name must be specified: <upsname>[@<hostname>[:<port>]]")?;
+    let mut conn = connect(server, debug)?;
+
+    for client_ip in conn.list_clients(ups_name)? {
+        println!("{}", client_ip);
+    }
+
+    Ok(())
+}
+
+fn connect(server: UpsdName, debug: bool) -> anyhow::Result<Connection> {
+    let host = server.try_into()?;
+    let config = nut_client::ConfigBuilder::new()
+        .with_host(host)
+        .with_debug(debug)
+        .build();
+    Connection::new(config).with_context(|| format!("Failed to connect to upsd: {}", server))
+}

rupsc/src/main.rs

@@ -0,0 +1,85 @@
+///! # rupsc
+///! A demo program to display UPS variables.
+///! This a Rust clone of [upsc](https://github.com/networkupstools/nut/blob/master/clients/upsc.c).
+///!
+///! P.S.: pronounced "r-oopsie".
+mod cmd;
+mod parser;
+
+use crate::parser::UpsdName;
+use anyhow::Context;
+use clap::{App, Arg};
+use core::convert::TryInto;
+
+fn main() -> anyhow::Result<()> {
+    let args = App::new(clap::crate_name!())
+        .version(clap::crate_version!())
+        .author(clap::crate_authors!())
+        .about(clap::crate_description!())
+        .arg(
+            Arg::with_name("list")
+                .short("l")
+                .conflicts_with_all(&["list-full", "clients"])
+                .takes_value(false)
+                .help("Lists each UPS on <hostname>, one per line."),
+        )
+        .arg(
+            Arg::with_name("list-full")
+                .short("L")
+                .conflicts_with_all(&["list", "clients"])
+                .takes_value(false)
+                .help("Lists each UPS followed by its description (from ups.conf)."),
+        )
+        .arg(
+            Arg::with_name("clients")
+                .short("c")
+                .conflicts_with_all(&["list", "list-full"])
+                .takes_value(false)
+                .help("Lists each client connected on <upsname>, one per line."),
+        )
+        .arg(
+            Arg::with_name("debug")
+                .short("D")
+                .takes_value(false)
+                .help("Enables debug mode (logs network commands to stderr)."),
+        )
+        .arg(
+            Arg::with_name("upsd-server")
+                .required(false)
+                .value_name("[upsname][@<hostname>[:<port>]]")
+                .help("upsd server (with optional upsname, if applicable)."),
+        )
+        .arg(
+            Arg::with_name("variable")
+                .required(false)
+                .value_name("variable")
+                .help("Optional, display this variable only."),
+        )
+        .get_matches();
+
+    let server: parser::UpsdName = args.value_of("upsd-server").map_or_else(
+        || Ok(UpsdName::default()),
+        |s| s.try_into().with_context(|| "Invalid upsd server name"),
+    )?;
+
+    let debug = args.is_present("debug");
+
+    if args.is_present("list") {
+        return cmd::list_devices(server, false, debug);
+    }
+
+    if args.is_present("list-full") {
+        return cmd::list_devices(server, true, debug);
+    }
+
+    if args.is_present("clients") {
+        return cmd::list_clients(server, debug);
+    }
+
+    // Fallback: prints one variable (or all of them)
+    if let Some(variable) = args.value_of("variable") {
+        cmd::print_variable(server, variable, debug)
+    } else {
+        cmd::list_variables(server, debug)
+    }
+}

rupsc/src/parser.rs

@@ -0,0 +1,150 @@
+use anyhow::Context;
+use std::convert::{TryFrom, TryInto};
+use std::fmt;
+use std::net::ToSocketAddrs;
+
+pub const DEFAULT_HOSTNAME: &str = "127.0.0.1";
+pub const DEFAULT_PORT: u16 = 3493;
+
+/// Connection information for a upsd server.
+///
+/// The upsname is optional depending on context.
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub struct UpsdName<'a> {
+    pub upsname: Option<&'a str>,
+    pub hostname: &'a str,
+    pub port: u16,
+}
+
+impl<'a> Default for UpsdName<'a> {
+    fn default() -> Self {
+        UpsdName {
+            upsname: None,
+            hostname: DEFAULT_HOSTNAME,
+            port: DEFAULT_PORT,
+        }
+    }
+}
+
+impl<'a> TryFrom<&'a str> for UpsdName<'a> {
+    type Error = anyhow::Error;
+
+    fn try_from(value: &'a str) -> anyhow::Result<UpsdName<'a>> {
+        let mut upsname: Option<&str> = None;
+        let mut hostname = DEFAULT_HOSTNAME;
+        let mut port = DEFAULT_PORT;
+
+        if value.contains(':') {
+            let mut split = value.splitn(2, ':');
+            let prefix = split.next().unwrap();
+            port = split
+                .next()
+                .unwrap()
+                .parse::<u16>()
+                .with_context(|| "invalid port number")?;
+            if prefix.contains('@') {
+                let mut split = prefix.splitn(2, '@');
+                upsname = Some(split.next().unwrap());
+                hostname = split.next().unwrap();
+            } else {
+                hostname = prefix;
+            }
+        } else if value.contains('@') {
+            let mut split = value.splitn(2, '@');
+            upsname = Some(split.next().unwrap());
+            hostname = split.next().unwrap();
+        } else {
+            upsname = Some(value);
+        }
+
+        Ok(UpsdName {
+            upsname,
+            hostname,
+            port,
+        })
+    }
+}
+
+impl<'a> TryInto<nut_client::Host> for UpsdName<'a> {
+    type Error = anyhow::Error;
+
+    fn try_into(self) -> anyhow::Result<nut_client::Host> {
+        Ok((String::from(self.hostname), self.port)
+            .to_socket_addrs()
+            .with_context(|| "Failed to convert to SocketAddr")?
+            .next()
+            .with_context(|| "Failed to convert to SocketAddr")?
+            .into())
+    }
+}
+
+impl<'a> fmt::Display for UpsdName<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(upsname) = self.upsname {
+            write!(f, "{}@", upsname)?;
+        }
+        write!(f, "{}:{}", self.hostname, self.port)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use core::convert::TryInto;
+
+    #[test]
+    fn test_upsdname_parser_full() {
+        let name: UpsdName = "ups@notlocal:1234".try_into().unwrap();
+        assert_eq!(
+            name,
+            UpsdName {
+                upsname: Some("ups"),
+                hostname: "notlocal",
+                port: 1234
+            }
+        );
+        assert_eq!(format!("{}", name), "ups@notlocal:1234");
+    }
+
+    #[test]
+    fn test_upsdname_parser_no_name() {
+        let name: UpsdName = "notlocal:5678".try_into().unwrap();
+        assert_eq!(
+            name,
+            UpsdName {
+                upsname: None,
+                hostname: "notlocal",
+                port: 5678
+            }
+        );
+        assert_eq!(format!("{}", name), "notlocal:5678");
+    }
+
+    #[test]
+    fn test_upsdname_parser_no_port_no_hostname() {
+        let name: UpsdName = "ups0".try_into().unwrap();
+        assert_eq!(
+            name,
+            UpsdName {
+                upsname: Some("ups0"),
+                hostname: DEFAULT_HOSTNAME,
+                port: DEFAULT_PORT
+            }
+        );
+        assert_eq!(format!("{}", name), "ups0@127.0.0.1:3493");
+    }
+
+    #[test]
+    fn test_upsdname_parser_no_port() {
+        let name: UpsdName = "ups@notlocal".try_into().unwrap();
+        assert_eq!(
+            name,
+            UpsdName {
+                upsname: Some("ups"),
+                hostname: "notlocal",
+                port: DEFAULT_PORT
+            }
+        );
+        assert_eq!(format!("{}", name), "ups@notlocal:3493");
+    }
+}