src/bin/download-speed.rs

   1 use failure::*;
   2 use futures::*;
   3 use std::io::Write;
   4
   5 //use std::sync::Arc;
   6 //use serde_json::Value;
   7 use chrono::{DateTime, Utc};
   8
   9 //use proxmox_backup::tools;
  10 //use proxmox_backup::backup::*;
  11 use proxmox_backup::client::*;
  12 //use proxmox_backup::pxar;
  13 //use futures::stream::Stream;
  14
  15 pub struct DummyWriter {
  16     bytes: usize,
  17 }
  18
  19 impl Write for DummyWriter {
  20
  21     fn write(&mut self, data: &[u8]) -> Result<usize, std::io::Error> {
  22         self.bytes += data.len();
  23         Ok(data.len())
  24     }
  25
  26     fn flush(&mut self) -> Result<(), std::io::Error> {
  27         Ok(())
  28     }
  29 }
  30
  31
  32 fn run() -> Result<(), Error> {
  33
  34     let host = "localhost";
  35
  36     let username = "root@pam";
  37
  38     let client = HttpClient::new(host, username)?;
  39
  40     let backup_time = "2019-06-28T10:49:48Z".parse::<DateTime<Utc>>()?;
  41
  42     let client = client.start_backup_reader("store2", "host", "elsa", backup_time, true).wait()?;
  43
  44     let start = std::time::SystemTime::now();
  45
  46     futures::stream::repeat(())
  47         .take(100)
  48         .and_then(|_| {
  49             let writer = DummyWriter { bytes: 0 };
  50             client.speedtest(writer)
  51                 .and_then(|writer| {
  52                     println!("Received {} bytes", writer.bytes);
  53                     Ok(writer.bytes)
  54                 })
  55         })
  56         .fold(0, move |mut acc, size| {
  57             acc += size;
  58             Ok::<_, Error>(acc)
  59         })
  60         .then(move |result| {
  61             match result {
  62                 Err(err) => {
  63                     println!("ERROR {}", err);
  64                 }
  65                 Ok(bytes) => {
  66                     let elapsed = start.elapsed().unwrap();
  67                     let elapsed = (elapsed.as_secs() as f64) +
  68                         (elapsed.subsec_millis() as f64)/1000.0;
  69
  70                     println!("Downloaded {} bytes, {} MB/s", bytes, (bytes as f64)/(elapsed*1024.0*1024.0));
  71                 }
  72             }
  73             Ok::<_, Error>(())
  74         })
  75         .wait()?;
  76
  77     Ok(())
  78 }
  79
  80 fn main() {
  81
  82     //let mut rt = tokio::runtime::Runtime::new().unwrap();
  83
  84     // should be rt.block_on_all, but this block forever in release builds
  85     tokio::run(lazy(move || {
  86    // let _ = rt.block_on(lazy(move || -> Result<(), ()> {
  87         if let Err(err) = run() {
  88             eprintln!("ERROR: {}", err);
  89         }
  90         println!("DONE1");
  91         Ok(())
  92     }));
  93
  94     println!("DONE2");
  95 }