2019-12-15 16:07:36 +00:00
|
|
|
use actix_web::{
|
2019-12-21 19:21:13 +00:00
|
|
|
get,
|
|
|
|
http::header,
|
|
|
|
web::{Data, Query},
|
|
|
|
App, HttpResponse, HttpServer, Responder,
|
2019-12-15 16:07:36 +00:00
|
|
|
};
|
|
|
|
use handlebars::Handlebars;
|
2019-12-21 19:04:13 +00:00
|
|
|
use hotwatch::{Event, Hotwatch};
|
2019-12-23 03:10:21 +00:00
|
|
|
use itertools::Itertools;
|
|
|
|
use percent_encoding::{utf8_percent_encode, AsciiSet, CONTROLS};
|
2019-12-15 17:49:16 +00:00
|
|
|
use serde::Deserialize;
|
2019-12-23 04:45:28 +00:00
|
|
|
use std::collections::HashMap;
|
2019-12-21 20:43:04 +00:00
|
|
|
use std::fmt;
|
2019-12-23 04:45:28 +00:00
|
|
|
use std::fs::{read_to_string, OpenOptions};
|
2019-12-21 20:43:04 +00:00
|
|
|
use std::io::Write;
|
2019-12-15 17:49:16 +00:00
|
|
|
use std::sync::{Arc, RwLock};
|
2019-12-21 19:04:13 +00:00
|
|
|
use std::time::Duration;
|
2019-12-15 16:07:36 +00:00
|
|
|
|
2019-12-23 05:08:16 +00:00
|
|
|
mod template_args;
|
|
|
|
|
2019-12-23 03:10:21 +00:00
|
|
|
/// https://url.spec.whatwg.org/#fragment-percent-encode-set
|
|
|
|
static FRAGMENT_ENCODE_SET: &AsciiSet =
|
|
|
|
&CONTROLS.add(b' ').add(b'"').add(b'<').add(b'>').add(b'`');
|
2019-12-15 19:57:42 +00:00
|
|
|
static DEFAULT_CONFIG: &[u8] = include_bytes!("../bunbun.default.toml");
|
2019-12-15 18:54:09 +00:00
|
|
|
static CONFIG_FILE: &str = "bunbun.toml";
|
2019-12-15 16:07:36 +00:00
|
|
|
|
2019-12-21 20:43:04 +00:00
|
|
|
#[derive(Debug)]
|
2019-12-23 03:10:21 +00:00
|
|
|
#[allow(clippy::enum_variant_names)]
|
2019-12-21 20:43:04 +00:00
|
|
|
enum BunBunError {
|
|
|
|
IoError(std::io::Error),
|
2019-12-21 20:56:59 +00:00
|
|
|
ParseError(serde_yaml::Error),
|
2019-12-22 04:34:03 +00:00
|
|
|
WatchError(hotwatch::Error),
|
2019-12-21 20:43:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl fmt::Display for BunBunError {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
|
|
match self {
|
|
|
|
BunBunError::IoError(e) => e.fmt(f),
|
2019-12-21 20:56:59 +00:00
|
|
|
BunBunError::ParseError(e) => e.fmt(f),
|
2019-12-22 04:34:03 +00:00
|
|
|
BunBunError::WatchError(e) => e.fmt(f),
|
2019-12-21 20:43:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-12-23 01:05:01 +00:00
|
|
|
/// Generates a from implementation from the specified type to the provided
|
|
|
|
/// bunbun error.
|
2019-12-22 04:34:03 +00:00
|
|
|
macro_rules! from_error {
|
|
|
|
($from:ty, $to:ident) => {
|
|
|
|
impl From<$from> for BunBunError {
|
|
|
|
fn from(e: $from) -> Self {
|
|
|
|
BunBunError::$to(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
2019-12-21 20:43:04 +00:00
|
|
|
}
|
|
|
|
|
2019-12-22 04:34:03 +00:00
|
|
|
from_error!(std::io::Error, IoError);
|
|
|
|
from_error!(serde_yaml::Error, ParseError);
|
|
|
|
from_error!(hotwatch::Error, WatchError);
|
2019-12-21 20:56:59 +00:00
|
|
|
|
2019-12-15 16:07:36 +00:00
|
|
|
#[get("/ls")]
|
2019-12-21 19:04:13 +00:00
|
|
|
fn list(data: Data<Arc<RwLock<State>>>) -> impl Responder {
|
2019-12-21 19:21:13 +00:00
|
|
|
let data = data.read().unwrap();
|
|
|
|
HttpResponse::Ok().body(data.renderer.render("list", &data.routes).unwrap())
|
2019-12-15 18:54:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Deserialize)]
|
|
|
|
struct SearchQuery {
|
2019-12-21 19:21:13 +00:00
|
|
|
to: String,
|
2019-12-15 16:07:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[get("/hop")]
|
2019-12-23 01:05:01 +00:00
|
|
|
fn hop(
|
|
|
|
data: Data<Arc<RwLock<State>>>,
|
|
|
|
query: Query<SearchQuery>,
|
|
|
|
) -> impl Responder {
|
2019-12-21 19:21:13 +00:00
|
|
|
let data = data.read().unwrap();
|
|
|
|
|
2019-12-23 03:10:21 +00:00
|
|
|
match resolve_hop(&query.to, &data.routes, &data.default_route) {
|
2019-12-23 05:08:16 +00:00
|
|
|
(Some(path), args) => HttpResponse::Found()
|
|
|
|
.header(
|
|
|
|
header::LOCATION,
|
|
|
|
data
|
|
|
|
.renderer
|
|
|
|
.render_template(
|
|
|
|
&path,
|
|
|
|
&template_args::query(
|
|
|
|
utf8_percent_encode(&args, FRAGMENT_ENCODE_SET).to_string(),
|
|
|
|
),
|
|
|
|
)
|
|
|
|
.unwrap(),
|
|
|
|
)
|
|
|
|
.finish(),
|
2019-12-23 03:10:21 +00:00
|
|
|
(None, _) => HttpResponse::NotFound().body("not found"),
|
2019-12-21 19:21:13 +00:00
|
|
|
}
|
2019-12-23 03:10:21 +00:00
|
|
|
}
|
2019-12-21 19:21:13 +00:00
|
|
|
|
2019-12-23 03:10:21 +00:00
|
|
|
/// Attempts to resolve the provided string into its route and its arguments.
|
|
|
|
/// If a default route was provided, then this will consider that route before
|
|
|
|
/// failing to resolve a route.
|
|
|
|
///
|
|
|
|
/// The first element in the tuple describes the route, while the second element
|
|
|
|
/// returns the remaining arguments. If none remain, an empty string is given.
|
|
|
|
fn resolve_hop(
|
|
|
|
query: &str,
|
2019-12-23 04:45:28 +00:00
|
|
|
routes: &HashMap<String, String>,
|
2019-12-23 03:10:21 +00:00
|
|
|
default_route: &Option<String>,
|
|
|
|
) -> (Option<String>, String) {
|
|
|
|
let mut split_args = query.split_ascii_whitespace().peekable();
|
|
|
|
let command = match split_args.peek() {
|
|
|
|
Some(command) => command,
|
|
|
|
None => return (None, String::new()),
|
|
|
|
};
|
2019-12-21 19:21:13 +00:00
|
|
|
|
2019-12-23 03:10:21 +00:00
|
|
|
match (routes.get(*command), default_route) {
|
|
|
|
// Found a route
|
|
|
|
(Some(resolved), _) => (
|
|
|
|
Some(resolved.clone()),
|
|
|
|
match split_args.next() {
|
|
|
|
// Discard the first result, we found the route using the first arg
|
|
|
|
Some(_) => split_args.join(" "),
|
|
|
|
None => String::new(),
|
|
|
|
},
|
|
|
|
),
|
|
|
|
// Unable to find route, but had a default route
|
|
|
|
(None, Some(route)) => (routes.get(route).cloned(), split_args.join(" ")),
|
|
|
|
// No default route and no match
|
|
|
|
(None, None) => (None, String::new()),
|
2019-12-21 19:21:13 +00:00
|
|
|
}
|
2019-12-15 16:07:36 +00:00
|
|
|
}
|
|
|
|
|
2019-12-15 17:49:16 +00:00
|
|
|
#[get("/")]
|
2019-12-21 19:04:13 +00:00
|
|
|
fn index(data: Data<Arc<RwLock<State>>>) -> impl Responder {
|
2019-12-21 19:21:13 +00:00
|
|
|
let data = data.read().unwrap();
|
2019-12-23 05:08:16 +00:00
|
|
|
HttpResponse::Ok().body(
|
|
|
|
data
|
|
|
|
.renderer
|
|
|
|
.render(
|
|
|
|
"index",
|
|
|
|
&template_args::hostname(data.public_address.clone()),
|
|
|
|
)
|
|
|
|
.unwrap(),
|
|
|
|
)
|
2019-12-15 17:49:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[get("/bunbunsearch.xml")]
|
2019-12-21 19:04:13 +00:00
|
|
|
fn opensearch(data: Data<Arc<RwLock<State>>>) -> impl Responder {
|
2019-12-21 19:21:13 +00:00
|
|
|
let data = data.read().unwrap();
|
|
|
|
HttpResponse::Ok()
|
|
|
|
.header(
|
|
|
|
header::CONTENT_TYPE,
|
|
|
|
"application/opensearchdescription+xml",
|
|
|
|
)
|
2019-12-23 05:08:16 +00:00
|
|
|
.body(
|
|
|
|
data
|
|
|
|
.renderer
|
|
|
|
.render(
|
|
|
|
"opensearch",
|
|
|
|
&template_args::hostname(data.public_address.clone()),
|
|
|
|
)
|
|
|
|
.unwrap(),
|
|
|
|
)
|
2019-12-15 17:49:16 +00:00
|
|
|
}
|
|
|
|
|
2019-12-23 01:05:01 +00:00
|
|
|
/// Dynamic variables that either need to be present at runtime, or can be
|
|
|
|
/// changed during runtime.
|
2019-12-15 17:49:16 +00:00
|
|
|
struct State {
|
2019-12-21 19:21:13 +00:00
|
|
|
public_address: String,
|
|
|
|
default_route: Option<String>,
|
2019-12-23 04:45:28 +00:00
|
|
|
routes: HashMap<String, String>,
|
2019-12-21 19:21:13 +00:00
|
|
|
renderer: Handlebars,
|
2019-12-15 17:49:16 +00:00
|
|
|
}
|
|
|
|
|
2019-12-21 20:43:04 +00:00
|
|
|
fn main() -> Result<(), BunBunError> {
|
2019-12-21 19:21:13 +00:00
|
|
|
let conf = read_config(CONFIG_FILE)?;
|
|
|
|
let renderer = compile_templates();
|
|
|
|
let state = Arc::from(RwLock::new(State {
|
|
|
|
public_address: conf.public_address,
|
|
|
|
default_route: conf.default_route,
|
|
|
|
routes: conf.routes,
|
|
|
|
renderer,
|
|
|
|
}));
|
|
|
|
let state_ref = state.clone();
|
|
|
|
|
2019-12-22 04:34:03 +00:00
|
|
|
let mut watch = Hotwatch::new_with_custom_delay(Duration::from_millis(500))?;
|
|
|
|
|
|
|
|
watch.watch(CONFIG_FILE, move |e: Event| {
|
|
|
|
if let Event::Write(_) = e {
|
|
|
|
let mut state = state.write().unwrap();
|
|
|
|
match read_config(CONFIG_FILE) {
|
|
|
|
Ok(conf) => {
|
|
|
|
state.public_address = conf.public_address;
|
|
|
|
state.default_route = conf.default_route;
|
|
|
|
state.routes = conf.routes;
|
2019-12-21 20:56:59 +00:00
|
|
|
}
|
2019-12-22 04:34:03 +00:00
|
|
|
Err(e) => eprintln!("Config is malformed: {}", e),
|
2019-12-21 19:21:13 +00:00
|
|
|
}
|
2019-12-22 04:34:03 +00:00
|
|
|
}
|
|
|
|
})?;
|
2019-12-21 19:21:13 +00:00
|
|
|
|
|
|
|
HttpServer::new(move || {
|
|
|
|
App::new()
|
|
|
|
.data(state_ref.clone())
|
|
|
|
.service(hop)
|
|
|
|
.service(list)
|
|
|
|
.service(index)
|
|
|
|
.service(opensearch)
|
|
|
|
})
|
|
|
|
.bind(&conf.bind_address)?
|
2019-12-21 20:43:04 +00:00
|
|
|
.run()?;
|
|
|
|
|
|
|
|
Ok(())
|
2019-12-15 17:49:16 +00:00
|
|
|
}
|
2019-12-15 16:07:36 +00:00
|
|
|
|
2019-12-23 01:05:01 +00:00
|
|
|
#[derive(Deserialize)]
|
|
|
|
struct Config {
|
|
|
|
bind_address: String,
|
|
|
|
public_address: String,
|
|
|
|
default_route: Option<String>,
|
2019-12-23 04:45:28 +00:00
|
|
|
routes: HashMap<String, String>,
|
2019-12-23 01:05:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Attempts to read the config file. If it doesn't exist, generate one a
|
|
|
|
/// default config file before attempting to parse it.
|
2019-12-21 20:43:04 +00:00
|
|
|
fn read_config(config_file_path: &str) -> Result<Config, BunBunError> {
|
2019-12-23 04:45:28 +00:00
|
|
|
let config_str = match read_to_string(config_file_path) {
|
|
|
|
Ok(conf_str) => conf_str,
|
2019-12-21 19:21:13 +00:00
|
|
|
Err(_) => {
|
|
|
|
eprintln!(
|
|
|
|
"Unable to find a {} file. Creating default!",
|
|
|
|
config_file_path
|
|
|
|
);
|
|
|
|
let mut fd = OpenOptions::new()
|
|
|
|
.write(true)
|
|
|
|
.create_new(true)
|
|
|
|
.open(config_file_path)
|
|
|
|
.expect("Unable to write to directory!");
|
|
|
|
fd.write_all(DEFAULT_CONFIG)?;
|
2019-12-23 04:45:28 +00:00
|
|
|
String::from_utf8_lossy(DEFAULT_CONFIG).into_owned()
|
2019-12-21 19:21:13 +00:00
|
|
|
}
|
|
|
|
};
|
2019-12-23 04:45:28 +00:00
|
|
|
|
|
|
|
// Reading from memory is faster than reading directly from a reader for some
|
|
|
|
// reason; see https://github.com/serde-rs/json/issues/160
|
|
|
|
Ok(serde_yaml::from_str(&config_str)?)
|
2019-12-21 19:16:47 +00:00
|
|
|
}
|
|
|
|
|
2019-12-23 01:05:01 +00:00
|
|
|
/// Returns an instance with all pre-generated templates included into the
|
|
|
|
/// binary. This allows for users to have a portable binary without needed the
|
|
|
|
/// templates at runtime.
|
2019-12-15 17:49:16 +00:00
|
|
|
fn compile_templates() -> Handlebars {
|
2019-12-21 19:21:13 +00:00
|
|
|
let mut handlebars = Handlebars::new();
|
2019-12-22 04:34:03 +00:00
|
|
|
macro_rules! register_template {
|
2019-12-23 01:05:01 +00:00
|
|
|
[ $( $template:expr ),* ] => {
|
2019-12-22 04:34:03 +00:00
|
|
|
$(
|
|
|
|
handlebars
|
|
|
|
.register_template_string(
|
|
|
|
$template,
|
|
|
|
String::from_utf8_lossy(
|
|
|
|
include_bytes!(concat!("templates/", $template, ".hbs")))
|
|
|
|
)
|
|
|
|
.unwrap();
|
|
|
|
)*
|
|
|
|
};
|
|
|
|
}
|
2019-12-23 01:05:01 +00:00
|
|
|
register_template!["index", "list", "opensearch"];
|
2019-12-21 19:21:13 +00:00
|
|
|
handlebars
|
2019-12-15 16:07:36 +00:00
|
|
|
}
|