tests/worker-task-abort.rs

   1 use anyhow::{bail, Error};
   2
   3 #[macro_use]
   4 extern crate proxmox_backup;
   5
   6 extern crate tokio;
   7 extern crate nix;
   8
   9 use proxmox::try_block;
  10
  11 use proxmox_backup::server;
  12 use proxmox_backup::tools;
  13
  14 fn garbage_collection(worker: &server::WorkerTask) -> Result<(), Error> {
  15
  16     worker.log("start garbage collection");
  17
  18     for i in 0..50 {
  19         worker.fail_on_abort()?;
  20
  21         flog!(worker, "progress {}", i);
  22
  23         std::thread::sleep(std::time::Duration::from_millis(10));
  24     }
  25
  26     worker.log("end garbage collection");
  27
  28     Ok(()).into()
  29 }
  30
  31
  32 #[test] #[ignore]
  33 fn worker_task_abort() -> Result<(), Error> {
  34
  35     server::create_task_log_dirs()?;
  36
  37     use std::sync::{Arc, Mutex};
  38
  39     let errmsg: Arc<Mutex<Option<String>>> = Arc::new(Mutex::new(None));
  40     let errmsg1 = errmsg.clone();
  41
  42     let mut rt = tokio::runtime::Runtime::new().unwrap();
  43     rt.block_on(async 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;
  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
  84     let data = errmsg.lock().unwrap();
  85     match *data {
  86         Some(ref err) => bail!("Error: {}", err),
  87         None => {},
  88     }
  89
  90     Ok(())
  91 }