87 lines
2.2 KiB
Rust
87 lines
2.2 KiB
Rust
#[macro_use(router)]
|
|
extern crate router;
|
|
extern crate iron;
|
|
extern crate urlencoded;
|
|
|
|
use iron::{status, Response, Request, Iron, IronResult};
|
|
use iron::prelude::*;
|
|
use urlencoded::UrlEncodedQuery;
|
|
use std::process::Command;
|
|
use std::{thread, time};
|
|
|
|
fn respond(ret_status: status::Status, message: &str) -> IronResult<Response> {
|
|
Ok(Response::with((
|
|
ret_status,
|
|
message
|
|
)))
|
|
}
|
|
|
|
fn index(_: &mut Request) -> IronResult<Response> {
|
|
respond(status::Ok, "You found the index!")
|
|
}
|
|
|
|
fn remote_run(remote: &str, actions: &Vec<String>) -> IronResult<Response> {
|
|
let actions: Vec<&str> = actions[0].split(',').collect();
|
|
//let message = format!("Actions: {:?}", actions);
|
|
let mut status = Some(0);
|
|
for action in actions {
|
|
let output = Command::new("irsend")
|
|
.arg("SEND_ONCE")
|
|
.arg(remote)
|
|
.arg(action)
|
|
.output();
|
|
|
|
match output {
|
|
Ok(ref out) => status = if !out.status.success() { out.status.code() } else { status },
|
|
Err(_) => status = None
|
|
}
|
|
|
|
thread::sleep(time::Duration::from_secs(1));
|
|
|
|
}
|
|
let message = match status {
|
|
Some(code) => if code == 0 { "Success" } else { "Failure" },
|
|
None => "Could not find irsend program"
|
|
};
|
|
respond(status::Ok, message)
|
|
}
|
|
|
|
fn remote(req: &mut Request) -> IronResult<Response> {
|
|
let url_ref = req.url.clone();
|
|
let remote_name = url_ref.path()[0];
|
|
|
|
let query_ref = match req.url.query() {
|
|
Some(_) => req.get_ref::<UrlEncodedQuery>(),
|
|
None => return respond(
|
|
status::BadRequest,
|
|
"Please add `actions` to the query params"
|
|
)
|
|
};
|
|
|
|
let actions = match query_ref {
|
|
Ok(ref hashmap) => hashmap.get("actions"),
|
|
Err(ref e) => return respond(
|
|
status::BadRequest,
|
|
format!("{:?}", e).as_str()
|
|
)
|
|
};
|
|
|
|
match actions {
|
|
Some(act) => remote_run(remote_name, act),
|
|
None => respond(
|
|
status::BadRequest,
|
|
format!("No actions specified!").as_str()
|
|
)
|
|
}
|
|
}
|
|
|
|
|
|
fn main() {
|
|
let router = router!(
|
|
index: get "/" => index,
|
|
remote: get "/:remote" => remote
|
|
);
|
|
|
|
Iron::new(router).http("0.0.0.0:3000").unwrap();
|
|
}
|