Untested Nix provider for Command

Author: petehayes102

core/src/command/mod.rs

@@ -8,83 +8,51 @@
 
 mod providers;
 
-pub use self::providers::Macos;
+pub use self::providers::Nix;
 
+use erased_serde::Serialize;
 use errors::*;
 use ExecutableProvider;
 use host::Host;
-use self::providers::MacosRemoteProvider;
-
-pub trait TelemetryProvider<'a> {
-    fn available(&Host) -> bool where Self: Sized;
-    fn try_new(&'a Host) -> Option<Self> where Self: Sized;
-    fn load(&self) -> Result<Telemetry>;
-}
+use self::providers::NixRemoteProvider;
 
 #[derive(Serialize, Deserialize)]
-pub enum RemoteProvider {
-    Macos(MacosRemoteProvider)
-}
-
-impl <'de>ExecutableProvider<'de> for RemoteProvider {
-    fn exec(&self, host: &Host) -> Result<()> {
-        match *self {
-            RemoteProvider::Macos(ref p) => p.exec(host)
-        }
-    }
+pub struct Command {
+    shell: String,
+    cmd: String,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
-pub struct Telemetry {
-    pub cpu: Cpu,
-    pub fs: Vec<FsMount>,
-    pub hostname: String,
-    pub memory: u64,
-    pub net: Vec<Netif>,
-    pub os: Os,
+pub struct CommandResult {
+    pub success: bool,
+    pub exit_code: Option<i32>,
+    pub stdout: Vec<u8>,
+    pub stderr: Vec<u8>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Cpu {
-    pub vendor: String,
-    pub brand_string: String,
-    pub cores: u32,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct FsMount {
-    pub filesystem: String,
-    pub mountpoint: String,
-    pub size: u64,
-    pub used: u64,
-    pub available: u64,
-    pub capacity: f32,
+pub trait CommandProvider<'a> {
+    fn available(&Host) -> bool where Self: Sized;
+    fn try_new<S: Into<String>>(&'a Host, S, Option<&str>) -> Option<Self> where Self: Sized;
+    fn exec(&self) -> Result<CommandResult>;
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Netif {
-    pub name: String,
-    pub index: u32,
-    pub mac: Option<String>,
-    pub ips: Option<Vec<String>>,
-    pub flags: u32,
+#[derive(Serialize, Deserialize)]
+pub enum RemoteProvider {
+    Nix(NixRemoteProvider)
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Os {
-    pub arch: String,
-    pub family: String,
-    pub platform: String,
-    pub version_str: String,
-    pub version_maj: u32,
-    pub version_min: u32,
-    pub version_patch: u32,
+impl <'de>ExecutableProvider<'de> for RemoteProvider {
+    fn exec(self, host: &Host) -> Result<Box<Serialize>> {
+        match self {
+            RemoteProvider::Nix(p) => p.exec(host)
+        }
+    }
 }
 
-pub fn factory<'a>(host: &'a Host) -> Result<Box<TelemetryProvider + 'a>> {
-    if let Some(p) = Macos::try_new(host) {
+pub fn factory<'a, S: Into<String>>(host: &'a Host, cmd: S, shell: Option<&str>) -> Result<Box<CommandProvider<'a> + 'a>> {
+    if let Some(p) = Nix::try_new(host, cmd, shell) {
         Ok(Box::new(p))
     } else {
-        Err(ErrorKind::ProviderUnavailable("Telemetry").into())
+        Err(ErrorKind::ProviderUnavailable("Command").into())
     }
 }

core/src/command/providers/macos.rs

@@ -4,6 +4,6 @@
 // https://www.tldrlegal.com/l/mpl-2.0>. This file may not be copied,
 // modified, or distributed except according to those terms.
 
-mod macos;
+mod nix;
 
-pub use self::macos::{Macos, RemoteProvider as MacosRemoteProvider};
+pub use self::nix::{Nix, RemoteProvider as NixRemoteProvider};

core/src/command/providers/mod.rs

@@ -0,0 +1,81 @@
+// Copyright 2015-2017 Intecture Developers.
+//
+// Licensed under the Mozilla Public License 2.0 <LICENSE or
+// https://www.tldrlegal.com/l/mpl-2.0>. This file may not be copied,
+// modified, or distributed except according to those terms.
+
+use command::{Command, CommandProvider, CommandResult};
+use erased_serde::Serialize;
+use errors::*;
+use ExecutableProvider;
+use host::*;
+use std::process;
+
+pub struct Nix<'a> {
+    host: &'a Host,
+    inner: Command
+}
+
+#[derive(Serialize, Deserialize)]
+pub enum RemoteProvider {
+    Available,
+    Exec(Command),
+}
+
+impl <'de>ExecutableProvider<'de> for RemoteProvider {
+    fn exec(self, host: &Host) -> Result<Box<Serialize>> {
+        match self {
+            RemoteProvider::Available => Ok(Box::new(Nix::available(host))),
+            RemoteProvider::Exec(inner) => {
+                let p = Nix { host, inner };
+                Ok(Box::new(p.exec()?))
+            }
+        }
+    }
+}
+
+impl <'a>CommandProvider<'a> for Nix<'a> {
+    fn available(host: &Host) -> bool {
+        if host.is_local() {
+            cfg!(not(windows))
+        } else {
+            unimplemented!();
+            // let r = RemoteProvider::Available;
+            // self.host.send(r).chain_err(|| ErrorKind::RemoteProvider("Command", "available"))?;
+            // Ok(self.host.recv()?)
+        }
+    }
+
+    fn try_new<S: Into<String>>(host: &'a Host, cmd: S, shell: Option<&str>) -> Option<Nix<'a>> {
+        if Self::available(host) {
+            let inner = Command {
+                shell: shell.unwrap_or("/bin/sh").into(),
+                cmd: cmd.into(),
+            };
+            Some(Nix { host, inner })
+        } else {
+            None
+        }
+    }
+
+    fn exec(&self) -> Result<CommandResult> {
+        if self.host.is_local() {
+            let out = process::Command::new(&self.inner.shell)
+                                       .arg(&self.inner.cmd)
+                                       .output()
+                                       .chain_err(|| "Command execution failed")?;
+            Ok(CommandResult {
+                success: out.status.success(),
+                exit_code: out.status.code(),
+                stdout: out.stdout,
+                stderr: out.stderr
+            })
+        } else {
+            unimplemented!();
+            // let r = RemoteProvider::Load;
+            // self.host.send(r).chain_err(|| ErrorKind::RemoteProvider("Command", "exec"))?;
+            // let result: CommandResult = self.host.recv()?;
+            // Ok(result)
+        }
+    }
+}

core/src/command/providers/nix.rs

@@ -21,6 +21,7 @@ extern crate serde;
 #[macro_use] extern crate serde_derive;
 extern crate serde_json;
 
+pub mod command;
 pub mod errors;
 pub mod host;
 mod target;
@@ -37,13 +38,15 @@ pub trait ExecutableProvider<'de>: serde::Serialize + serde::Deserialize<'de> {
 
 #[derive(Serialize, Deserialize)]
 pub enum RemoteProvider {
-    Telemetry(telemetry::RemoteProvider)
+    Command(command::RemoteProvider),
+    Telemetry(telemetry::RemoteProvider),
 }
 
 impl <'de>ExecutableProvider<'de> for RemoteProvider {
     fn exec(self, host: &host::Host) -> Result<Box<Serialize>> {
         match self {
-            RemoteProvider::Telemetry(p) => p.exec(host)
+            RemoteProvider::Command(p) => p.exec(host),
+            RemoteProvider::Telemetry(p) => p.exec(host),
         }
     }
 }