src/bin/download-speed.rs: switch to async

Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com>

src/bin/download-speed.rs

@@ -1,16 +1,10 @@
-use failure::*;
-use futures::*;
 use std::io::Write;
 
-//use std::sync::Arc;
+use failure::*;
-//use serde_json::Value;
+
 use chrono::{DateTime, Utc};
 
-//use proxmox_backup::tools;
+use proxmox_backup::client::HttpClient;
-//use proxmox_backup::backup::*;
-use proxmox_backup::client::*;
-//use proxmox_backup::pxar;
-//use futures::stream::Stream;
 
 pub struct DummyWriter {
     bytes: usize,
@@ -29,7 +23,7 @@ impl Write for DummyWriter {
 }
 
 
-fn run() -> Result<(), Error> {
+async fn run() -> Result<(), Error> {
 
     let host = "localhost";
 
@@ -39,57 +33,33 @@ fn run() -> Result<(), Error> {
 
     let backup_time = "2019-06-28T10:49:48Z".parse::<DateTime<Utc>>()?;
 
-    let client = client.start_backup_reader("store2", "host", "elsa", backup_time, true).wait()?;
+    let client = client
+        .start_backup_reader("store2", "host", "elsa", backup_time, true)
+        .await?;
 
     let start = std::time::SystemTime::now();
 
-    futures::stream::repeat(())
+    let mut bytes = 0;
-        .take(100)
+    for _ in 0..100 {
-        .and_then(|_| {
         let writer = DummyWriter { bytes: 0 };
-            client.speedtest(writer)
+        let writer = client.speedtest(writer).await?;
-                .and_then(|writer| {
         println!("Received {} bytes", writer.bytes);
-                    Ok(writer.bytes)
+        bytes += writer.bytes;
-                })
-        })
-        .fold(0, move |mut acc, size| {
-            acc += size;
-            Ok::<_, Error>(acc)
-        })
-        .then(move |result| {
-            match result {
-                Err(err) => {
-                    println!("ERROR {}", err);
     }
-                Ok(bytes) => {
+
     let elapsed = start.elapsed().unwrap();
     let elapsed = (elapsed.as_secs() as f64) +
         (elapsed.subsec_millis() as f64)/1000.0;
 
     println!("Downloaded {} bytes, {} MB/s", bytes, (bytes as f64)/(elapsed*1024.0*1024.0));
-                }
-            }
-            Ok::<_, Error>(())
-        })
-        .wait()?;
 
     Ok(())
 }
 
-fn main() {
+#[tokio::main]
-
+async fn main() {
-    //let mut rt = tokio::runtime::Runtime::new().unwrap();
+    if let Err(err) = run().await {
-
-    // should be rt.block_on_all, but this block forever in release builds
-    tokio::run(lazy(move || {
-   // let _ = rt.block_on(lazy(move || -> Result<(), ()> {
-        if let Err(err) = run() {
         eprintln!("ERROR: {}", err);
     }
-        println!("DONE1");
+    println!("DONE");
-        Ok(())
-    }));
-
-    println!("DONE2");
 }