work: added basic skeleton of Service and Transform to ...

saskenuba · saskenuba · commit 21d5f54f13ab · 2022-03-02T17:54:20.000-03:00
PreheaderMiddleware

Signed-off-by: Martin &lt;martin@hotmail.com.br&gt;
diff --git a/Cargo.toml b/Cargo.toml
@@ -11,10 +11,12 @@ license = "MIT"
 actix-service = "2"
 actix-utils = "3"
 actix-web = { version = "4", default-features = false }
-smartstring = "1"
 
 futures-util = "0.3"
 log = "0.4"
+reqwest = { version = "0.11", features = ["tokio-rustls"] }
+thiserror = "1"
+url = "2"
 
 [dev-dependencies]
 actix-web = { version = "4", default_features = false, features = ["macros"] }
diff --git a/src/errors.rs b/src/errors.rs
@@ -0,0 +1,10 @@
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum PrerenderError {
+    #[error("Invalid Url.")]
+    InvalidUrl,
+
+    #[error(transparent)]
+    ReqwestError(#[from] reqwest::Error),
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -2,14 +2,15 @@
 
 #![forbid(unsafe_code)]
 #![deny(nonstandard_style)]
-#![allow(clippy::must_use_candidate)]
+#![allow(clippy::must_use_candidate, clippy::missing_panics_doc)]
 #![warn(future_incompatible, missing_debug_implementations)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
 
 use consts::{IGNORED_EXTENSIONS, USER_AGENTS};
 
 mod consts;
+pub mod errors;
 pub mod middleware;
 
 // impl<S, B> Service<ServiceRequest> for PrerenderMiddleWare
diff --git a/src/middleware.rs b/src/middleware.rs
@@ -1,75 +1,75 @@
+use crate::errors::PrerenderError;
 use crate::{IGNORED_EXTENSIONS, USER_AGENTS};
-use actix_web::dev::ServiceRequest;
+use actix_service::{Service, Transform};
+use actix_utils::future;
+use actix_utils::future::Ready;
+use actix_web::body::BoxBody;
+
+use actix_web::dev::{ServiceRequest, ServiceResponse};
 use actix_web::http::header::HeaderMap;
 use actix_web::http::uri::PathAndQuery;
 use actix_web::http::{header, Method};
+use actix_web::{Error, HttpResponse};
+use futures_util::future::LocalBoxFuture;
+use futures_util::TryFutureExt;
+use reqwest::Client;
+use url::Url;
 
-#[derive(Debug)]
-struct PrerenderMiddleware {
-    prerender_service_url: String,
+#[derive(Debug, Clone)]
+pub struct Prerender {
+    prerender_service_url: Url,
+    inner_client: Client,
 }
 
-impl PrerenderMiddleware {
-    pub fn prepare_build_api_url(&self, req: &ServiceRequest) -> String {
-        let req_uri = req.uri();
-        let req_headers = req.headers();
-
-        // TODO: this.host?
-        let host = req
-            .uri()
-            .host()
-            .or_else(|| {
-                req_headers
-                    .get("X-Forwarded-Host")
-                    .and_then(|hdr| hdr.to_str().ok())
-            })
-            .or_else(|| {
-                req_headers
-                    .get(header::HOST)
-                    .and_then(|hdr| hdr.to_str().ok())
-            })
-            .unwrap();
-
-        let scheme = req.uri().scheme_str().unwrap_or("http");
-        let url_path_query = req_uri.path_and_query().map(PathAndQuery::as_str).unwrap();
-
-        format!(
-            "{}{}://{}{}",
-            &*self.prerender_service_url, scheme, host, url_path_query
-        )
-    }
+#[derive(Debug, Clone)]
+pub struct Inner {
+    prerender_service_url: Url,
+    inner_client: Client,
 }
 
+impl Prerender {}
+
 #[derive(Debug)]
-struct PrerenderMiddlewareBuilder {}
+pub struct PrerenderBuilder {}
 
-impl PrerenderMiddlewareBuilder {
-    pub fn use_prerender_io() -> PrerenderMiddleware {
-        PrerenderMiddleware {
-            prerender_service_url: prerender_url().to_string(),
+impl PrerenderBuilder {
+    pub fn use_prerender_io(mut self) -> Prerender {
+        Prerender {
+            prerender_service_url: prerender_url(),
+            inner_client: Default::default(),
         }
     }
 
-    pub fn use_custom_prerender_url(prerender_service_url: &impl ToString) -> PrerenderMiddleware {
-        PrerenderMiddleware {
-            prerender_service_url: prerender_service_url.to_string(),
-        }
+    pub fn use_custom_prerender_url(
+        mut self,
+        prerender_service_url: &str,
+    ) -> Result<Prerender, PrerenderError> {
+        let result = Url::parse(prerender_service_url).map_err(|_| PrerenderError::InvalidUrl)?;
+
+        Ok(Prerender {
+            prerender_service_url: result,
+            inner_client: Default::default(),
+        })
     }
 }
 
-impl PrerenderMiddleware {
-    pub fn builder() -> PrerenderMiddlewareBuilder {
-        PrerenderMiddlewareBuilder {}
+impl Prerender {
+    pub fn builder() -> PrerenderBuilder {
+        PrerenderBuilder {}
     }
 }
 
+fn prerender_url() -> Url {
+    Url::parse("https://service.prerender.io").unwrap()
+}
+
 /// Decides if should prerender the page or not.
 ///
 /// Will NOT prerender on the following cases:
 /// * HTTP is not GET or HEAD
 /// * User agent is NOT crawler
 /// * Is requesting a resource on `IGNORED_EXTENSIONS`
-pub fn should_prerender(req: &ServiceRequest) -> bool {
+pub(crate) fn should_prerender(req: &ServiceRequest) -> bool {
     let request_headers = req.headers();
     let mut is_crawler = false;
 
@@ -78,9 +78,9 @@ pub fn should_prerender(req: &ServiceRequest) -> bool {
     }
 
     let req_ua_lowercase = if let Some(user_agent) = request_headers.get(header::USER_AGENT) {
-        let user_agent = user_agent.to_str();
+        let user_agent = user_agent.to_str().map(str::to_lowercase);
         if let Ok(ua) = user_agent {
-            ua.to_lowercase()
+            ua
         } else {
             return false;
         }
@@ -111,37 +111,135 @@ pub fn should_prerender(req: &ServiceRequest) -> bool {
     is_crawler
 }
 
-pub fn get_prerendered_response(req: ServiceRequest) {
-    let mut prerender_request_headers = HeaderMap::new();
-    let forward_headers = true;
+#[derive(Debug)]
+pub struct PrerenderMiddleware<S> {
+    pub(crate) service: S,
+    prerender_service_url: Url,
+    inner_client: Client,
+}
 
-    if forward_headers {
-        prerender_request_headers = req.headers().clone();
-        prerender_request_headers.remove(header::HOST);
+impl<S> PrerenderMiddleware<S> {
+    pub fn prepare_build_api_url(&self, req: &ServiceRequest) -> String {
+        let req_uri = req.uri();
+        let req_headers = req.headers();
+
+        // TODO: this.host?
+        let host = req
+            .uri()
+            .host()
+            .or_else(|| {
+                req_headers
+                    .get("X-Forwarded-Host")
+                    .and_then(|hdr| hdr.to_str().ok())
+            })
+            .or_else(|| {
+                req_headers
+                    .get(header::HOST)
+                    .and_then(|hdr| hdr.to_str().ok())
+            })
+            .unwrap();
+
+        let scheme = req.uri().scheme_str().unwrap_or("http");
+        let url_path_query = req_uri.path_and_query().map(PathAndQuery::as_str).unwrap();
+
+        format!(
+            "{}{}://{}{}",
+            self.prerender_service_url, scheme, host, url_path_query
+        )
+    }
+
+    pub async fn get_rendered_response(
+        &self,
+        req: ServiceRequest,
+    ) -> Result<ServiceResponse, PrerenderError> {
+        let mut prerender_request_headers = HeaderMap::new();
+        let forward_headers = true;
+
+        if forward_headers {
+            prerender_request_headers = req.headers().clone();
+            prerender_request_headers.remove(header::HOST);
+        }
+
+        prerender_request_headers.append(header::ACCEPT_ENCODING, "gzip".parse().unwrap());
+
+        // TODO: accept `X-Prerender-Token`
+        // prerender_request_headers.insert("X-Prerender-Token", pre_render_token);
+
+        let url_to_request = self.prepare_build_api_url(&req);
+        let prerender_response = self
+            .inner_client
+            .get(url_to_request)
+            .send()
+            .and_then(|a| a.bytes())
+            .await?;
+
+        let http_response = HttpResponse::Ok().body(prerender_response);
+        Ok(req.into_response(http_response))
     }
+}
+
+impl<S> Service<ServiceRequest> for PrerenderMiddleware<S>
+where
+    S: Service<ServiceRequest, Response = ServiceResponse, Error = Error>,
+    S::Future: 'static,
+{
+    type Response = ServiceResponse<BoxBody>;
+    type Error = Error;
+    type Future = LocalBoxFuture<'static, Result<ServiceResponse<BoxBody>, Error>>;
+
+    actix_service::forward_ready!(service);
 
-    prerender_request_headers.append(header::ACCEPT_ENCODING, "gzip".parse().unwrap());
+    fn call(&self, req: ServiceRequest) -> Self::Future {
+        // life goes on
+        if !should_prerender(&req) {
+            let fut = self.service.call(req);
+            return Box::pin(async move { fut.await });
+        }
 
-    // TODO: accept `X-Prerender-Token`
-    // prerender_request_headers.insert("X-Prerender-Token", pre_render_token);
+        // let response = self.get_rendered_response(req).await.map_err(|e| );
+        todo!()
+    }
 }
 
-pub fn prerender_url() -> &'static str {
-    "https://service.prerender.io/"
+impl<S> Transform<S, ServiceRequest> for Prerender
+where
+    S: Service<ServiceRequest, Response = ServiceResponse, Error = Error>,
+    S::Future: 'static,
+{
+    type Response = ServiceResponse<BoxBody>;
+    type Error = Error;
+    type Transform = PrerenderMiddleware<S>;
+    type InitError = ();
+    type Future = Ready<Result<Self::Transform, Self::InitError>>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        future::ok(PrerenderMiddleware {
+            service,
+            prerender_service_url: self.prerender_service_url.clone(),
+            inner_client: self.inner_client.clone(),
+        })
+    }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::middleware::should_prerender;
-    use actix_web::http::{header, Method};
+    use crate::middleware::{prerender_url, should_prerender, Prerender, PrerenderMiddleware};
+    use actix_service::Transform;
+    use actix_web::http::header;
+    use actix_web::middleware::Compat;
     use actix_web::test::TestRequest;
+    use actix_web::{test, App};
 
     fn init_logger() {
         let _ = env_logger::builder().is_test(true).try_init();
     }
 
-    #[test]
-    fn test_human_valid_resource() {
+    fn compat_compat() {
+        let _ = App::new().wrap(Compat::new(Prerender::builder().use_prerender_io()));
+    }
+
+    #[actix_web::test]
+    async fn test_human_valid_resource() {
         let req = TestRequest::get()
             .insert_header((
                 header::USER_AGENT,
@@ -153,8 +251,8 @@ mod tests {
         assert!(!should_prerender(&req));
     }
 
-    #[test]
-    fn test_crawler_valid_resource() {
+    #[actix_web::test]
+    async fn test_crawler_valid_resource() {
         let req = TestRequest::get()
             .insert_header((
                 header::USER_AGENT,
@@ -166,8 +264,8 @@ mod tests {
         assert!(should_prerender(&req));
     }
 
-    #[test]
-    fn test_crawler_ignored_resource() {
+    #[actix_web::test]
+    async fn test_crawler_ignored_resource() {
         let req = TestRequest::get()
             .insert_header((
                 header::USER_AGENT,
@@ -180,8 +278,8 @@ mod tests {
         assert!(!render);
     }
 
-    #[test]
-    fn test_crawler_wrong_http_method() {
+    #[actix_web::test]
+    async fn test_crawler_wrong_http_method() {
         let req = TestRequest::post()
             .insert_header((
                 header::USER_AGENT,
@@ -193,4 +291,31 @@ mod tests {
         let render = should_prerender(&req);
         assert!(!render);
     }
+
+    fn create_middleware() -> Prerender {
+        Prerender::builder().use_prerender_io()
+    }
+
+    #[actix_web::test]
+    async fn test_redirect_url() {
+        let req_url = "http://yourserver.com/clothes/tshirts?query=xl";
+
+        let req = TestRequest::get()
+            .insert_header((
+                header::USER_AGENT,
+                "Mozilla/5.0 (X11; Linux x86_64; rv:62.0) Gecko/20100101 Firefox/62.0",
+            ))
+            .uri(req_url)
+            .to_srv_request();
+
+        let middleware = create_middleware()
+            .new_transform(test::ok_service())
+            .into_inner()
+            .unwrap();
+
+        assert_eq!(
+            middleware.prepare_build_api_url(&req),
+            format!("{}{}", prerender_url(), req_url)
+        );
+    }
 }
