aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorMelody Horn <melody@boringcactus.com>2021-12-24 16:25:51 -0700
committerMelody Horn <melody@boringcactus.com>2021-12-24 16:25:51 -0700
commit3817ec811d76b91d3d4924003a4d48d0cd43a576 (patch)
tree93cd9ac73e08c9d4414bb312f7a01f104581a160 /src
parentc6d12d80babd9f4bd5692cf74ab9d6e9278859d1 (diff)
downloadnarchttpd-3817ec811d76b91d3d4924003a4d48d0cd43a576.tar.gz
narchttpd-3817ec811d76b91d3d4924003a4d48d0cd43a576.zip
rust is a myth. it doesn't existconfig-toml
Diffstat (limited to 'src')
-rw-r--r--src/main.rs121
-rw-r--r--src/utils.rs8
-rw-r--r--src/utils/proxy_child.rs69
-rw-r--r--src/utils/serve_static.rs102
4 files changed, 137 insertions, 163 deletions
diff --git a/src/main.rs b/src/main.rs
index 0951518..f284b75 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,86 +1,87 @@
+use std::collections::HashMap;
use std::convert::Infallible;
+use std::fs::read_to_string;
use std::net::SocketAddr;
use std::path::PathBuf;
-use std::rc::Rc;
use std::sync::Arc;
use hyper::service::{make_service_fn, service_fn};
use hyper::{header, Body, Request, Response, Server, StatusCode};
-use rhai::{Dynamic, Engine, FnPtr, Map, NativeCallContext, Scope};
+use serde::Deserialize;
use structopt::StructOpt;
mod utils;
+use utils::HttpHandler;
#[derive(Debug, StructOpt)]
struct Opt {
- #[structopt(long, parse(from_os_str), default_value = "narchttpd.rhai")]
- config_script: PathBuf,
+ #[structopt(long, parse(from_os_str), default_value = "narchttpd.toml")]
+ config_file: PathBuf,
}
-fn make_engine() -> Engine {
- let mut engine = Engine::new();
- engine.register_type_with_name::<Rc<Request<Body>>>("Request");
- engine.register_type::<utils::serve_static::Params>();
- engine.register_fn(
- "handle_request_serve_static",
- utils::serve_static::handle_request,
- );
- engine.register_fn("serve_static", utils::serve_static::serve_static);
- engine.register_fn(
- "handle_request_proxy_child",
- utils::proxy_child::handle_request,
- );
- engine.register_fn("proxy_child", utils::proxy_child::proxy_child);
- engine
+#[derive(Deserialize)]
+#[serde(tag = "mode", rename_all = "kebab-case")]
+enum DomainConfig {
+ Static {
+ root: PathBuf,
+ },
+
+ ProxyChild {
+ command: String,
+ in_dir: Option<PathBuf>,
+ port: u16,
+ },
+}
+
+impl DomainConfig {
+ fn handler(self) -> Box<dyn HttpHandler> {
+ match self {
+ Self::Static { root } => Box::new(utils::serve_static::Params::new(root)),
+ Self::ProxyChild {
+ command,
+ in_dir,
+ port,
+ } => Box::new(utils::proxy_child::ProxyChild::new(command, in_dir, port)),
+ }
+ }
}
-fn get_config_scope(engine: &Engine, opt: &Opt) -> Scope<'static> {
- let mut ast = engine.compile_file(opt.config_script.clone()).unwrap();
-
- let mut scope = Scope::new();
- scope.push("http_ports", [80]);
- scope.push("https_ports", [443]);
- scope.push("domains", Map::new());
- let export_ast = engine
- .compile("export http_ports, https_ports, domains;")
- .unwrap();
- ast.combine(export_ast);
- let _: () = engine.eval_ast_with_scope(&mut scope, &ast).unwrap();
- scope
+#[derive(Deserialize)]
+struct Config {
+ http_ports: Vec<u16>,
+ https_ports: Vec<u16>,
+ #[serde(flatten)]
+ domains: HashMap<String, DomainConfig>,
}
#[tokio::main]
async fn main() {
- let opt = Arc::new(Opt::from_args());
+ let opt = Opt::from_args();
- let engine = make_engine();
- let scope = get_config_scope(&engine, &opt);
+ let config_data = read_to_string(&opt.config_file).expect("Config file not found");
- let http_ports: rhai::Array = scope.get_value("http_ports").unwrap();
- let http_ports: Vec<u16> = http_ports
- .into_iter()
- .map(|x| x.as_int().unwrap() as u16)
- .collect();
- let https_ports: rhai::Array = scope.get_value("https_ports").unwrap();
- let https_ports: Vec<u16> = https_ports
- .into_iter()
- .map(|x| x.as_int().unwrap() as u16)
- .collect();
+ let Config {
+ http_ports,
+ https_ports,
+ domains,
+ } = toml::from_str(&config_data).expect("Config file not valid");
assert!(https_ports.is_empty(), "HTTPS is complicated oops");
+ let domains: HashMap<_, _> = domains
+ .into_iter()
+ .map(|(domain, config)| (domain, Arc::new(config.handler())))
+ .collect();
+ let do_response_domains = domains.clone();
+
// TODO learn hyper
- let do_response = move |ctx: &NativeCallContext, domains: Map, req: Request<Body>| {
- for (domain, handler) in &domains {
+ let do_response = move |req: Request<Body>| async move {
+ for (domain, handler) in do_response_domains.clone() {
let req_domain = req.headers().get(header::HOST).unwrap();
- if domain.as_str() == req_domain {
+ if &domain == req_domain {
eprintln!("request {:?} matched domain {}", req, domain);
// matched!
- let handler: FnPtr = handler.clone_cast();
- let args = [Dynamic::from(Rc::new(req))];
- let result = handler.call_dynamic(ctx, None, args).unwrap();
- let result: Rc<Response<Body>> = result.cast();
- return Rc::try_unwrap(result).unwrap();
+ return handler.handle(req).await;
}
}
Response::builder()
@@ -96,19 +97,7 @@ async fn main() {
let make_svc = make_service_fn(move |_conn| async move {
Ok::<_, Infallible>(service_fn(move |req| async move {
- let handle = tokio::runtime::Handle::current();
- let response = handle
- .spawn_blocking(move || {
- let opt = Opt::from_args();
- let engine = make_engine();
- let scope = get_config_scope(&engine, &opt);
- let request_handler_context =
- NativeCallContext::new(&engine, "handle_request", &[]);
- let domains: Map = scope.get_value("domains").unwrap();
- do_response(&request_handler_context, domains, req)
- })
- .await
- .unwrap();
+ let response = do_response(req).await;
Ok::<_, Infallible>(response)
}))
});
diff --git a/src/utils.rs b/src/utils.rs
index 0bd5c2e..ebc21f2 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,2 +1,10 @@
+use async_trait::async_trait;
+use hyper::{Body, Request, Response};
+
pub mod proxy_child;
pub mod serve_static;
+
+#[async_trait]
+pub trait HttpHandler: Send + Sync {
+ async fn handle(&self, request: Request<Body>) -> Response<Body>;
+}
diff --git a/src/utils/proxy_child.rs b/src/utils/proxy_child.rs
index d7a021d..cc35298 100644
--- a/src/utils/proxy_child.rs
+++ b/src/utils/proxy_child.rs
@@ -1,9 +1,12 @@
+use std::path::PathBuf;
use std::process::{Child as ChildProcess, Command};
use std::rc::Rc;
+use std::sync::Arc;
use hyper::http::uri::Scheme;
use hyper::{header, Body, Client, Request, Response};
-use rhai::{Dynamic, FnPtr, Map};
+
+use super::{async_trait, HttpHandler};
pub struct KillOnDrop(ChildProcess);
@@ -15,60 +18,48 @@ impl Drop for KillOnDrop {
#[derive(Clone)]
pub struct ProxyChild {
- process: Rc<KillOnDrop>,
+ process: Arc<KillOnDrop>,
port: u16,
}
impl ProxyChild {
- fn new(params: Map) -> Self {
- let command_line = params["command"].clone().into_immutable_string().unwrap();
- let port = params["port"].as_int().unwrap();
+ pub fn new(command_line: String, in_dir: Option<PathBuf>, port: u16) -> Self {
let mut command_line = command_line.split(" ");
let command = command_line.next().unwrap();
let mut child = Command::new(command);
child.args(command_line);
- if let Some(cwd) = params.get("in_dir") {
- let cwd = cwd.clone().into_immutable_string().unwrap();
- let cwd: &str = cwd.as_ref();
+ if let Some(cwd) = in_dir {
child.current_dir(cwd);
}
let child = child.spawn().unwrap();
Self {
- process: Rc::new(KillOnDrop(child)),
+ process: Arc::new(KillOnDrop(child)),
port: port as u16,
}
}
}
-pub fn handle_request(child: &mut ProxyChild, request: Rc<Request<Body>>) -> Rc<Response<Body>> {
- let ProxyChild { port, .. } = child;
- let mut request_uri = request.uri().clone().into_parts();
- // TODO ipv6 loopback?
- request_uri.authority = Some(format!("127.0.0.1:{}", port).parse().unwrap());
- request_uri.scheme = Some(Scheme::HTTP);
- let mut proxy_request = Request::builder()
- .method(request.method())
- .uri(request_uri)
- .header(header::HOST, request.headers()[header::HOST].clone());
- proxy_request.headers_mut().unwrap().extend(
- request
- .headers()
- .iter()
- .map(|(x, y)| (x.clone(), y.clone())),
- );
- // TODO handle nonempty body
- let proxy_request = proxy_request.body(Body::empty()).unwrap();
- let response = async {
+#[async_trait]
+impl HttpHandler for ProxyChild {
+ async fn handle(&self, request: Request<Body>) -> Response<Body> {
+ let ProxyChild { port, .. } = self;
+ let mut request_uri = request.uri().clone().into_parts();
+ // TODO ipv6 loopback?
+ request_uri.authority = Some(format!("127.0.0.1:{}", port).parse().unwrap());
+ request_uri.scheme = Some(Scheme::HTTP);
+ let mut proxy_request = Request::builder()
+ .method(request.method())
+ .uri(request_uri)
+ .header(header::HOST, request.headers()[header::HOST].clone());
+ proxy_request.headers_mut().unwrap().extend(
+ request
+ .headers()
+ .iter()
+ .map(|(x, y)| (x.clone(), y.clone())),
+ );
+ // TODO handle nonempty body
+ let proxy_request = proxy_request.body(Body::empty()).unwrap();
let client = Client::new();
- Rc::new(client.request(proxy_request).await.unwrap())
- };
- let runtime = tokio::runtime::Handle::current();
- runtime.block_on(response)
-}
-
-pub fn proxy_child(params: Map) -> FnPtr {
- let child = ProxyChild::new(params);
- let mut result = FnPtr::new("handle_request_proxy_child").unwrap();
- result.add_curry(Dynamic::from(child));
- result
+ client.request(proxy_request).await.unwrap()
+ }
}
diff --git a/src/utils/serve_static.rs b/src/utils/serve_static.rs
index 2ec0a90..c087c21 100644
--- a/src/utils/serve_static.rs
+++ b/src/utils/serve_static.rs
@@ -1,75 +1,61 @@
use std::fs::File;
use std::io::{ErrorKind, Read};
use std::path::PathBuf;
-use std::rc::Rc;
use hyper::{Body, Request, Response, StatusCode};
-use rhai::{Dynamic, FnPtr, Map};
+
+use super::{async_trait, HttpHandler};
#[derive(Clone, Debug)]
pub struct Params {
root: PathBuf,
}
-#[derive(Debug)]
-pub struct KeyError(&'static str);
-
-impl TryFrom<Map> for Params {
- type Error = KeyError;
-
- fn try_from(mut value: Map) -> Result<Self, Self::Error> {
- let root = value
- .remove("root")
- .and_then(|value| value.into_immutable_string().ok())
- .ok_or(KeyError("root"))?;
- let root: PathBuf = root.parse().unwrap();
+impl Params {
+ pub fn new(root: PathBuf) -> Self {
let root = root.canonicalize().unwrap();
- Ok(Self { root })
+ Self { root }
}
}
-pub fn handle_request(params: &mut Params, request: Rc<Request<Body>>) -> Rc<Response<Body>> {
- let Params { root } = params;
- eprintln!("handling request {:?}", request);
- let request_path = request.uri().path();
- let request_path = request_path.trim_start_matches("/");
- let target = root.join(request_path);
- let target = if target.is_dir() {
- target.join("index.html")
- } else {
- target
- };
- eprintln!("target is {}", target.display());
- let response = if target.ancestors().all(|ancestor| ancestor != root) {
- // oops! all directory traversal
- Response::builder()
- .status(StatusCode::BAD_REQUEST)
- .body(Body::empty())
- } else {
- let file = File::open(target);
- match file {
- Ok(mut file) => {
- let mut result = Vec::new();
- file.read_to_end(&mut result).unwrap();
- Response::builder().body(Body::from(result))
- }
- Err(err) => {
- let status_code = match err.kind() {
- ErrorKind::NotFound => StatusCode::NOT_FOUND,
- _ => StatusCode::BAD_REQUEST,
- };
- Response::builder()
- .status(status_code)
- .body(Body::from(status_code.canonical_reason().unwrap_or("")))
+#[async_trait]
+impl HttpHandler for Params {
+ async fn handle(&self, request: Request<Body>) -> Response<Body> {
+ let Params { root } = self;
+ eprintln!("handling request {:?}", request);
+ let request_path = request.uri().path();
+ let request_path = request_path.trim_start_matches("/");
+ let target = root.join(request_path);
+ let target = if target.is_dir() {
+ target.join("index.html")
+ } else {
+ target
+ };
+ eprintln!("target is {}", target.display());
+ let response = if target.ancestors().all(|ancestor| ancestor != root) {
+ // oops! all directory traversal
+ Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::empty())
+ } else {
+ let file = File::open(target);
+ match file {
+ Ok(mut file) => {
+ let mut result = Vec::new();
+ file.read_to_end(&mut result).unwrap();
+ Response::builder().body(Body::from(result))
+ }
+ Err(err) => {
+ let status_code = match err.kind() {
+ ErrorKind::NotFound => StatusCode::NOT_FOUND,
+ _ => StatusCode::BAD_REQUEST,
+ };
+ Response::builder()
+ .status(status_code)
+ .body(Body::from(status_code.canonical_reason().unwrap_or("")))
+ }
}
- }
- };
- Rc::new(response.unwrap())
-}
-
-pub fn serve_static(params: Map) -> FnPtr {
- let params: Params = params.try_into().unwrap();
- let mut result = FnPtr::new("handle_request_serve_static").unwrap();
- result.add_curry(Dynamic::from(params));
- result
+ };
+ response.unwrap()
+ }
}