Extract is_concurrent_handlers_limit_reached to server utils

src/foldend/handler_server/endpoints/register_endpoint.rs

@@ -2,6 +2,7 @@ use tokio::sync::RwLockWriteGuard;
 
 use super::super::server::Server;
 use super::handler_service_endpoint::ServiceEndpoint;
+use crate::handler_server::utils::is_concurrent_handlers_limit_reached;
 use crate::{handler_mapping::HandlerMapping, mapping::Mapping};
 use generated_types::{HandlerStateResponse, RegisterToDirectoryRequest};
 
@@ -69,10 +70,10 @@ impl ServiceEndpoint<Request, Response> for RegisterEndpoint<'_> {
                 String::new(),
             );
             if request.is_start_on_register {
-                if self
-                    .server
-                    .is_concurrent_handlers_limit_reached(&self.mapping)
-                {
+                if is_concurrent_handlers_limit_reached(
+                    &self.mapping,
+                    self.server.config.concurrent_threads_limit,
+                ) {
                     self.mapping
                         .directory_mapping
                         .insert(request.directory_path, handler_mapping);

src/foldend/handler_server/endpoints/start_handler_endpoint.rs

@@ -4,6 +4,7 @@ use tokio::sync::RwLockWriteGuard;
 
 use super::super::server::Server;
 use super::handler_service_endpoint::ServiceEndpoint;
+use crate::handler_server::utils::is_concurrent_handlers_limit_reached;
 use crate::mapping::Mapping;
 use generated_types::{HandlerStateResponse, HandlerStatesMapResponse, StartHandlerRequest};
 
@@ -44,9 +45,10 @@ impl ServiceEndpoint<Request, Response> for StartHandlerEndpoint<'_> {
         {
             Some(handler_mapping) => {
                 if !handler_mapping.is_alive()
-                    && self
-                        .server
-                        .is_concurrent_handlers_limit_reached(&self.mapping)
+                    && is_concurrent_handlers_limit_reached(
+                        &self.mapping,
+                        self.server.config.concurrent_threads_limit,
+                    )
                 {
                     return Err(tonic::Status::failed_precondition(format!(
                         "Aborted start handler - Reached concurrent live handler limit ({})",

src/foldend/handler_server/mod.rs

@@ -1,3 +1,4 @@
 mod endpoints;
 mod handler_service;
 pub mod server;
+mod utils;

src/foldend/handler_server/server.rs

@@ -1,4 +1,4 @@
-use std::{ops::Deref, sync::Arc};
+use std::sync::Arc;
 
 use tokio::sync::{broadcast, RwLock, RwLockReadGuard};
 
@@ -16,23 +16,6 @@ pub struct Server {
 }
 
 impl Server {
-    pub fn is_concurrent_handlers_limit_reached<T>(&self, mapping: &T) -> bool
-    where
-        T: Deref<Target = Mapping>,
-    {
-        let mut live_handlers_count: u8 = 0;
-        if live_handlers_count >= self.config.concurrent_threads_limit {
-            return true;
-        }
-        for _ in mapping.iter_live_handlers() {
-            live_handlers_count += 1;
-            if live_handlers_count >= self.config.concurrent_threads_limit {
-                return true;
-            }
-        }
-        false
-    }
-
     pub fn convert_trace_channel_reciever_to_stream(
         &self,
     ) -> trace_handler_stream::TraceHandlerStream {

src/foldend/handler_server/utils.rs

@@ -0,0 +1,18 @@
+use crate::mapping::Mapping;
+
+pub fn is_concurrent_handlers_limit_reached(
+    mapping: &Mapping,
+    concurrent_threads_limit: u8,
+) -> bool {
+    let mut live_handlers_count: u8 = 0;
+    if live_handlers_count >= concurrent_threads_limit {
+        return true;
+    }
+    for _ in mapping.iter_live_handlers() {
+        live_handlers_count += 1;
+        if live_handlers_count >= concurrent_threads_limit {
+            return true;
+        }
+    }
+    false
+}