Remove hashmap clones (#187)

sparckles · Apr 29, 2022 · fa9b7d1 · fa9b7d1
1 parent 79d33db
commit fa9b7d1
Show file tree

Hide file tree

Showing 5 changed files with 53 additions and 28 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -33,6 +33,7 @@ actix-web-actors = "4.0.0-beta.1"
 uuid = { version = "0.8", features = ["serde", "v4"] }
 serde = "1.0.136"
 serde_json = "1.0.79"
+futures = "0.3.21"
 
 [features]
 # Defines a feature named `webp` that does not enable any other features.

diff --git a/src/executors/mod.rs b/src/executors/mod.rs
@@ -2,11 +2,15 @@
 /// i.e. the functions that have the responsibility of parsing and executing functions.
 use crate::io_helpers::read_file;
 
+use std::borrow::Borrow;
+use std::cell::RefCell;
 use std::collections::HashMap;
+use std::rc::Rc;
 use std::sync::Arc;
 
 use actix_web::{http::Method, web, HttpRequest};
 use anyhow::{bail, Result};
+use futures::lock::Mutex;
 // pyO3 module
 use crate::types::{Headers, PyFunction};
 use futures_util::stream::StreamExt;
@@ -22,7 +26,7 @@ pub async fn execute_middleware_function<'a>(
     headers: &Headers,
     req: &HttpRequest,
     route_params: HashMap<String, String>,
-    queries: HashMap<String, String>,
+    queries: Rc<RefCell<HashMap<String, String>>>,
     number_of_params: u8,
 ) -> Result<HashMap<String, HashMap<String, String>>> {
     // TODO:
@@ -55,13 +59,18 @@ pub async fn execute_middleware_function<'a>(
     for elem in (*headers).iter() {
         headers_python.insert(elem.key().clone(), elem.value().clone());
     }
+    let mut queries_clone: HashMap<String, String> = HashMap::new();
+
+    for (key, value) in (*queries).borrow().clone() {
+        queries_clone.insert(key, value);
+    }
 
     match function {
         PyFunction::CoRoutine(handler) => {
             let output = Python::with_gil(|py| {
                 let handler = handler.as_ref(py);
                 request.insert("params", route_params.into_py(py));
-                request.insert("queries", queries.into_py(py));
+                request.insert("queries", queries_clone.into_py(py));
                 request.insert("headers", headers_python.into_py(py));
                 // request.insert("body", data.into_py(py));
 
@@ -89,28 +98,30 @@ pub async fn execute_middleware_function<'a>(
         }
 
         PyFunction::SyncFunction(handler) => {
-            tokio::task::spawn_blocking(move || {
-                Python::with_gil(|py| {
-                    let handler = handler.as_ref(py);
-                    request.insert("params", route_params.into_py(py));
-                    request.insert("queries", queries.into_py(py));
-                    request.insert("headers", headers_python.into_py(py));
-                    request.insert("body", data.into_py(py));
+            // do we even need this?
+            // How else can we return a future from this?
+            // let's wrap the output in a future?
+            let output: Result<HashMap<String, HashMap<String, String>>> = Python::with_gil(|py| {
+                let handler = handler.as_ref(py);
+                request.insert("params", route_params.into_py(py));
+                request.insert("queries", queries_clone.into_py(py));
+                request.insert("headers", headers_python.into_py(py));
+                request.insert("body", data.into_py(py));
 
-                    let output: PyResult<&PyAny> = match number_of_params {
-                        0 => handler.call0(),
-                        1 => handler.call1((request,)),
-                        // this is done to accomodate any future params
-                        2_u8..=u8::MAX => handler.call1((request,)),
-                    };
+                let output: PyResult<&PyAny> = match number_of_params {
+                    0 => handler.call0(),
+                    1 => handler.call1((request,)),
+                    // this is done to accomodate any future params
+                    2_u8..=u8::MAX => handler.call1((request,)),
+                };
 
-                    let output: Vec<HashMap<String, HashMap<String, String>>> =
-                        output?.extract().unwrap();
+                let output: Vec<HashMap<String, HashMap<String, String>>> =
+                    output?.extract().unwrap();
 
-                    Ok(output[0].clone())
-                })
-            })
-            .await?
+                Ok(output[0].clone())
+            });
+
+            Ok(output.unwrap())
         }
     }
 }
@@ -123,7 +134,7 @@ pub async fn execute_http_function(
     headers: HashMap<String, String>,
     req: &HttpRequest,
     route_params: HashMap<String, String>,
-    queries: HashMap<String, String>,
+    queries: Rc<RefCell<HashMap<String, String>>>,
     number_of_params: u8,
     // need to change this to return a response struct
     // create a custom struct for this
@@ -151,12 +162,18 @@ pub async fn execute_http_function(
     // request object accessible while creating routes
     let mut request = HashMap::new();
 
+    let mut queries_clone: HashMap<String, String> = HashMap::new();
+
+    for (key, value) in (*queries).borrow().clone() {
+        queries_clone.insert(key, value);
+    }
+
     match function {
         PyFunction::CoRoutine(handler) => {
             let output = Python::with_gil(|py| {
                 let handler = handler.as_ref(py);
                 request.insert("params", route_params.into_py(py));
-                request.insert("queries", queries.into_py(py));
+                request.insert("queries", queries_clone.into_py(py));
                 request.insert("headers", headers.into_py(py));
                 let data = data.into_py(py);
                 request.insert("body", data);

diff --git a/src/request_handler/mod.rs b/src/request_handler/mod.rs
@@ -1,8 +1,9 @@
 use crate::executors::{execute_http_function, execute_middleware_function};
 
-use std::collections::HashMap;
+use std::rc::Rc;
 use std::str::FromStr;
 use std::sync::Arc;
+use std::{cell::RefCell, collections::HashMap};
 
 use actix_web::{web, HttpRequest, HttpResponse, HttpResponseBuilder};
 // pyO3 module
@@ -33,7 +34,7 @@ pub async fn handle_http_request(
     payload: &mut web::Payload,
     req: &HttpRequest,
     route_params: HashMap<String, String>,
-    queries: HashMap<String, String>,
+    queries: Rc<RefCell<HashMap<String, String>>>,
 ) -> HttpResponse {
     let contents = match execute_http_function(
         function,
@@ -93,7 +94,7 @@ pub async fn handle_http_middleware_request(
     payload: &mut web::Payload,
     req: &HttpRequest,
     route_params: HashMap<String, String>,
-    queries: HashMap<String, String>,
+    queries: Rc<RefCell<HashMap<String, String>>>,
 ) -> HashMap<String, HashMap<String, String>> {
     let contents = match execute_middleware_function(
         function,

diff --git a/src/server.rs b/src/server.rs
@@ -8,8 +8,10 @@ use crate::shared_socket::SocketHeld;
 use crate::types::{Headers, PyFunction};
 use crate::web_socket_connection::start_web_socket;
 
+use std::cell::RefCell;
 use std::collections::HashMap;
 use std::convert::TryInto;
+use std::rc::Rc;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::Ordering::{Relaxed, SeqCst};
 use std::sync::{Arc, RwLock};
@@ -311,13 +313,16 @@ async fn index(
 ) -> impl Responder {
     // cloning hashmaps a lot here
     // try reading about arc or rc
-    let mut queries = HashMap::new();
+
+    let mut queries = Rc::new(RefCell::new(HashMap::new()));
 
     if !req.query_string().is_empty() {
         let split = req.query_string().split('&');
         for s in split {
             let params = s.split_once('=').unwrap_or((s, ""));
-            queries.insert(params.0.to_string(), params.1.to_string());
+            queries
+                .borrow_mut()
+                .insert(params.0.to_string(), params.1.to_string());
         }
     }