initial commit

Author: Jason Ozias

.gitignore

@@ -0,0 +1,3 @@
+/target
+**/*.rs.bk
+Cargo.lock

Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "libmussh"
+version = "0.1.0"
+authors = ["Jason Ozias <[email protected]>"]
+edition = "2018"
+
+[dependencies]
+clap = "2"
+crossbeam = "0"
+failure = "0"
+getset = "0"
+indexmap = "1"
+serde = "1"
+serde_derive = "1"
+toml = "0"

src/config.rs

@@ -0,0 +1,154 @@
+// Copyright (c) 2018 libmussh developers
+//
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT
+// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. All files in the project carrying such notice may not be copied,
+// modified, or distributed except according to those terms.
+
+use failure::{Error, Fallible};
+use getset::Getters;
+use serde_derive::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+use std::convert::TryFrom;
+use std::fs::File;
+use std::io::{BufReader, Read};
+use std::path::PathBuf;
+
+#[derive(Clone, Debug, Default, Deserialize, Eq, Getters, PartialEq, Serialize)]
+/// The base configuration.
+crate struct Mussh {
+    /// A list of hosts.
+    #[serde(serialize_with = "toml::ser::tables_last")]
+    #[get = "pub"]
+    hostlist: BTreeMap<String, Hosts>,
+    /// The hosts.
+    #[serde(serialize_with = "toml::ser::tables_last")]
+    #[get = "pub"]
+    hosts: BTreeMap<String, Host>,
+    /// A command.
+    #[serde(serialize_with = "toml::ser::tables_last")]
+    #[get = "pub"]
+    cmd: BTreeMap<String, Command>,
+}
+
+impl TryFrom<PathBuf> for Mussh {
+    type Error = Error;
+
+    fn try_from(path: PathBuf) -> Fallible<Self> {
+        let mut buf_reader = BufReader::new(File::open(path)?);
+        let mut buffer = String::new();
+        let _bytes_read = buf_reader.read_to_string(&mut buffer)?;
+        Ok(toml::from_str(&buffer)?)
+    }
+}
+
+#[derive(Clone, Debug, Default, Deserialize, Eq, Getters, PartialEq, Serialize)]
+/// hosts configuration
+crate struct Hosts {
+    /// The hostnames.
+    #[get = "pub"]
+    hostnames: Vec<String>,
+}
+
+#[derive(Clone, Debug, Default, Deserialize, Eq, Getters, PartialEq, Serialize)]
+/// Host configuration.
+crate struct Host {
+    /// A hostname.
+    #[get = "pub"]
+    hostname: String,
+    /// A pem key.
+    #[get = "pub"]
+    pem: Option<String>,
+    /// A port
+    #[get = "pub"]
+    port: Option<u16>,
+    /// A username.
+    #[get = "pub"]
+    username: String,
+    /// A command alias.
+    #[get = "pub"]
+    alias: Option<Vec<Alias>>,
+}
+
+#[derive(Clone, Debug, Default, Deserialize, Eq, Getters, PartialEq, Serialize)]
+/// command configuration
+crate struct Command {
+    /// A Command.
+    #[get = "pub"]
+    command: String,
+}
+
+#[derive(Clone, Debug, Default, Deserialize, Eq, Getters, PartialEq, Serialize)]
+/// command alias configuration.
+crate struct Alias {
+    /// A command alias.
+    #[get = "pub"]
+    command: String,
+    /// The command this is an alias for.
+    #[get = "pub"]
+    aliasfor: String,
+}
+
+#[cfg(test)]
+mod test {
+    use super::{Alias, Command};
+    use failure::Fallible;
+
+    const ALIAS: &str = r#"command = "blah"
+aliasfor = "dedah"
+"#;
+    const COMMAND: &str = r#"command = "blah"
+"#;
+    #[allow(dead_code)]
+    const HOST: &str = r#"hostname = "10.0.0.3"
+port = 22
+pem = "abcdef"
+username = "jozias"
+[[alias]]
+command = "blah"
+aliasfor = "dedah"
+"#;
+
+    #[test]
+    fn de_alias() -> Fallible<()> {
+        let expected = Alias {
+            command: "blah".to_string(),
+            aliasfor: "dedah".to_string(),
+        };
+        let actual: Alias = toml::from_str(ALIAS)?;
+        assert_eq!(expected, actual);
+        Ok(())
+    }
+
+    #[test]
+    fn ser_alias() -> Fallible<()> {
+        let expected = ALIAS;
+        let actual = toml::to_string(&Alias {
+            command: "blah".to_string(),
+            aliasfor: "dedah".to_string(),
+        })?;
+        assert_eq!(expected, actual);
+        Ok(())
+    }
+
+    #[test]
+    fn de_command() -> Fallible<()> {
+        let expected = Command {
+            command: "blah".to_string(),
+        };
+        let actual: Command = toml::from_str(COMMAND)?;
+        assert_eq!(expected, actual);
+        Ok(())
+    }
+
+    #[test]
+    fn ser_command() -> Fallible<()> {
+        let expected = COMMAND;
+        let actual = toml::to_string(&Command {
+            command: "blah".to_string(),
+        })?;
+        assert_eq!(expected, actual);
+        Ok(())
+    }
+}

src/lib.rs

@@ -0,0 +1,50 @@
+// Copyright (c) 2018 libmussh developers
+//
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT
+// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. All files in the project carrying such notice may not be copied,
+// modified, or distributed except according to those terms.
+
+//! libmussh
+#![feature(crate_visibility_modifier, try_from)]
+#![deny(
+    clippy::all,
+    clippy::pedantic,
+    macro_use_extern_crate,
+    missing_copy_implementations,
+    missing_debug_implementations,
+    missing_docs,
+    trivial_casts,
+    trivial_numeric_casts,
+    unused
+)]
+#![warn(
+    absolute_paths_not_starting_with_crate,
+    anonymous_parameters,
+    bare_trait_objects,
+    box_pointers,
+    elided_lifetimes_in_paths,
+    ellipsis_inclusive_range_patterns,
+    keyword_idents,
+    question_mark_macro_sep,
+    single_use_lifetimes,
+    unreachable_pub,
+    unsafe_code,
+    unused_extern_crates,
+    unused_import_braces,
+    unused_labels,
+    unused_lifetimes,
+    unused_qualifications,
+    unused_results,
+    variant_size_differences
+)]
+#![allow(clippy::stutter)]
+#![doc(html_root_url = "https://docs.rs/libmussh/0.1.0")]
+
+mod config;
+mod multiplex;
+mod utils;
+
+pub use self::multiplex::Multiplex;
+pub use self::utils::as_set;

src/multiplex.rs

@@ -0,0 +1,152 @@
+// Copyright (c) 2018 libmussh developers
+//
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT
+// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. All files in the project carrying such notice may not be copied,
+// modified, or distributed except according to those terms.
+
+//! Multiplex commands over hosts.
+use clap::ArgMatches;
+use crate::utils;
+use getset::{Getters, Setters};
+use indexmap::IndexSet;
+
+/// Multiplex struct
+#[derive(Clone, Debug, Default, Getters, Eq, PartialEq, Setters)]
+pub struct Multiplex {
+    /// Hosts
+    hosts: IndexSet<String>,
+    /// Host that need to complete `sync_commands` before run on
+    /// other hosts
+    sync_hosts: IndexSet<String>,
+    /// Commands
+    commands: IndexSet<String>,
+    ///s Commands that need to be run on `sync_hosts` before run
+    /// on other hosts
+    sync_commands: IndexSet<String>,
+}
+
+impl<'a> From<&'a ArgMatches<'a>> for Multiplex {
+    fn from(matches: &'a ArgMatches<'a>) -> Self {
+        let mut run = Self::default();
+        run.hosts = utils::as_set(
+            matches
+                .values_of("hosts")
+                .map_or_else(|| vec![], utils::map_vals),
+        );
+        run.sync_hosts = utils::as_set(
+            matches
+                .values_of("sync_hosts")
+                .map_or_else(|| vec![], utils::map_vals),
+        );
+        run.commands = utils::as_set(
+            matches
+                .values_of("commands")
+                .map_or_else(|| vec![], utils::map_vals),
+        );
+        run.sync_commands = utils::as_set(
+            matches
+                .values_of("sync_commands")
+                .map_or_else(|| vec![], utils::map_vals),
+        );
+        run
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Multiplex;
+    use clap::{App, Arg};
+    use crate::utils::as_set;
+    use failure::Fallible;
+
+    fn test_cli<'a, 'b>() -> App<'a, 'b> {
+        App::new(env!("CARGO_PKG_NAME"))
+            .arg(
+                Arg::with_name("hosts")
+                    .short("h")
+                    .long("hosts")
+                    .use_delimiter(true),
+            )
+            .arg(
+                Arg::with_name("commands")
+                    .short("c")
+                    .long("commands")
+                    .use_delimiter(true),
+            )
+            .arg(
+                Arg::with_name("sync_hosts")
+                    .short("s")
+                    .long("sync_hosts")
+                    .use_delimiter(true),
+            )
+            .arg(
+                Arg::with_name("sync_commands")
+                    .short("y")
+                    .long("sync_commands")
+                    .use_delimiter(true),
+            )
+    }
+
+    #[test]
+    fn hosts_from_cli() -> Fallible<()> {
+        let mut expected = Multiplex::default();
+        expected.hosts = as_set(
+            vec!["m1", "m2", "m3"]
+                .iter()
+                .map(|v| v.to_string())
+                .collect::<Vec<String>>(),
+        );
+        let cli = vec!["test", "-h", "m1,m2,m3,m1,m3"];
+        let matches = test_cli().get_matches_from_safe(cli)?;
+        assert_eq!(Multiplex::from(&matches), expected);
+        Ok(())
+    }
+
+    #[test]
+    fn sync_hosts_from_cli() -> Fallible<()> {
+        let mut expected = Multiplex::default();
+        expected.sync_hosts = as_set(
+            vec!["m1", "m2", "m3"]
+                .iter()
+                .map(|v| v.to_string())
+                .collect::<Vec<String>>(),
+        );
+        let cli = vec!["test", "-s", "m1,m2,m3,m1,m3"];
+        let matches = test_cli().get_matches_from_safe(cli)?;
+        assert_eq!(Multiplex::from(&matches), expected);
+        Ok(())
+    }
+
+    #[test]
+    fn commands_from_cli() -> Fallible<()> {
+        let mut expected = Multiplex::default();
+        expected.commands = as_set(
+            vec!["foo", "bar", "baz"]
+                .iter()
+                .map(|v| v.to_string())
+                .collect::<Vec<String>>(),
+        );
+        let cli = vec!["test", "-c", "foo,bar,foo,foo,baz,bar"];
+        let matches = test_cli().get_matches_from_safe(cli)?;
+        assert_eq!(Multiplex::from(&matches), expected);
+        Ok(())
+    }
+
+    #[test]
+    fn sync_commands_from_cli() -> Fallible<()> {
+        let mut expected = Multiplex::default();
+        expected.sync_commands = as_set(
+            vec!["foo", "bar", "baz"]
+                .iter()
+                .map(|v| v.to_string())
+                .collect::<Vec<String>>(),
+        );
+        let cli = vec!["test", "-y", "foo,bar,foo,foo,baz,bar"];
+        let matches = test_cli().get_matches_from_safe(cli)?;
+        assert_eq!(Multiplex::from(&matches), expected);
+        Ok(())
+    }
+
+}