tests/worker-task-abort.rs: test abort worker

tests/worker-task-abort.rs

@@ -0,0 +1,94 @@
+use failure::*;
+
+#[macro_use]
+extern crate proxmox_backup;
+
+extern crate tokio;
+extern crate nix;
+
+use tokio::prelude::future::lazy;
+
+use proxmox_backup::server;
+use proxmox_backup::tools;
+
+
+fn garbage_collection(worker: &server::WorkerTask) -> Result<(), Error> {
+
+    worker.log("start garbage collection");
+
+    for i in 0..50 {
+        worker.fail_on_abort()?;
+
+        flog!(worker, "progress {}", i);
+
+        std::thread::sleep(std::time::Duration::from_millis(10));
+    }
+
+    worker.log("end garbage collection");
+
+    Ok(()).into()
+}
+
+
+#[test]
+fn worker_task_abort() -> Result<(), Error> {
+
+    server::create_task_log_dirs()?;
+
+    use std::sync::{Arc, Mutex};
+
+    let errmsg: Arc<Mutex<Option<String>>> = Arc::new(Mutex::new(None));
+    let errmsg1 = errmsg.clone();
+
+    tokio::run(lazy(move ||  {
+
+        let init_result: Result<(), Error> = try_block!({
+            server::create_task_control_socket()?;
+            server::server_state_init()?;
+            Ok(())
+        });
+
+        if let Err(err) = init_result {
+            eprintln!("unable to start daemon - {}", err);
+            return Ok(());
+        }
+
+        let errmsg = errmsg1.clone();
+        let res = server::WorkerTask::new_thread("garbage_collection", None, "root@pam", true, move |worker| {
+            println!("WORKER {}", worker);
+
+            let result = garbage_collection(&worker);
+            tools::request_shutdown();
+
+            if let Err(err) = result {
+                println!("got expected error: {}", err);
+            } else {
+                let mut data = errmsg.lock().unwrap();
+                *data = Some(String::from("thread finished - seems abort did not work as expected"));
+            }
+
+            Ok(())
+        });
+
+        match res {
+            Err(err) => {
+                println!("unable to start worker - {}", err);
+            }
+            Ok(wid) => {
+                println!("WORKER: {}", wid);
+                server::abort_worker_async(wid.parse::<server::UPID>().unwrap());
+            }
+        }
+
+        Ok(())
+    }));
+
+
+    let data = errmsg.lock().unwrap();
+    match *data {
+        Some(ref err) => bail!("Error: {}", err),
+        None => {},
+    }
+
+    Ok(())
+}