wip fix gil issue on server.rs

Author: VishnuSanal

src/server.rs

@@ -16,6 +16,7 @@ use crate::types::HttpMethod;
 use crate::types::MiddlewareReturn;
 use crate::websockets::start_web_socket;
 
+use core::task;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::Ordering::{Relaxed, SeqCst};
 use std::sync::{Arc, RwLock};
@@ -29,7 +30,7 @@ use actix_web::*;
 
 // pyO3 module
 use log::{debug, error};
-use pyo3::exceptions::PyValueError;
+use pyo3::exceptions::{asyncio, PyValueError};
 use pyo3::prelude::*;
 use pyo3::pycell::PyRef;
 
@@ -78,12 +79,7 @@ impl Server {
         }
     }
 
-    pub fn start(
-        &mut self,
-        py: Python,
-        socket: PyRef<SocketHeld>,
-        workers: usize,
-    ) -> PyResult<()> {
+    pub fn start(&mut self, py: Python, socket: PyRef<SocketHeld>, workers: usize) -> PyResult<()> {
         pyo3_log::init();
 
         if STARTED
@@ -113,8 +109,7 @@ impl Server {
 
         let excluded_response_headers_paths = self.excluded_response_headers_paths.clone();
 
-        let task_locals = pyo3_async_runtimes::TaskLocals::new(event_loop).copy_context(py)?;
-        let task_locals_copy = task_locals.clone_ref(py);
+        let task_locals_new = pyo3_async_runtimes::TaskLocals::new(event_loop).copy_context(py)?;
 
         let max_payload_size = env::var(MAX_PAYLOAD_SIZE)
             .unwrap_or(DEFAULT_MAX_PAYLOAD_SIZE.to_string())
@@ -129,14 +124,15 @@ impl Server {
         thread::spawn(move || {
             actix_web::rt::System::new().block_on(async move {
                 debug!("The number of workers is {}", workers);
-                execute_startup_handler(startup_handler, &task_locals_copy)
+                execute_startup_handler(startup_handler, &task_locals_new)
                     .await
                     .unwrap();
 
                 HttpServer::new(move || {
                     let mut app = App::new();
 
-                    let task_locals = task_locals_copy.clone_ref(py);
+                    // let task_locals = pyo3_async_runtimes::tokio::get_current_locals(py).expect("Failed to get Python task locals");
+                    // let task_locals: pyo3_async_runtimes::TaskLocals = asyncio.call_method0("get_running_loop");
                     let directories = directories.read().unwrap();
 
                     // this loop matches three types of directory serving
@@ -170,25 +166,32 @@ impl Server {
                         .app_data(web::Data::new(global_response_headers.clone()))
                         .app_data(web::Data::new(excluded_response_headers_paths.clone()));
 
-                    let web_socket_map = web_socket_router.get_web_socket_map();
-                    for (elem, value) in (web_socket_map.read()).iter() {
-                        let endpoint = elem.clone();
-                        let path_params = value.clone();
-                        let task_locals = task_locals.clone_ref(py);
-                        app = app.route(
-                            &endpoint.clone(),
-                            web::get().to(move |stream: web::Payload, req: HttpRequest| {
-                                let endpoint_copy = endpoint.clone();
-                                start_web_socket(
-                                    req,
-                                    stream,
-                                    path_params.clone(),
-                                    task_locals.clone_ref(py),
-                                    endpoint_copy,
-                                )
-                            }),
-                        );
-                    }
+                    Python::with_gil(|py| {
+                        let task_locals = pyo3_async_runtimes::tokio::get_current_locals(py)
+                            .expect("Failed to get Python task locals");
+
+                        let web_socket_map = web_socket_router.get_web_socket_map();
+                        for (elem, value) in (web_socket_map.read()).iter() {
+                            let endpoint = elem.clone();
+                            let path_params = value.clone();
+                            let task_locals = task_locals.clone_ref(py);
+                            app = app.route(
+                                &endpoint.clone(),
+                                web::get().to(move |stream: web::Payload, req: HttpRequest| {
+                                    let endpoint_copy = endpoint.clone();
+                                    start_web_socket(
+                                        req,
+                                        stream,
+                                        path_params.clone(),
+                                        task_locals.clone_ref(py),
+                                        endpoint_copy,
+                                    )
+                                }),
+                            );
+                        }
+
+                        Ok(())
+                    });
 
                     debug!("Max payload size is {}", max_payload_size);
 
@@ -202,19 +205,25 @@ impl Server {
                                   global_response_headers,
                                   response_headers_exclude_paths,
                                   req| {
-                                pyo3_async_runtimes::tokio::scope_local(task_locals.clone_ref(py), async move {
-                                    index(
-                                        router,
-                                        payload,
-                                        const_router,
-                                        middleware_router,
-                                        global_request_headers,
-                                        global_response_headers,
-                                        response_headers_exclude_paths,
-                                        req,
-                                    )
-                                    .await
-                                })
+                                Python::with_gil(|py| {
+                                    pyo3_async_runtimes::tokio::scope_local(
+                                        task_locals.clone_ref(py),
+                                        async move {
+                                            index(
+                                                router,
+                                                payload,
+                                                const_router,
+                                                middleware_router,
+                                                global_request_headers,
+                                                global_response_headers,
+                                                response_headers_exclude_paths,
+                                                req,
+                                            )
+                                            .await
+                                        },
+                                    );
+                                    Ok(())
+                                });
                             },
                         ))
                 })
@@ -250,6 +259,9 @@ impl Server {
                 if function.is_async {
                     debug!("Shutdown event handler async");
 
+                    let task_locals = pyo3_async_runtimes::tokio::get_current_locals(py)
+                        .expect("Failed to get Python task locals");
+
                     pyo3_async_runtimes::tokio::run_until_complete(
                         task_locals.event_loop(py),
                         pyo3_async_runtimes::into_future_with_locals(