From 948c74f4ca07fe720b4694ca8e35a19fbc1760c0 Mon Sep 17 00:00:00 2001
From: Dietmar Maurer <dietmar@proxmox.com>
Date: Mon, 19 Nov 2018 06:40:57 +0100
Subject: [PATCH] move future test code into extra file

---
 src/lib.rs             |  5 ++++
 src/main.rs            | 63 -----------------------------------------
 src/storage/futures.rs | 64 ++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 69 insertions(+), 63 deletions(-)
 create mode 100644 src/storage/futures.rs

diff --git a/src/lib.rs b/src/lib.rs
index a547fba9..6ff16017 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -12,6 +12,11 @@ pub mod api {
 
 }
 
+pub mod storage {
+
+    pub mod futures;
+}
+
 pub mod getopts;
 
 pub mod api3;
diff --git a/src/main.rs b/src/main.rs
index 5b2f34fd..58af18ac 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,65 +12,10 @@ use apitest::getopts;
 //use failure::*;
 use lazy_static::lazy_static;
 
-
 use futures::future::Future;
 
 use hyper;
 
-use std::thread;
-use std::sync::{Arc, Mutex};
-use failure::*;
-use tokio::prelude::*;
-
-struct StorageOperation {
-    state: Arc<Mutex<bool>>,
-    running: bool,
-}
-
-impl StorageOperation {
-
-    fn new() -> Self {
-        StorageOperation { state: Arc::new(Mutex::new(false)), running: false }
-    }
-
-    fn run(&mut self, task: task::Task) {
-
-        let state = self.state.clone();
-
-        thread::spawn(move || {
-            println!("state {}", state.lock().unwrap());
-            println!("Starting Asnyc worker thread");
-            thread::sleep(::std::time::Duration::from_secs(5));
-            println!("End Asnyc worker thread");
-            *state.lock().unwrap() = true;
-            task.notify();
-        });
-    }
-}
-
-impl Future for StorageOperation {
-    type Item = ();
-    type Error = Error;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if *self.state.lock().unwrap() != true {
-            println!("not ready - parking the task.");
-
-            if !self.running {
-                println!("starting storage thread");
-                self.run(task::current());
-                self.running = true;
-            }
-
-            Ok(Async::NotReady)
-        } else {
-            println!("storage thread ready - task will complete.");
-            Ok(Async::Ready(()))
-        }
-    }
-}
-
-
 fn main() {
     println!("Proxmox REST Server example.");
 
@@ -116,14 +61,6 @@ fn main() {
         .map_err(|e| eprintln!("server error: {}", e));
 
 
-    if false {
-        let op = StorageOperation::new();
-        hyper::rt::run(op.map_err(|e| {
-            println!("Got Error: {}", e);
-            ()
-        }));
-    }
-
     // Run this server for... forever!
     hyper::rt::run(server);
 }
diff --git a/src/storage/futures.rs b/src/storage/futures.rs
new file mode 100644
index 00000000..6a8fd8fd
--- /dev/null
+++ b/src/storage/futures.rs
@@ -0,0 +1,64 @@
+use std::thread;
+use std::sync::{Arc, Mutex};
+use failure::*;
+use tokio::prelude::*;
+
+struct StorageOperation {
+    state: Arc<Mutex<bool>>,
+    running: bool,
+}
+
+impl StorageOperation {
+
+    fn new() -> Self {
+        StorageOperation { state: Arc::new(Mutex::new(false)), running: false }
+    }
+
+    fn run(&mut self, task: task::Task) {
+
+        let state = self.state.clone();
+
+        thread::spawn(move || {
+            println!("state {}", state.lock().unwrap());
+            println!("Starting Asnyc worker thread (delay 1 second)");
+            thread::sleep(::std::time::Duration::from_secs(1));
+            println!("End Asnyc worker thread");
+            *state.lock().unwrap() = true;
+            task.notify();
+        });
+    }
+}
+
+impl Future for StorageOperation {
+    type Item = ();
+    type Error = Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if *self.state.lock().unwrap() != true {
+            println!("not ready - parking the task.");
+
+            if !self.running {
+                println!("starting storage thread");
+                self.run(task::current());
+                self.running = true;
+            }
+
+            Ok(Async::NotReady)
+        } else {
+            println!("storage thread ready - task will complete.");
+            Ok(Async::Ready(()))
+        }
+    }
+}
+
+
+#[test]
+fn test_storage_future()
+{
+
+    let op = StorageOperation::new();
+    hyper::rt::run(op.map_err(|e| {
+        println!("Got Error: {}", e);
+        ()
+    }));
+}