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