tests/worker-task-abort.rs

   1 use failure::*;
   2
   3 #[macro_use]
   4 extern crate proxmox_backup;
   5
   6 extern crate tokio;
   7 extern crate nix;
   8
   9 use tokio::prelude::future::lazy;
  10
  11 use proxmox_backup::server;
  12 use proxmox_backup::tools;
  13
  14
  15 fn garbage_collection(worker: &server::WorkerTask) -> Result<(), Error> {
  16
  17     worker.log("start garbage collection");
  18
  19     for i in 0..50 {
  20         worker.fail_on_abort()?;
  21
  22         flog!(worker, "progress {}", i);
  23
  24         std::thread::sleep(std::time::Duration::from_millis(10));
  25     }
  26
  27     worker.log("end garbage collection");
  28
  29     Ok(()).into()
  30 }
  31
  32
  33 #[test]
  34 fn worker_task_abort() -> Result<(), Error> {
  35
  36     server::create_task_log_dirs()?;
  37
  38     use std::sync::{Arc, Mutex};
  39
  40     let errmsg: Arc<Mutex<Option<String>>> = Arc::new(Mutex::new(None));
  41     let errmsg1 = errmsg.clone();
  42
  43     tokio::run(lazy(move ||  {
  44
  45         let init_result: Result<(), Error> = try_block!({
  46             server::create_task_control_socket()?;
  47             server::server_state_init()?;
  48             Ok(())
  49         });
  50
  51         if let Err(err) = init_result {
  52             eprintln!("unable to start daemon - {}", err);
  53             return Ok(());
  54         }
  55
  56         let errmsg = errmsg1.clone();
  57         let res = server::WorkerTask::new_thread("garbage_collection", None, "root@pam", true, move |worker| {
  58             println!("WORKER {}", worker);
  59
  60             let result = garbage_collection(&worker);
  61             tools::request_shutdown();
  62
  63             if let Err(err) = result {
  64                 println!("got expected error: {}", err);
  65             } else {
  66                 let mut data = errmsg.lock().unwrap();
  67                 *data = Some(String::from("thread finished - seems abort did not work as expected"));
  68             }
  69
  70             Ok(())
  71         });
  72
  73         match res {
  74             Err(err) => {
  75                 println!("unable to start worker - {}", err);
  76             }
  77             Ok(wid) => {
  78                 println!("WORKER: {}", wid);
  79                 server::abort_worker_async(wid.parse::<server::UPID>().unwrap());
  80             }
  81         }
  82
  83         Ok(())
  84     }));
  85
  86
  87     let data = errmsg.lock().unwrap();
  88     match *data {
  89         Some(ref err) => bail!("Error: {}", err),
  90         None => {},
  91     }
  92
  93     Ok(())
  94 }