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(())
  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 rt = tokio::runtime::Runtime::new().unwrap();
  43     rt.block_on(async move {
  44
  45         let mut commando_sock = server::CommandoSocket::new(server::our_ctrl_sock());
  46
  47         let init_result: Result<(), Error> = try_block!({
  48             server::register_task_control_commands(&mut commando_sock)?;
  49             server::server_state_init()?;
  50             Ok(())
  51         });
  52
  53         if let Err(err) = init_result {
  54             eprintln!("unable to start daemon - {}", err);
  55             return;
  56         }
  57
  58         let errmsg = errmsg1.clone();
  59         let res = server::WorkerTask::new_thread(
  60             "garbage_collection",
  61             None,
  62             proxmox_backup::api2::types::Authid::root_auth_id().clone(),
  63             true,
  64             move |worker| {
  65                 println!("WORKER {}", worker);
  66
  67                 let result = garbage_collection(&worker);
  68                 tools::request_shutdown();
  69
  70                 if let Err(err) = result {
  71                     println!("got expected error: {}", err);
  72                 } else {
  73                     let mut data = errmsg.lock().unwrap();
  74                     *data = Some(String::from("thread finished - seems abort did not work as expected"));
  75                 }
  76
  77                 Ok(())
  78             },
  79         );
  80
  81         match res {
  82             Err(err) => {
  83                 println!("unable to start worker - {}", err);
  84             }
  85             Ok(wid) => {
  86                 println!("WORKER: {}", wid);
  87                 server::abort_worker_async(wid.parse::<server::UPID>().unwrap());
  88             }
  89         }
  90     });
  91
  92     let data = errmsg.lock().unwrap();
  93     match *data {
  94         Some(ref err) => bail!("Error: {}", err),
  95         None => {},
  96     }
  97
  98     Ok(())
  99 }