perf(serverless): avoid expensive clones (#261)

* perf(serverless): avoid expensive clones * chore: add changeset * fix: uncomment
lagonapp · Nov 18, 2022 · fee60e4 · fee60e4
1 parent 2a185ef
commit fee60e4
Show file tree

Hide file tree

Showing 5 changed files with 24 additions and 18 deletions.
diff --git a/.changeset/eighty-moons-smoke.md b/.changeset/eighty-moons-smoke.md
@@ -0,0 +1,5 @@
+---
+'@lagon/serverless': patch
+---
+
+Improve performances by avoiding expensive clones
diff --git a/packages/serverless/src/deployments/assets.rs b/packages/serverless/src/deployments/assets.rs
@@ -9,7 +9,7 @@ use super::Deployment;
 pub fn handle_asset(deployment: &Deployment, asset: &String) -> Result<Response> {
     let path = Path::new(env::current_dir()?.as_path())
         .join("deployments")
-        .join(deployment.id.clone())
+        .join(&deployment.id)
         .join(asset);
     let body = fs::read(path)?;
 

diff --git a/packages/serverless/src/deployments/mod.rs b/packages/serverless/src/deployments/mod.rs
@@ -62,7 +62,7 @@ impl Deployment {
 pub async fn get_deployments(
     mut conn: PooledConn,
     bucket: Bucket,
-) -> Result<Arc<RwLock<HashMap<String, Deployment>>>> {
+) -> Result<Arc<RwLock<HashMap<String, Arc<Deployment>>>>> {
     let deployments = Arc::new(RwLock::new(HashMap::new()));
 
     let mut deployments_list: HashMap<String, Deployment> = HashMap::new();
@@ -160,7 +160,7 @@ pub async fn get_deployments(
             }
 
             for domain in deployment.get_domains() {
-                deployments.insert(domain, deployment.clone());
+                deployments.insert(domain, Arc::new(deployment.clone()));
             }
         }
     }

diff --git a/packages/serverless/src/deployments/pubsub.rs b/packages/serverless/src/deployments/pubsub.rs
@@ -23,7 +23,7 @@ async fn clear_deployments_cache(domains: &Vec<String>) {
 
 pub fn listen_pub_sub(
     bucket: Bucket,
-    deployments: Arc<RwLock<HashMap<String, Deployment>>>,
+    deployments: Arc<RwLock<HashMap<String, Arc<Deployment>>>>,
 ) -> JoinHandle<Result<()>> {
     tokio::spawn(async move {
         let url = dotenv::var("REDIS_URL").expect("REDIS_URL must be set");
@@ -77,7 +77,7 @@ pub fn listen_pub_sub(
                             let domains = deployment.get_domains();
 
                             for domain in &domains {
-                                deployments.insert(domain.clone(), deployment.clone());
+                                deployments.insert(domain.clone(), Arc::new(deployment.clone()));
                             }
 
                             clear_deployments_cache(&domains).await;
@@ -112,22 +112,22 @@ pub fn listen_pub_sub(
                     let mut deployments = deployments.write().await;
 
                     if let Some(deployment) = deployments.get(previous_id) {
-                        let mut unpromoted_deployment = deployment.clone();
+                        let mut unpromoted_deployment = deployment.as_ref().clone();
                         unpromoted_deployment.is_production = false;
 
                         for domain in deployment.get_domains() {
                             deployments.remove(&domain);
                         }
 
                         for domain in unpromoted_deployment.get_domains() {
-                            deployments.insert(domain, unpromoted_deployment.clone());
+                            deployments.insert(domain, Arc::new(unpromoted_deployment.clone()));
                         }
                     }
 
                     let domains = deployment.get_domains();
 
                     for domain in &domains {
-                        deployments.insert(domain.clone(), deployment.clone());
+                        deployments.insert(domain.clone(), Arc::new(deployment.clone()));
                     }
 
                     clear_deployments_cache(&domains).await;

diff --git a/packages/serverless/src/main.rs b/packages/serverless/src/main.rs
@@ -59,12 +59,13 @@ async fn handle_request(
     req: HyperRequest<Body>,
     ip: String,
     pool: LocalPoolHandle,
-    deployments: Arc<RwLock<HashMap<String, Deployment>>>,
+    deployments: Arc<RwLock<HashMap<String, Arc<Deployment>>>>,
     thread_ids: Arc<RwLock<HashMap<String, usize>>>,
 ) -> Result<HyperResponse<Body>> {
-    let mut url = req.uri().to_string();
+    let url = req.uri().path();
     // Remove the leading '/' from the url
-    url.remove(0);
+    let url = &url[1..];
+    let url = url.to_owned();
 
     let hostname = match req.headers().get(HOST) {
         Some(hostname) => hostname.to_str()?.to_string(),
@@ -77,15 +78,15 @@ async fn handle_request(
 
     let deployments = deployments.read().await;
     let deployment = match deployments.get(&hostname) {
-        Some(deployment) => deployment.clone(),
+        Some(deployment) => Arc::clone(deployment),
         None => {
             warn!(request = as_debug!(req); "No deployment found for hostname");
 
             return Ok(HyperResponse::builder().status(404).body(PAGE_404.into())?);
         }
     };
 
-    let deployment_id = deployment.id.clone();
+    let deployment_id = &Arc::clone(&deployment).id;
     let thread_ids_reader = thread_ids.read().await;
 
     let thread_id = match thread_ids_reader.get(&hostname) {
@@ -299,15 +300,15 @@ async fn main() -> Result<()> {
     let bucket = Bucket::new(&bucket_name, region, credentials)?;
 
     let deployments = get_deployments(conn, bucket.clone()).await?;
-    let redis = listen_pub_sub(bucket.clone(), deployments.clone());
+    let redis = listen_pub_sub(bucket.clone(), Arc::clone(&deployments));
 
     let pool = LocalPoolHandle::new(POOL_SIZE);
     let thread_ids = Arc::new(RwLock::new(HashMap::new()));
 
     let server = Server::bind(&addr).serve(make_service_fn(move |conn: &AddrStream| {
-        let deployments = deployments.clone();
+        let deployments = Arc::clone(&deployments);
         let pool = pool.clone();
-        let thread_ids = thread_ids.clone();
+        let thread_ids = Arc::clone(&thread_ids);
 
         let addr = conn.remote_addr();
         let ip = addr.ip().to_string();
@@ -318,8 +319,8 @@ async fn main() -> Result<()> {
                     req,
                     ip.clone(),
                     pool.clone(),
-                    deployments.clone(),
-                    thread_ids.clone(),
+                    Arc::clone(&deployments),
+                    Arc::clone(&thread_ids),
                 )
             }))
         }