Merge pull request #2430 from input-output-hk/cut-unneeded-bytes-futu…

…res-tokio-deps

Cut unneeded uses of bytes and the old futures 0.1/ tokio 0.2 stack

jcli/Cargo.toml

@@ -22,7 +22,6 @@ bincode = "1.0.1"
 mime = "^0.3.7"
 structopt = "^0.3"
 bech32 = "0.7"
-bytes = "0.4"
 hex = "0.4.2"
 chain-core      = { path = "../chain-deps/chain-core" }
 chain-impl-mockchain = { path = "../chain-deps/chain-impl-mockchain" }

jcli/src/jcli_app/rest/v0/message/mod.rs

@@ -6,8 +6,6 @@ use chain_core::property::Deserialize;
 use chain_impl_mockchain::fragment::Fragment;
 use std::path::PathBuf;
 use structopt::StructOpt;
-extern crate bytes;
-use self::bytes::IntoBuf;
 
 #[derive(StructOpt)]
 #[structopt(rename_all = "kebab-case")]
@@ -64,8 +62,8 @@ fn get_logs(addr: HostAddr, debug: DebugFlag, output_format: OutputFormat) -> Re
 fn post_message(file: Option<PathBuf>, addr: HostAddr, debug: DebugFlag) -> Result<(), Error> {
     let msg_hex = io::read_line(&file)?;
     let msg_bin = hex::decode(&msg_hex)?;
-    let _fragment = Fragment::deserialize(msg_bin.as_slice().into_buf())
-        .map_err(Error::InputFragmentMalformed)?;
+    let _fragment =
+        Fragment::deserialize(msg_bin.as_slice()).map_err(Error::InputFragmentMalformed)?;
     let url = addr.with_segments(&["v0", "message"])?.into_url();
     let builder = reqwest::blocking::Client::new().post(url);
     let response = RestApiSender::new(builder, &debug)

testing/jormungandr-integration-tests/Cargo.toml

@@ -10,7 +10,6 @@ prost = "0.6"
 tokio = { version = "0.2", features = ["macros"] }
 futures      = "0.3.5"
 base64 = "0.12"
-bytes = "0.4"
 hex = "0.4.2"
 chain-addr      = { path = "../../chain-deps/chain-addr" }
 chain-core      = { path = "../../chain-deps/chain-core" }

testing/jormungandr-scenario-tests/Cargo.toml

@@ -8,12 +8,9 @@ edition = "2018"
 
 [dependencies]
 slog = "2"
-bawawa = "0.1.5"
-bytes = "0.4"
 custom_debug = "0.5"
 dialoguer = "0.6.2"
 error-chain = "0.12"
-tokio = "0.1"
 assert_fs = "1.0"
 chain-core           = { path = "../../chain-deps/chain-core" }
 chain-crypto         = { path = "../../chain-deps/chain-crypto", features = [ "property-test-api" ] }

testing/jormungandr-scenario-tests/src/legacy/node.rs

@@ -28,15 +28,15 @@ pub use jormungandr_testing_utils::testing::{
     FragmentNode, FragmentNodeError, MemPoolCheck,
 };
 
-use bawawa::{Control, Process};
 use futures::executor::block_on;
 use indicatif::ProgressBar;
 use rand_core::RngCore;
-use tokio::prelude::*;
 use yaml_rust::{Yaml, YamlLoader};
 
 use std::collections::HashMap;
+use std::io::{BufRead, BufReader};
 use std::path::{Path, PathBuf};
+use std::process::{Child, Command, Stdio};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
@@ -56,7 +56,7 @@ pub struct LegacyNode {
     #[allow(unused)]
     dir: PathBuf,
 
-    process: Process,
+    process: Child,
 
     progress_bar: ProgressBarController,
     node_settings: LegacySettings,
@@ -537,7 +537,7 @@ impl LegacyNode {
     }
 
     pub fn spawn<R: RngCore>(
-        jormungandr: &bawawa::Command,
+        jormungandr: &Path,
         context: &Context<R>,
         progress_bar: ProgressBar,
         alias: &str,
@@ -546,7 +546,7 @@ impl LegacyNode {
         working_dir: &Path,
         peristence_mode: PersistenceMode,
     ) -> Result<Self> {
-        let mut command = jormungandr.clone();
+        let mut command = Command::new(jormungandr);
         let dir = working_dir.join(alias);
         std::fs::DirBuilder::new().recursive(true).create(&dir)?;
 
@@ -604,23 +604,24 @@ impl LegacyNode {
             cause: e,
         })?;
 
-        command.arguments(&["--config", &config_file.display().to_string()]);
+        command.arg("--config");
+        command.arg(&config_file);
 
         match block0 {
             NodeBlock0::File(path) => {
-                command.arguments(&[
-                    "--genesis-block",
-                    &path.display().to_string(),
-                    "--secret",
-                    &config_secret.display().to_string(),
-                ]);
+                command.arg("--genesis-block");
+                command.arg(&path);
+                command.arg("--secret");
+                command.arg(&config_secret);
             }
             NodeBlock0::Hash(hash) => {
-                command.arguments(&["--genesis-block-hash", &hash.to_string()]);
+                command.args(&["--genesis-block-hash", &hash.to_string()]);
             }
         }
 
-        let process = Process::spawn(command).map_err(Error::CannotSpawnNode)?;
+        command.stderr(Stdio::piped());
+
+        let process = command.spawn().map_err(Error::CannotSpawnNode)?;
 
         let node = LegacyNode {
             alias: alias.into(),
@@ -639,16 +640,32 @@ impl LegacyNode {
         Ok(node)
     }
 
-    pub fn capture_logs(&mut self) -> impl Future<Item = (), Error = ()> {
-        let stderr = self.process.stderr().take().unwrap();
-
-        let stderr = tokio::codec::FramedRead::new(stderr, tokio::codec::LinesCodec::new());
-
-        let progress_bar = self.progress_bar.clone();
+    pub fn capture_logs(&mut self) {
+        let stderr = self.process.stderr.take().unwrap();
+        let reader = BufReader::new(stderr);
+        for line_result in reader.lines() {
+            let line = line_result.expect("failed to read a line from log output");
+            self.progress_bar.log_info(&line);
+        }
+    }
 
-        stderr
-            .for_each(move |line| future::ok(progress_bar.log_info(&line)))
-            .map_err(|err| unimplemented!("{}", err))
+    pub fn wait(&mut self) {
+        match self.process.wait() {
+            Err(err) => {
+                self.progress_bar.log_err(&err);
+                self.progress_bar_failure();
+                self.set_status(Status::Failure);
+            }
+            Ok(status) => {
+                if status.success() {
+                    self.progress_bar_success();
+                } else {
+                    self.progress_bar.log_err(&status);
+                    self.progress_bar_failure()
+                }
+                self.set_status(Status::Exit(status));
+            }
+        }
     }
 
     fn progress_bar_start(&self) {
@@ -688,44 +705,3 @@ impl LegacyNode {
         *self.status.lock().unwrap() = status
     }
 }
-
-impl Future for LegacyNode {
-    type Item = ();
-    type Error = ();
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        match self.process.poll() {
-            Err(err) => {
-                self.progress_bar.log_err(&err);
-                self.progress_bar_failure();
-                self.set_status(Status::Failure);
-                Err(())
-            }
-            Ok(Async::NotReady) => Ok(Async::NotReady),
-            Ok(Async::Ready(status)) => {
-                if status.success() {
-                    self.progress_bar_success();
-                } else {
-                    self.progress_bar.log_err(&status);
-                    self.progress_bar_failure()
-                }
-                self.set_status(Status::Exit(status));
-                Ok(Async::Ready(()))
-            }
-        }
-    }
-}
-
-impl Control for LegacyNode {
-    fn command(&self) -> &bawawa::Command {
-        &self.process.command()
-    }
-
-    fn id(&self) -> u32 {
-        self.process.id()
-    }
-
-    fn kill(&mut self) -> bawawa::Result<()> {
-        self.process.kill()
-    }
-}

testing/jormungandr-scenario-tests/src/main.rs

@@ -93,8 +93,8 @@ fn main() {
 
     std::env::set_var("RUST_BACKTRACE", "full");
 
-    let jormungandr = prepare_command(command_args.jormungandr);
-    let jcli = prepare_command(command_args.jcli);
+    let jormungandr = prepare_command(&command_args.jormungandr);
+    let jcli = prepare_command(&command_args.jcli);
     let progress_bar_mode = command_args.progress_bar_mode;
     let seed = command_args
         .seed
@@ -154,9 +154,9 @@ fn introduction<R: rand_core::RngCore>(context: &Context<R>) {
 ###############################################################################
     "###,
         *style::icons::jormungandr,
-        style::binary.apply_to(context.jormungandr().to_string()),
+        style::binary.apply_to(context.jormungandr().to_string_lossy()),
         *style::icons::jcli,
-        style::binary.apply_to(context.jcli().to_string()),
+        style::binary.apply_to(context.jcli().to_string_lossy()),
         *style::icons::seed,
         style::seed.apply_to(context.seed()),
     )