refactor: Move server part to the library.

4 files changed, 130 insertions, 119 deletions

diff --git a/src/auth/mod.rs b/src/auth/mod.rs
index 9ef9960..f3db525 100644
--- a/src/auth/mod.rs
+++ b/src/auth/mod.rs
@@ -1,4 +1,3 @@
-extern crate crypto;
 extern crate base64;
 
 use crypto::bcrypt_pbkdf::bcrypt_pbkdf;
diff --git a/src/bin/main.rs b/src/bin/main.rs
index 36463a6..b54c4c0 100644
--- a/src/bin/main.rs
+++ b/src/bin/main.rs
@@ -1,127 +1,12 @@
 // CSRF protection
 // https://github.com/heartsucker/iron-csrf
 #[macro_use]
-extern crate iron;
-#[macro_use]
 extern crate log;
-#[macro_use]
-extern crate router;
-extern crate env_logger;
 extern crate systemhttp;
-extern crate iron_sessionstorage;
-extern crate staticfile;
-extern crate regex;
-
-use iron_sessionstorage::traits::*;
-use iron_sessionstorage::SessionStorage;
-use iron_sessionstorage::backends::SignedCookieBackend;
-use iron::status;
-use iron::modifiers::Header;
-use iron::headers::ContentType;
-use iron::{Iron, Request, IronResult, Response, Chain};
-use router::Router;
-use systemhttp::systemd::unit;
-use systemhttp::systemd::journal;
-use systemhttp::render;
-use staticfile::Static;
-use regex::Regex;
-
-struct Aaa(String);
-
-impl iron_sessionstorage::Value for Aaa {
-    fn get_key() -> &'static str {
-        "aaa"
-    }
-    fn into_raw(self) -> String {
-        self.0
-    }
-    fn from_raw(v: String) -> Option<Self> {
-        Some(Aaa(v))
-    }
-}
-
-fn overview(r: &mut Request) -> IronResult<Response> {
-    let mut _value = match try!(r.session().get::<Aaa>()) {
-        Some(aaa) => aaa,
-        None => Aaa("".to_owned()),
-    };
-
-    let name = r.extensions
-        .get::<Router>()
-        .unwrap()
-        .find("name")
-        .unwrap_or("World").to_owned();
-
-    let units = unit::get_units("*").unwrap();
-
-    let sections = ["service", "timer", "socket", "target", "slice", "mount",
-                    "path"];
-    let units_by_section = sections.iter().map(|&s| {
-        (s.to_owned(),
-         units.iter().filter(|&u| &u.type_ == s).collect::<Vec<&unit::Unit>>())
-    }).collect::<Vec<_>>();
-
-    // let res = Ok(Response::with((status::Ok,
-    //                              Header(ContentType::html()),
-    //                              render_message(&format!("Hello, {} ({})",
-    //                                                      name,
-    //                                                      session_value.0),
-    //                                             &units))));
-
-    // info!("Updating session value. Current value: {}", session_value.0);
-    // session_value.0.push('a');
-    // try!(r.session().set(session_value));
-    Ok(Response::with((status::Ok,
-                       Header(ContentType::html()),
-                       render::system_status(&units_by_section))))
-}
-
-fn journal(r: &mut Request) -> IronResult<Response> {
-    let unit = iexpect!(r.extensions
-                        .get::<Router>()
-                        .unwrap()
-                        .find("unit"), status::BadRequest);
-    let re = Regex::new(r"[-_\w\d]*").unwrap();
-    if !re.is_match(unit) {
-        return Ok(Response::with(
-            (status::BadRequest,
-             format!("Unit ({}) does not match {}",
-                     unit, re))));
-    }
-    Ok(Response::with((status::Ok,
-                       itry!(journal::get_log(unit, 100)))))
-}
-
-fn unit_status(r: &mut Request) -> IronResult<Response> {
-    let unit_name = iexpect!(r.extensions
-                             .get::<Router>()
-                             .unwrap()
-                             .find("unit"), status::BadRequest);
-    let re = Regex::new(r"[-_\w\d]*").unwrap();
-    if !re.is_match(unit_name) {
-        return Ok(Response::with(
-            (status::BadRequest,
-             format!("Unit ({}) does not match {}",
-                     unit_name, re))));
-    }
-    let ref unit = itry!(unit::get_units(unit_name))[0];
-    let log = itry!(journal::get_log(unit_name, 15));
-    Ok(Response::with((status::Ok,
-                       Header(ContentType::html()),
-                       render::unit_status(&unit, &log))))
-}
+extern crate env_logger;
 
 fn main() {
     env_logger::init().unwrap();
-    let secret = b"secret2".to_vec();
-    let router = router!(
-        root: get "/" => overview,
-        details: get "/status/:unit" => unit_status,
-        journal: get "/journal/:unit" => journal,
-        css: get "/static/main.css" => Static::new(""),
-    );
-    let mut chain = Chain::new(router);
-    chain.link_around(SessionStorage::new(SignedCookieBackend::new(secret)));
-    let _server = Iron::new(chain).http(":::8080").unwrap();
-    println!("On 8080");
+    let _server = systemhttp::server::serve(8080).unwrap();
+    println!("Serving on {}", 8080);
 }
diff --git a/src/lib.rs b/src/lib.rs
index cbc8777..ad0f971 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,10 +1,23 @@
 #[macro_use]
 extern crate horrorshow;
 extern crate sqlite;
+extern crate crypto;
+extern crate base64;
+#[macro_use]
+extern crate iron;
+#[macro_use]
+extern crate log;
+#[macro_use]
+extern crate router;
+extern crate env_logger;
+extern crate iron_sessionstorage;
+extern crate staticfile;
+extern crate regex;
 
 pub mod systemd;
 pub mod render;
 pub mod auth;
+pub mod server;
 
 #[cfg(test)]
 mod tests {
diff --git a/src/server.rs b/src/server.rs
new file mode 100644
index 0000000..dad728e
--- /dev/null
+++ b/src/server.rs
@@ -0,0 +1,114 @@
+extern crate iron_sessionstorage;
+use iron_sessionstorage::traits::*;
+use iron_sessionstorage::SessionStorage;
+use iron_sessionstorage::backends::SignedCookieBackend;
+use iron::status;
+use iron::modifiers::Header;
+use iron::headers::ContentType;
+use iron::{Iron, Request, IronResult, Response, Chain, Listening};
+use iron::error::{HttpResult};
+use router::Router;
+use systemd::unit;
+use systemd::journal;
+use render;
+use staticfile::Static;
+use regex::Regex;
+
+struct Aaa(String);
+
+impl iron_sessionstorage::Value for Aaa {
+    fn get_key() -> &'static str {
+        "aaa"
+    }
+    fn into_raw(self) -> String {
+        self.0
+    }
+    fn from_raw(v: String) -> Option<Self> {
+        Some(Aaa(v))
+    }
+}
+
+fn overview(r: &mut Request) -> IronResult<Response> {
+    let mut _value = match try!(r.session().get::<Aaa>()) {
+        Some(aaa) => aaa,
+        None => Aaa("".to_owned()),
+    };
+
+    let name = r.extensions
+        .get::<Router>()
+        .unwrap()
+        .find("name")
+        .unwrap_or("World").to_owned();
+
+    let units = unit::get_units("*").unwrap();
+
+    let sections = ["service", "timer", "socket", "target", "slice", "mount",
+                    "path"];
+    let units_by_section = sections.iter().map(|&s| {
+        (s.to_owned(),
+         units.iter().filter(|&u| &u.type_ == s).collect::<Vec<&unit::Unit>>())
+    }).collect::<Vec<_>>();
+
+    // let res = Ok(Response::with((status::Ok,
+    //                              Header(ContentType::html()),
+    //                              render_message(&format!("Hello, {} ({})",
+    //                                                      name,
+    //                                                      session_value.0),
+    //                                             &units))));
+
+    // info!("Updating session value. Current value: {}", session_value.0);
+    // session_value.0.push('a');
+    // try!(r.session().set(session_value));
+    Ok(Response::with((status::Ok,
+                       Header(ContentType::html()),
+                       render::system_status(&units_by_section))))
+}
+
+fn journal(r: &mut Request) -> IronResult<Response> {
+    let unit = iexpect!(r.extensions
+                        .get::<Router>()
+                        .unwrap()
+                        .find("unit"), status::BadRequest);
+    let re = Regex::new(r"[-_\w\d]*").unwrap();
+    if !re.is_match(unit) {
+        return Ok(Response::with(
+            (status::BadRequest,
+             format!("Unit ({}) does not match {}",
+                     unit, re))));
+    }
+    Ok(Response::with((status::Ok,
+                       itry!(journal::get_log(unit, 100)))))
+}
+
+fn unit_status(r: &mut Request) -> IronResult<Response> {
+    let unit_name = iexpect!(r.extensions
+                             .get::<Router>()
+                             .unwrap()
+                             .find("unit"), status::BadRequest);
+    let re = Regex::new(r"[-_\w\d]*").unwrap();
+    if !re.is_match(unit_name) {
+        return Ok(Response::with(
+            (status::BadRequest,
+             format!("Unit ({}) does not match {}",
+                     unit_name, re))));
+    }
+    let ref unit = itry!(unit::get_units(unit_name))[0];
+    let log = itry!(journal::get_log(unit_name, 15));
+    Ok(Response::with((status::Ok,
+                       Header(ContentType::html()),
+                       render::unit_status(&unit, &log))))
+}
+
+pub fn serve(port: u16) -> HttpResult<Listening> {
+    let secret = b"secret2".to_vec();
+    let router = router!(
+        root: get "/" => overview,
+        details: get "/status/:unit" => unit_status,
+        journal: get "/journal/:unit" => journal,
+        css: get "/static/main.css" => Static::new(""),
+    );
+    let mut chain = Chain::new(router);
+    chain.link_around(SessionStorage::new(SignedCookieBackend::new(secret)));
+    let bind_address = format!("{}:{}", "::", port);
+    Iron::new(chain).http(bind_address.as_str())
+}