Add Response remote type, rename Runnable to Request

Author: petehayes102

core/src/command/providers/generic.rs

@@ -5,31 +5,25 @@
 // 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 remote::{CommandRequest, CommandResponse, Executable, ExecutableResult,
+             GenericRequest, Request, Response, ResponseResult};
 use std::process;
-use super::{CommandProvider, CommandRunnable};
+use super::CommandProvider;
 use tokio_core::reactor::Handle;
 use tokio_process::CommandExt;
+use tokio_proto::streaming::Message;
 
 #[derive(Clone)]
 pub struct Generic;
 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 {
     fn available(host: &H) -> Box<Future<Item = bool, Error = Error>> {
         match host.get_type() {
@@ -91,27 +85,38 @@ impl LocalGeneric {
 
 impl RemoteGeneric {
     fn available(host: &Plain) -> Box<Future<Item = bool, Error = Error>> {
-        let runnable = Runnable::Command(
-                          CommandRunnable::Generic(
-                              GenericRunnable::Available));
+        let runnable = Request::Command(
+                          CommandRequest::Generic(
+                              GenericRequest::Available));
         host.run(runnable)
-            .chain_err(|| ErrorKind::Runnable { endpoint: "Command::Generic", func: "available" })
+            .chain_err(|| ErrorKind::Request { 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())));
+        let runnable = Request::Command(
+                          CommandRequest::Generic(
+                              GenericRequest::Exec(cmd.into(), shell.to_owned())));
         host.run(runnable)
-            .chain_err(|| ErrorKind::Runnable { endpoint: "Command::Generic", func: "exec" })
+            .chain_err(|| ErrorKind::Request { endpoint: "Command::Generic", func: "exec" })
     }
 }
 
-impl Executable for GenericRunnable {
-    fn exec(self, _: &Local, handle: &Handle) -> Box<Future<Item = Box<Serialize>, Error = Error>> {
+impl Executable for GenericRequest {
+    fn exec(self, _: &Local, handle: &Handle) -> ExecutableResult {
         match self {
-            GenericRunnable::Available => Box::new(LocalGeneric::available().map(|b| Box::new(b) as Box<Serialize>)),
-            GenericRunnable::Exec(cmd, shell) => Box::new(LocalGeneric::exec(handle, &cmd, &shell).map(|r| Box::new(r) as Box<Serialize>)),
+            GenericRequest::Available => Box::new(
+                LocalGeneric::available()
+                    .map(|b| Message::WithoutBody(
+                        ResponseResult::Ok(
+                            Response::Command(
+                                CommandResponse::Available(b)))))),
+            GenericRequest::Exec(cmd, shell) => Box::new(
+                LocalGeneric::exec(handle, &cmd, &shell)
+                    .map(|t| Message::WithoutBody(
+                        ResponseResult::Ok(
+                            Response::Command(
+                                CommandResponse::Exec(t.into()))))
+                ))
         }
     }
 }

core/src/command/providers/mod.rs

@@ -7,34 +7,17 @@
 mod generic;
 
 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};
+pub use self::generic::Generic;
 use super::CommandResult;
 use tokio_core::reactor::Handle;
 
 pub trait CommandProvider<H: Host>: Provider<H> {
     fn exec(&self, &H, &Handle, &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, handle: &Handle) -> Box<Future<Item = Box<Serialize>, Error = Error>> {
-        match self {
-            CommandRunnable::Generic(p) => p.exec(host, handle)
-        }
-    }
-}
-
 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 {

core/src/errors.rs

@@ -26,7 +26,7 @@ error_chain! {
             display("No providers available for {}", p),
         }
 
-        Runnable {
+        Request {
             endpoint: &'static str,
             func: &'static str,
         } {

core/src/host/remote.rs

@@ -7,7 +7,7 @@
 use bytes::BytesMut;
 use errors::*;
 use futures::{future, Future};
-use remote::Runnable;
+use remote::Request;
 use serde::Deserialize;
 use serde_json;
 use std::{io, result};
@@ -81,15 +81,15 @@ impl Plain {
     }
 
     #[doc(hidden)]
-    pub fn run<D: 'static>(&self, provider: Runnable) -> Box<Future<Item = D, Error = Error>>
+    pub fn run<D: 'static>(&self, provider: Request) -> Box<Future<Item = D, Error = Error>>
         where for<'de> D: Deserialize<'de>
     {
         Box::new(self.run_msg::<D>(provider)
             .map(|msg| msg.into_inner()))
     }
 
     #[doc(hidden)]
-    pub fn run_msg<D: 'static>(&self, provider: Runnable) -> Box<Future<Item = Message<D, Body<Vec<u8>, io::Error>>, Error = Error>>
+    pub fn run_msg<D: 'static>(&self, provider: Request) -> Box<Future<Item = Message<D, Body<Vec<u8>, io::Error>>, Error = Error>>
         where for<'de> D: Deserialize<'de>
     {
         let value = match serde_json::to_value(provider).chain_err(|| "Could not encode provider to send to host") {

core/src/remote.rs

@@ -4,29 +4,151 @@
 // https://www.tldrlegal.com/l/mpl-2.0>. This file may not be copied,
 // modified, or distributed except according to those terms.
 
-use command::providers::CommandRunnable;
-use erased_serde::Serialize;
+// Hopefully in the near future this will be auto-generated from `derive` attributes.
+
+use command::CommandResult;
 use errors::*;
 use futures::Future;
 use host::local::Local;
-use telemetry::providers::TelemetryRunnable;
+use telemetry::serializable::Telemetry;
 use tokio_core::reactor::Handle;
+use tokio_proto::streaming::{Body, Message};
+
+pub type ExecutableResult = Box<Future<Item = Message<ResponseResult, Body<Vec<u8>, Error>>, Error = Error>>;
 
 pub trait Executable {
-    fn exec(self, &Local, &Handle) -> Box<Future<Item = Box<Serialize>, Error = Error>>;
+    fn exec(self, &Local, &Handle) -> ExecutableResult;
+}
+
+#[derive(Serialize, Deserialize)]
+pub enum Request {
+    Command(CommandRequest),
+    Telemetry(TelemetryRequest),
+}
+
+#[derive(Serialize, Deserialize)]
+pub enum Response {
+    Command(CommandResponse),
+    Telemetry(TelemetryResponse),
+}
+
+#[derive(Serialize, Deserialize)]
+pub enum ResponseResult {
+    Ok(Response),
+    Err(String),
+}
+
+impl Executable for Request {
+    fn exec(self, host: &Local, handle: &Handle) -> ExecutableResult {
+        match self {
+            Request::Command(p) => p.exec(host, handle),
+            Request::Telemetry(p) => p.exec(host, handle),
+        }
+    }
+}
+
+//
+// Command
+//
+
+#[derive(Serialize, Deserialize)]
+pub enum CommandRequest {
+    Generic(GenericRequest),
+}
+
+#[derive(Serialize, Deserialize)]
+pub enum GenericRequest {
+    Available,
+    Exec(String, Vec<String>),
+}
+
+#[derive(Serialize, Deserialize)]
+pub enum CommandResponse {
+    Available(bool),
+    Exec(CommandResult),
+}
+
+impl Executable for CommandRequest {
+    fn exec(self, host: &Local, handle: &Handle) -> ExecutableResult {
+        match self {
+            CommandRequest::Generic(p) => p.exec(host, handle)
+        }
+    }
+}
+
+//
+// Telemetry
+//
+
+#[derive(Serialize, Deserialize)]
+pub enum TelemetryRequest {
+    Centos(CentosRequest),
+    Debian(DebianRequest),
+    Fedora(FedoraRequest),
+    Freebsd(FreebsdRequest),
+    Macos(MacosRequest),
+    Nixos(NixosRequest),
+    Ubuntu(UbuntuRequest),
+}
+
+#[derive(Serialize, Deserialize)]
+pub enum CentosRequest {
+    Available,
+    Load,
+}
+
+#[derive(Serialize, Deserialize)]
+pub enum DebianRequest {
+    Available,
+    Load,
+}
+
+#[derive(Serialize, Deserialize)]
+pub enum FedoraRequest {
+    Available,
+    Load,
+}
+
+#[derive(Serialize, Deserialize)]
+pub enum FreebsdRequest {
+    Available,
+    Load,
+}
+
+#[derive(Serialize, Deserialize)]
+pub enum MacosRequest {
+    Available,
+    Load,
+}
+
+#[derive(Serialize, Deserialize)]
+pub enum NixosRequest {
+    Available,
+    Load,
+}
+
+#[derive(Serialize, Deserialize)]
+pub enum UbuntuRequest {
+    Available,
+    Load,
 }
 
 #[derive(Serialize, Deserialize)]
-pub enum Runnable {
-    Command(CommandRunnable),
-    Telemetry(TelemetryRunnable),
+pub enum TelemetryResponse {
+    Available(bool),
+    Load(Telemetry),
 }
 
-impl Executable for Runnable {
-    fn exec(self, host: &Local, handle: &Handle) -> Box<Future<Item = Box<Serialize>, Error = Error>> {
+impl Executable for TelemetryRequest {
+    fn exec(self, host: &Local, handle: &Handle) -> ExecutableResult {
         match self {
-            Runnable::Command(p) => p.exec(host, handle),
-            Runnable::Telemetry(p) => p.exec(host, handle),
+            TelemetryRequest::Centos(p) => p.exec(host, handle),
+            TelemetryRequest::Debian(p) => p.exec(host, handle),
+            TelemetryRequest::Fedora(p) => p.exec(host, handle),
+            TelemetryRequest::Freebsd(p) => p.exec(host, handle),
+            TelemetryRequest::Macos(p) => p.exec(host, handle),
+            TelemetryRequest::Nixos(p) => p.exec(host, handle),
+            TelemetryRequest::Ubuntu(p) => p.exec(host, handle),
         }
     }
 }

core/src/telemetry/mod.rs

@@ -7,7 +7,8 @@
 //! System generated data about your host.
 
 pub mod providers;
-mod serializable;
+#[doc(hidden)]
+pub mod serializable;
 
 use pnet::datalink::NetworkInterface;