Restructure providers to abstract provider logic from endpoints. Hamstrung by lack of specialisation in Rust :#

Author: petehayes102

agent/src/main.rs

@@ -19,15 +19,18 @@ mod errors;
 
 use errors::*;
 use futures::{future, Future};
-use intecture_api::{Executable, Runnable};
+use intecture_api::remote::{Executable, Runnable};
+use intecture_api::host::local::Local;
 use intecture_api::host::remote::JsonProto;
 use std::fs::File;
 use std::io::{self, Read};
 use std::net::SocketAddr;
 use tokio_proto::TcpServer;
 use tokio_service::Service;
 
-pub struct Api;
+pub struct Api {
+    host: Local,
+}
 
 impl Service for Api {
     type Request = serde_json::Value;
@@ -46,7 +49,7 @@ impl Service for Api {
                         io::ErrorKind::Other, e.description()
                     ))),
         };
-        Box::new(runnable.exec()
+        Box::new(runnable.exec(&self.host)
             // @todo Can't wrap 'e' as error_chain Error doesn't derive Sync.
             // Waiting for https://github.com/rust-lang-nursery/error-chain/pull/163
             .map_err(|e| io::Error::new(io::ErrorKind::Other, e.description()))
@@ -96,7 +99,8 @@ quick_main!(|| -> Result<()> {
         Config { address }
     };
 
+    let host = Local::new().wait()?;
     let server = TcpServer::new(JsonProto, config.address);
-    server.serve(|| Ok(Api));
+    server.serve(move || Ok(Api { host: host.clone() }));
     Ok(())
 });

core/src/command/mod.rs

@@ -8,29 +8,18 @@
 
 pub mod providers;
 
-use erased_serde::Serialize;
 use errors::*;
-use Executable;
 use futures::{future, Future};
 use host::Host;
-use self::providers::{Nix, NixRunnable};
-use std::sync::Arc;
+use self::providers::CommandProvider;
 
-pub trait CommandProvider<H: Host> {
-    fn available(&Arc<H>) -> Box<Future<Item = bool, Error = Error>> where Self: Sized;
-    fn try_new(&Arc<H>, &str, Option<&[&str]>) -> Box<Future<Item = Option<Self>, Error = Error>> where Self: Sized;
-    fn exec(&mut self) -> Box<Future<Item = CommandResult, Error = Error>>;
-}
-
-#[doc(hidden)]
-#[derive(Serialize, Deserialize)]
-pub enum CommandRunnable {
-    Nix(NixRunnable)
-}
+#[cfg(not(windows))]
+const DEFAULT_SHELL: [&'static str; 2] = ["/bin/sh", "-c"];
+#[cfg(windows)]
+const DEFAULT_SHELL: [&'static str; 1] = ["yeah...we don't currently support windows :("];
 
-#[doc(hidden)]
-#[derive(Clone, Serialize, Deserialize)]
-pub struct Command {
+pub struct Command<H: Host> {
+    inner: Box<CommandProvider<H>>,
     shell: Vec<String>,
     cmd: String,
 }
@@ -43,18 +32,38 @@ pub struct CommandResult {
     pub stderr: Vec<u8>,
 }
 
-impl Executable for CommandRunnable {
-    fn exec(self) -> Box<Future<Item = Box<Serialize>, Error = Error>> {
-        match self {
-            CommandRunnable::Nix(p) => p.exec()
+impl<H: Host + 'static> Command<H> {
+    pub fn new(host: &H, cmd: &str, shell: Option<&[&str]>) -> Box<Future<Item = Command<H>, Error = Error>> {
+        let cmd_owned = cmd.to_owned();
+        let shell_owned: Vec<String> = shell.unwrap_or(&DEFAULT_SHELL)
+            .to_owned()
+            .iter()
+            .map(|s| s.to_string())
+            .collect();
+
+        Box::new(host.command_provider()
+            .and_then(|provider| future::ok(Command {
+                inner: provider,
+                shell: shell_owned,
+                cmd: cmd_owned,
+            })))
+    }
+
+    pub fn with_provider<P>(provider: P, cmd: &str, shell: Option<&[&str]>) -> Command<H>
+        where P: CommandProvider<H> + 'static
+    {
+        Command {
+            inner: Box::new(provider),
+            shell: shell.unwrap_or(&DEFAULT_SHELL)
+                        .to_owned()
+                        .iter()
+                        .map(|s| s.to_string())
+                        .collect(),
+            cmd: cmd.into(),
         }
     }
-}
 
-pub fn factory<H: Host + 'static>(host: &Arc<H>, cmd: &str, shell: Option<&[&str]>) -> Box<Future<Item = Box<CommandProvider<H>>, Error = Error>> {
-    Box::new(Nix::try_new(host, cmd, shell)
-                     .and_then(|opt| match opt {
-                         Some(provider) => future::ok(Box::new(provider) as Box<CommandProvider<H>>),
-                         None => future::err(ErrorKind::ProviderUnavailable("Command").into())
-                     }))
+    pub fn exec(&mut self) -> Box<Future<Item = CommandResult, Error = Error>> {
+        self.inner.exec(&self.cmd, &self.shell)
+    }
 }

core/src/command/providers/generic.rs

@@ -0,0 +1,122 @@
+// 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::CommandResult;
+use erased_serde::Serialize;
+use errors::*;
+use futures::{future, Future};
+use host::{Host, HostType};
+use host::local::Local;
+use host::remote::Plain;
+use provider::Provider;
+use remote::{Executable, Runnable};
+use std::process;
+use super::{CommandProvider, CommandRunnable};
+
+#[derive(Clone)]
+pub struct Generic<H: Host> {
+    host: H
+}
+
+struct LocalGeneric;
+struct RemoteGeneric;
+
+#[doc(hidden)]
+#[derive(Serialize, Deserialize)]
+pub enum GenericRunnable {
+    Available,
+    Exec(String, Vec<String>),
+}
+
+impl<H: Host + 'static> Provider<H> for Generic<H> {
+    fn available(host: &H) -> Box<Future<Item = bool, Error = Error>> {
+        match host.get_type() {
+            HostType::Local(l) => LocalGeneric::available(l),
+            HostType::Remote(r) => RemoteGeneric::available(r),
+        }
+    }
+
+    fn try_new(host: &H) -> Box<Future<Item = Option<Generic<H>>, Error = Error>> {
+        let host = host.clone();
+        Box::new(Self::available(&host)
+            .and_then(|available| {
+                if available {
+                    future::ok(Some(Generic { host }))
+                } else {
+                    future::ok(None)
+                }
+            }))
+    }
+}
+
+impl<H: Host + 'static> CommandProvider<H> for Generic<H> {
+    fn exec(&mut self, cmd: &str, shell: &[String]) -> Box<Future<Item = CommandResult, Error = Error>> {
+        match self.host.get_type() {
+            HostType::Local(l) => LocalGeneric::exec(l, cmd, shell),
+            HostType::Remote(r) => RemoteGeneric::exec(r, cmd, shell),
+        }
+    }
+}
+
+impl LocalGeneric {
+    fn available(_: &Local) -> Box<Future<Item = bool, Error = Error>> {
+        Box::new(future::ok(cfg!(unix)))
+    }
+
+    fn exec(_: &Local, cmd: &str, shell: &[String]) -> Box<Future<Item = CommandResult, Error = Error>> {
+        let cmd_owned = cmd.to_owned();
+        let shell_owned = shell.to_owned();
+
+        Box::new(future::lazy(move || -> future::FutureResult<CommandResult, Error> {
+            let (shell, shell_args) = match shell_owned.split_first() {
+                Some((s, a)) => (s, a),
+                None => return future::err("Invalid shell provided".into()),
+            };
+
+            let out = process::Command::new(shell)
+                                       .args(shell_args)
+                                       .arg(&cmd_owned)
+                                       .output()
+                                       .chain_err(|| "Command execution failed");
+            match out {
+                Ok(output) => future::ok(CommandResult {
+                    success: output.status.success(),
+                    exit_code: output.status.code(),
+                    stdout: output.stdout,
+                    stderr: output.stderr,
+                }),
+                Err(e) => future::err(e),
+            }
+        }))
+    }
+}
+
+impl RemoteGeneric {
+    fn available(host: &Plain) -> Box<Future<Item = bool, Error = Error>> {
+        let runnable = Runnable::Command(
+                          CommandRunnable::Generic(
+                              GenericRunnable::Available));
+        host.run(runnable)
+            .chain_err(|| ErrorKind::Runnable { endpoint: "Command::Generic", func: "available" })
+    }
+
+    fn exec(host: &Plain, cmd: &str, shell: &[String]) -> Box<Future<Item = CommandResult, Error = Error>> {
+        let runnable = Runnable::Command(
+                          CommandRunnable::Generic(
+                              GenericRunnable::Exec(cmd.into(), shell.to_owned())));
+        host.run(runnable)
+            .chain_err(|| ErrorKind::Runnable { endpoint: "Command::Generic", func: "exec" })
+    }
+}
+
+impl Executable for GenericRunnable {
+    fn exec(self, host: &Local) -> Box<Future<Item = Box<Serialize>, Error = Error>> {
+        match self {
+            GenericRunnable::Available => Box::new(LocalGeneric::available(host).map(|b| Box::new(b) as Box<Serialize>)),
+            GenericRunnable::Exec(cmd, shell) => Box::new(LocalGeneric::exec(host, &cmd, &shell).map(|r| Box::new(r) as Box<Serialize>)),
+        }
+    }
+}

core/src/command/providers/mod.rs

@@ -4,6 +4,40 @@
 // https://www.tldrlegal.com/l/mpl-2.0>. This file may not be copied,
 // modified, or distributed except according to those terms.
 
-mod nix;
+mod generic;
 
-pub use self::nix::{Nix, NixRunnable};
+use errors::*;
+use erased_serde::Serialize;
+use futures::{future, Future};
+use host::Host;
+use host::local::Local;
+use provider::Provider;
+use remote::Executable;
+pub use self::generic::{Generic, GenericRunnable};
+use super::CommandResult;
+
+pub trait CommandProvider<H: Host>: Provider<H> {
+    fn exec(&mut self, &str, &[String]) -> Box<Future<Item = CommandResult, Error = Error>>;
+}
+
+#[doc(hidden)]
+#[derive(Serialize, Deserialize)]
+pub enum CommandRunnable {
+    Generic(GenericRunnable)
+}
+
+impl Executable for CommandRunnable {
+    fn exec(self, host: &Local) -> Box<Future<Item = Box<Serialize>, Error = Error>> {
+        match self {
+            CommandRunnable::Generic(p) => p.exec(host)
+        }
+    }
+}
+
+pub fn factory<H: Host + 'static>(host: &H) -> Box<Future<Item = Box<CommandProvider<H>>, Error = Error>> {
+    Box::new(Generic::try_new(host)
+        .and_then(|opt| match opt {
+            Some(provider) => future::ok(Box::new(provider) as Box<CommandProvider<H>>),
+            None => future::err(ErrorKind::ProviderUnavailable("Command").into())
+        }))
+}