This proxy works!

src/main.rs

@@ -1,6 +1,59 @@
+#[macro_use] extern crate log;
 
 
-fn main() {
-  println!("WIP");
+/*#[derive(Deserialize)]
+pub struct SpeakRequest {
+  /// Slug for the speaker
+  speaker: String,
+  /// Raw text to be spoken
+  text: String,
+}*/
+
+use hyper::server::conn::AddrStream;
+use hyper::{Body, Request, Response, Server};
+use hyper::service::{service_fn, make_service_fn};
+use futures::future::{self, Future};
+
+type BoxFut = Box<Future<Item=Response<Body>, Error=hyper::Error> + Send>;
+
+fn debug_request(req: Request<Body>) -> BoxFut {
+  let body_str = format!("{:?}", req);
+  let response = Response::new(Body::from(body_str));
+  Box::new(future::ok(response))
 }
 
+fn main() {
+
+  // This is our socket address...
+  let addr = ([127, 0, 0, 1], 13900).into();
+
+  // A `Service` is needed for every connection.
+  let make_svc = make_service_fn(|socket: &AddrStream| {
+    let remote_addr = socket.remote_addr();
+    service_fn(move |req: Request<Body>| { // returns BoxFut
+
+      if req.uri().path().starts_with("/target/first") {
+
+        // will forward requests to port 13901
+        return hyper_reverse_proxy::call(remote_addr.ip(), "http://127.0.0.1:12345", req)
+
+      } else if req.uri().path().starts_with("/target/second") {
+
+        // will forward requests to port 13902
+        return hyper_reverse_proxy::call(remote_addr.ip(), "http://127.0.0.1:3000", req)
+
+      } else {
+        debug_request(req)
+      }
+    })
+  });
+
+  let server = Server::bind(&addr)
+    .serve(make_svc)
+    .map_err(|e| eprintln!("server error: {}", e));
+
+  println!("Running server on {:?}", addr);
+
+  // Run this server for... forever!
+  hyper::rt::run(server);
+}

src/middlewares.rs

@@ -0,0 +1,66 @@
+//use chrono::{DateTime, Utc};
+//use serde_json;
+
+use hyper::{Body, Request, Response};
+use simple_proxy::proxy::error::MiddlewareError;
+use simple_proxy::proxy::middleware::MiddlewareResult::Next;
+use simple_proxy::proxy::middleware::{Middleware, MiddlewareResult};
+use simple_proxy::proxy::service::{ServiceContext, State};
+
+#[derive(Clone, Default)]
+pub struct Logger;
+
+/// # Panics
+/// May panic if the request state has not been initialized in `before_request`.
+/// e.g If a middleware responded early before the logger in `before_request`.
+impl Middleware for Logger {
+  fn name() -> String {
+    String::from("Logger")
+  }
+
+  fn before_request(
+    &mut self,
+    req: &mut Request<Body>,
+    context: &ServiceContext,
+    state: &State,
+  ) -> Result<MiddlewareResult, MiddlewareError> {
+    info!(
+      "[{}] Starting a {} request to {}",
+      &context.req_id.to_string()[..6],
+      req.method(),
+      req.uri()
+    );
+    //let now = serde_json::to_string(&Utc::now()).expect("[Logger] Cannot serialize DateTime");
+    self.set_state(context.req_id, state, "foo".to_string())?;
+    Ok(Next)
+  }
+
+  fn after_request(
+    &mut self,
+    _res: Option<&mut Response<Body>>,
+    context: &ServiceContext,
+    state: &State,
+  ) -> Result<MiddlewareResult, MiddlewareError> {
+    let start_time = self.get_state(context.req_id, state)?;
+    match start_time {
+      Some(time) => {
+        //let start_time: DateTime<Utc> = serde_json::from_str(&time)?;
+
+        info!(
+          "[{}] Request took {}ms",
+          &context.req_id.to_string()[..6],
+          12345
+          //(Utc::now() - start_time).num_milliseconds()
+        );
+      }
+      None => error!("[Logger] start time not found in state"),
+    }
+    Ok(Next)
+  }
+}
+
+impl Logger {
+  pub fn new() -> Self {
+    Logger {}
+  }
+}