1 files changed, 30 insertions, 39 deletions
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()
+    }
 }