use iron; use iron::error::{HttpResult}; use iron::headers::ContentType; use iron::modifiers::{Header, Redirect}; use iron::status; use iron::{Iron, IronError, Request, IronResult, Response, Chain, Listening, Plugin, Url}; use iron_sessionstorage::SessionStorage; use iron_sessionstorage::backends::SignedCookieBackend; use iron_sessionstorage::traits::*; use iron_sessionstorage; use params::{Params, Value}; use regex::Regex; use render; use router::Router; use staticfile::Static; use systemd::journal; use systemd::unit; use persistent::Read; #[derive(Clone, Default, Debug)] struct Context { base_url: String } impl iron::typemap::Key for Context { type Value = Context; } #[derive(Default, Debug, Clone)] struct Login { user: String, } impl iron_sessionstorage::Value for Login { fn get_key() -> &'static str { "login" } fn into_raw(self) -> String { self.user } fn from_raw(v: String) -> Option { Some(Login{ user: v }) } } fn overview(r: &mut Request) -> IronResult { let mut _value = try!(r.session().get::()); 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::>()) }).collect::>(); // 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)); let renderer = make_renderer(r)?; Ok(Response::with((status::Ok, Header(ContentType::html()), renderer.system_status(&units_by_section)))) } fn journal(r: &mut Request) -> IronResult { let unit = iexpect!(r.extensions .get::() .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 { let unit_name = iexpect!(r.extensions .get::() .unwrap() .find("unit"), status::BadRequest).to_string(); 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)); let renderer = make_renderer(r)?; Ok(Response::with((status::Ok, Header(ContentType::html()), renderer.unit_status(&unit, &log)))) } fn get_logged_in_user(r: &mut Request) -> IronResult> { let login = r.session().get::()?; // Session storage doesn't have a way to delete its cookie, // so we set the username to empty on logout. if let &Some(Login { ref user }) = &login { if user.is_empty() { return Ok(None) } } Ok(login) } fn login(r: &mut Request) -> IronResult { let renderer = make_renderer(r)?; Ok(Response::with((status::Ok, Header(ContentType::html()), renderer.login_page()))) } fn login_submit(r: &mut Request) -> IronResult { let login = { let map = r.get_ref::().unwrap(); let user = match map.get("username") { Some(&Value::String(ref v)) => v, _ => panic!("no username in params: {:?}", map) }; let password = match map.get("password") { Some(&Value::String(ref v)) => v, _ => panic!("no password in params: {:?}", map) }; Login { user: user.clone() } }; info!("User logged in: {:?}", login); r.session().set(login)?; let url = Url::parse("http://localhost:8080/").unwrap(); Ok(Response::with((status::Found, Redirect(url)))) } fn logout(r: &mut Request) -> IronResult { r.session().set::(Default::default()); let url = Url::parse("http://localhost:8080/").unwrap(); Ok(Response::with((status::Found, Redirect(url)))) } fn make_renderer(r: &mut Request) -> IronResult { let user = get_logged_in_user(r)?.map(|u| u.user); Ok(render::Renderer { user: user }) } pub fn serve(port: u16) -> HttpResult { // TODO: Use a real secret. let secret = b"secret2".to_vec(); let router = router!( root: get "/" => overview, login: get "/login" => login, login_submit: post "/login" => login_submit, logout: get "/logout" => logout, details: get "/status/:unit" => unit_status, journal: get "/journal/:unit" => journal, css: get "/static/main.css" => Static::new(""), ); let mut chain = Chain::new(router); let context = Context { base_url: String::from("http://localhost:8080/"), }; chain.link_around(SessionStorage::new(SignedCookieBackend::new(secret))); chain.link(Read::::both(context)); let bind_address = format!("{}:{}", "::", port); Iron::new(chain).http(bind_address.as_str()) }