Add backend proxy to aid local fastboot testing

To avoid the need to set up a local nginx configuration during
development, this commit adds a simple proxy for frontend requests when
`USE_FASTBOOT=staging-experimental` is set.

When enabled, developers should browse to http://localhost:8888/
(instead of port 4200 when using `npm run start:local`).

Author: jtgeibel

src/middleware.rs

@@ -5,6 +5,7 @@ mod prelude {
     use std::error::Error;
     pub type BoxError = Box<dyn Error + Send>;
     pub type Result<T> = std::result::Result<T, BoxError>;
+    pub type ConcreteResult<T> = std::result::Result<T, crate::util::Error>;
 }
 
 pub use prelude::Result;

src/middleware/ember_index_rewrite.rs

@@ -2,18 +2,34 @@
 //! with "/api" and the Accept header contains "html".
 
 use super::prelude::*;
+use std::{
+    collections::{hash_map::Entry, HashMap},
+    fmt::Write,
+    io::Cursor,
+};
 
-use crate::util::RequestProxy;
+use crate::util::{errors::NotFound, RequestProxy};
+
+use reqwest::blocking::Client;
 
 // Can't derive debug because of Handler and Static.
 #[allow(missing_debug_implementations)]
 pub struct EmberIndexRewrite {
     handler: Option<Box<dyn Handler>>,
+    fastboot_client: Option<Client>,
 }
 
 impl Default for EmberIndexRewrite {
     fn default() -> EmberIndexRewrite {
-        EmberIndexRewrite { handler: None }
+        let fastboot_client = match dotenv::var("USE_FASTBOOT") {
+            Ok(val) if val == "staging-experimental" => Some(Client::new()),
+            _ => None,
+        };
+
+        EmberIndexRewrite {
+            handler: None,
+            fastboot_client,
+        }
     }
 }
 
@@ -25,21 +41,78 @@ impl AroundMiddleware for EmberIndexRewrite {
 
 impl Handler for EmberIndexRewrite {
     fn call(&self, req: &mut dyn Request) -> Result<Response> {
-        // If the client is requesting html, then we've only got one page so
-        // rewrite the request.
-        let wants_html = req
-            .headers()
-            .find("Accept")
-            .map(|accept| accept.iter().any(|s| s.contains("html")))
-            .unwrap_or(false);
-        // If the route starts with /api, just assume they want the API
-        // response and fall through.
-        let is_api_path = req.path().starts_with("/api");
         let handler = self.handler.as_ref().unwrap();
-        if wants_html && !is_api_path {
-            handler.call(&mut RequestProxy::rewrite_path(req, "/index.html"))
-        } else {
+
+        if req.path().starts_with("/api") {
             handler.call(req)
+        } else {
+            if let Some(client) = &self.fastboot_client {
+                // During local fastboot development, forward requests to the local fastboot server.
+                // In prodution, including when running with fastboot, nginx proxies the requests
+                // to the correct endpoint and requests should never make it here.
+                return proxy_to_fastboot(client, req).map_err(|e| Box::new(e) as BoxError);
+            }
+
+            if req
+                .headers()
+                .find("Accept")
+                .map(|accept| accept.iter().any(|s| s.contains("html")))
+                .unwrap_or(false)
+            {
+                // Serve static Ember page to bootstrap the frontend
+                handler.call(&mut RequestProxy::rewrite_path(req, "/index.html"))
+            } else {
+                // Return a 404 to crawlers that don't send `Accept: text/hml`.
+                // This is to preserve legacy behavior and will likely change.
+                // Most of these crawlers probably won't execute our frontend JS anyway, but
+                // it would be nice to bootstrap the app for crawlers that do execute JS.
+                Ok(NotFound.into())
+            }
         }
     }
 }
+
+/// Proxy to the fastboot server in development mode
+///
+/// This handler is somewhat hacky, and is not intended for usage in production.
+///
+/// # Panics
+///
+/// This function can panic and should only be used in development mode.
+fn proxy_to_fastboot(client: &Client, req: &mut dyn Request) -> ConcreteResult<Response> {
+    if req.method() != conduit::Method::Get {
+        return Err(format!("Only support GET but request method was {}", req.method()).into());
+    }
+
+    let mut url = format!("http://127.0.0.1:9000{}", req.path());
+    if let Some(query) = req.query_string() {
+        write!(url, "?{}", query).map_err(|e| e.to_string())?;
+    }
+    let mut request = client.request(reqwest::Method::GET, &*url);
+    for header in req.headers().all() {
+        for value in header.1 {
+            request = request.header(header.0, value);
+        }
+    }
+
+    let mut fastboot_response = request.send()?;
+    let mut headers: HashMap<String, Vec<String>> = HashMap::new();
+    for header in fastboot_response.headers() {
+        match headers.entry(header.0.to_string()) {
+            Entry::Occupied(mut v) => {
+                v.get_mut().push(header.1.to_str().unwrap().to_owned());
+            }
+            Entry::Vacant(v) => {
+                v.insert(vec![header.1.to_str().unwrap().to_owned()]);
+            }
+        };
+    }
+
+    let mut body = Vec::new();
+    fastboot_response.copy_to(&mut body)?;
+    Ok(conduit::Response {
+        status: (fastboot_response.status().as_u16() as u32, "OK"),
+        headers,
+        body: Box::new(Cursor::new(body)),
+    })
+}

src/util/errors.rs

@@ -221,9 +221,15 @@ impl AppError for InternalAppError {
 #[derive(Debug, Clone, Copy)]
 pub struct NotFound;
 
+impl From<NotFound> for Response {
+    fn from(_: NotFound) -> Response {
+        json_error("Not Found", (404, "Not Found"))
+    }
+}
+
 impl AppError for NotFound {
     fn response(&self) -> Option<Response> {
-        Some(json_error("Not Found", (404, "Not Found")))
+        Some(NotFound.into())
     }
 }