split server configuration

src/server/handlers.rs

@@ -0,0 +1,8 @@
+// src/server/handlers.rs
+pub mod adresar_service;
+pub mod uctovnictvo_service;
+pub mod table_structure_service;
+
+pub use adresar_service::AdresarService;
+pub use uctovnictvo_service::UctovnictvoService;
+pub use table_structure_service::TableStructureHandler;

src/server/mod.rs

@@ -1,178 +1,7 @@
 // src/server/mod.rs
-use crate::table_structure::handlers;
-use tonic::{Request, Response, Status};
-use tonic_reflection::server::Builder as ReflectionBuilder;
-use crate::adresar::handlers::{
-    post_adresar, get_adresar, put_adresar, delete_adresar, get_adresar_count, get_adresar_by_position,
-};
-use crate::uctovnictvo::handlers::{
-    post_uctovnictvo, get_uctovnictvo, get_uctovnictvo_count, get_uctovnictvo_by_position,
-    put_uctovnictvo,
-};
-use crate::proto::multieko2::{
-    common::{Empty, CountResponse, PositionRequest},
-    table_structure::{TableStructureResponse, TableColumn},
-    FILE_DESCRIPTOR_SET,
-};
-use crate::proto::multieko2::adresar::{
-    adresar_server::{Adresar, AdresarServer},
-    PostAdresarRequest, AdresarResponse, GetAdresarRequest, PutAdresarRequest,
-    DeleteAdresarRequest, DeleteAdresarResponse,
-};
-use crate::proto::multieko2::uctovnictvo::{
-    uctovnictvo_server::{Uctovnictvo, UctovnictvoServer},
-    PostUctovnictvoRequest, UctovnictvoResponse, GetUctovnictvoRequest, PutUctovnictvoRequest,
-};
-use crate::proto::multieko2::table_structure::table_structure_service_server::{
-    TableStructureService, TableStructureServiceServer,
-};
-pub struct AdresarService {
-    db_pool: sqlx::PgPool,
-}
+pub mod services;
+pub mod handlers;
+pub mod run;
 
-pub struct UctovnictvoService {
-    db_pool: sqlx::PgPool,
-}
-
-pub struct TableStructureHandler {
-    db_pool: sqlx::PgPool
-}
-
-#[tonic::async_trait]
-impl Adresar for AdresarService {
-    async fn post_adresar(
-        &self,
-        request: Request<PostAdresarRequest>,
-    ) -> Result<Response<AdresarResponse>, Status> {
-        let response = post_adresar(&self.db_pool, request.into_inner()).await?;
-        Ok(Response::new(response))
-    }
-
-    async fn get_adresar(
-        &self,
-        request: Request<GetAdresarRequest>,
-    ) -> Result<Response<AdresarResponse>, Status> {
-        let response = get_adresar(&self.db_pool, request.into_inner()).await?;
-        Ok(Response::new(response))
-    }
-
-    async fn put_adresar(
-        &self,
-        request: Request<PutAdresarRequest>,
-    ) -> Result<Response<AdresarResponse>, Status> {
-        let response = put_adresar(&self.db_pool, request.into_inner()).await?;
-        Ok(Response::new(response))
-    }
-
-    async fn delete_adresar(
-        &self,
-        request: Request<DeleteAdresarRequest>,
-    ) -> Result<Response<DeleteAdresarResponse>, Status> {
-        let response = delete_adresar(&self.db_pool, request.into_inner()).await?;
-        Ok(Response::new(response))
-    }
-
-    async fn get_adresar_count(
-        &self,
-        request: Request<Empty>,
-    ) -> Result<Response<CountResponse>, Status> {
-        let response = get_adresar_count(&self.db_pool, request.into_inner()).await?;
-        Ok(Response::new(response))
-    }
-
-    async fn get_adresar_by_position(
-        &self,
-        request: Request<PositionRequest>,
-    ) -> Result<Response<AdresarResponse>, Status> {
-        let response = get_adresar_by_position(&self.db_pool, request.into_inner()).await?;
-        Ok(Response::new(response))
-    }
-}
-
-#[tonic::async_trait]
-impl Uctovnictvo for UctovnictvoService {
-    async fn post_uctovnictvo(
-        &self,
-        request: Request<PostUctovnictvoRequest>,
-    ) -> Result<Response<UctovnictvoResponse>, Status> {
-        let response = post_uctovnictvo(&self.db_pool, request.into_inner()).await?;
-        Ok(Response::new(response))
-    }
-
-    async fn get_uctovnictvo(
-        &self,
-        request: Request<GetUctovnictvoRequest>,
-    ) -> Result<Response<UctovnictvoResponse>, Status> {
-        let response = get_uctovnictvo(&self.db_pool, request.into_inner()).await?;
-        Ok(Response::new(response))
-    }
-
-    async fn get_uctovnictvo_count(
-        &self,
-        request: Request<Empty>,
-    ) -> Result<Response<CountResponse>, Status> {
-        let response = get_uctovnictvo_count(&self.db_pool, request.into_inner()).await?;
-        Ok(Response::new(response))
-    }
-
-    async fn get_uctovnictvo_by_position(
-        &self,
-        request: Request<PositionRequest>,
-    ) -> Result<Response<UctovnictvoResponse>, Status> {
-        let response = get_uctovnictvo_by_position(&self.db_pool, request.into_inner()).await?;
-        Ok(Response::new(response))
-    }
-
-    async fn put_uctovnictvo(
-        &self,
-        request: Request<PutUctovnictvoRequest>,
-    ) -> Result<Response<UctovnictvoResponse>, Status> {
-        let response = put_uctovnictvo(&self.db_pool, request.into_inner()).await?;
-        Ok(Response::new(response))
-    }
-}
-
-#[tonic::async_trait]
-impl TableStructureService for TableStructureHandler {
-    async fn get_adresar_table_structure(
-        &self,
-        request: Request<crate::proto::multieko2::common::Empty>,
-    ) -> Result<Response<TableStructureResponse>, Status> {
-        let response = handlers::get_adresar_table_structure(&self.db_pool, request.into_inner())
-            .await?;
-        Ok(Response::new(response))
-    }
-
-    async fn get_uctovnictvo_table_structure(
-        &self,
-        request: Request<crate::proto::multieko2::common::Empty>,
-    ) -> Result<Response<TableStructureResponse>, Status> {
-        let response =
-            handlers::get_uctovnictvo_table_structure(&self.db_pool, request.into_inner()).await?;
-        Ok(Response::new(response))
-    }
-}
-
-pub async fn run_server(db_pool: sqlx::PgPool) -> Result<(), Box<dyn std::error::Error>> {
-    let addr = "[::1]:50051".parse()?;
-    let adresar_service = AdresarService { db_pool: db_pool.clone() };
-    let uctovnictvo_service = UctovnictvoService { db_pool: db_pool.clone() };
-    let table_structure_service = TableStructureHandler { db_pool: db_pool.clone() };
-
-    println!("Server listening on {}", addr);
-
-    let reflection_service = ReflectionBuilder::configure()
-        .register_encoded_file_descriptor_set(FILE_DESCRIPTOR_SET)
-        .build_v1()
-        .unwrap();
-
-    tonic::transport::Server::builder()
-        .add_service(AdresarServer::new(adresar_service))
-        .add_service(UctovnictvoServer::new(uctovnictvo_service))
-        .add_service(TableStructureServiceServer::new(table_structure_service))
-        .add_service(reflection_service)
-        .serve(addr)
-        .await?;
-
-    Ok(())
-}
+pub use run::run_server;
+pub use services::*;

src/server/run.rs

@@ -0,0 +1,33 @@
+// src/server/run.rs
+use tonic::transport::Server;
+use tonic_reflection::server::Builder as ReflectionBuilder;
+
+use crate::proto::multieko2::FILE_DESCRIPTOR_SET;
+use crate::server::services::{
+    AdresarService, 
+    UctovnictvoService, 
+    TableStructureHandler
+};
+use crate::server::{
+    AdresarServer,
+    UctovnictvoServer,
+    TableStructureServiceServer
+};
+
+pub async fn run_server(db_pool: sqlx::PgPool) -> Result<(), Box<dyn std::error::Error>> {
+    let addr = "[::1]:50051".parse()?;
+
+    let reflection_service = ReflectionBuilder::configure()
+        .register_encoded_file_descriptor_set(FILE_DESCRIPTOR_SET)
+        .build_v1()?;
+
+    Server::builder()
+        .add_service(AdresarServer::new(AdresarService { db_pool: db_pool.clone() }))
+        .add_service(UctovnictvoServer::new(UctovnictvoService { db_pool: db_pool.clone() }))
+        .add_service(TableStructureServiceServer::new(TableStructureHandler { db_pool }))
+        .add_service(reflection_service)
+        .serve(addr)
+        .await?;
+
+    Ok(())
+}

src/server/services/adresar_service.rs

@@ -0,0 +1,65 @@
+// src/server/services/adresar_service.rs
+use tonic::{Request, Response, Status};
+use crate::proto::multieko2::adresar::{
+    adresar_server::{Adresar, AdresarServer},
+    PostAdresarRequest, AdresarResponse, GetAdresarRequest, PutAdresarRequest,
+    DeleteAdresarRequest, DeleteAdresarResponse,
+};
+use crate::adresar::handlers;
+use sqlx::PgPool;
+
+#[derive(Debug)]
+pub struct AdresarService {
+    pub db_pool: PgPool,
+}
+
+#[tonic::async_trait]
+impl Adresar for AdresarService {
+    async fn post_adresar(
+        &self,
+        request: Request<PostAdresarRequest>,
+    ) -> Result<Response<AdresarResponse>, Status> {
+        let response = post_adresar(&self.db_pool, request.into_inner()).await?;
+        Ok(Response::new(response))
+    }
+
+    async fn get_adresar(
+        &self,
+        request: Request<GetAdresarRequest>,
+    ) -> Result<Response<AdresarResponse>, Status> {
+        let response = get_adresar(&self.db_pool, request.into_inner()).await?;
+        Ok(Response::new(response))
+    }
+
+    async fn put_adresar(
+        &self,
+        request: Request<PutAdresarRequest>,
+    ) -> Result<Response<AdresarResponse>, Status> {
+        let response = put_adresar(&self.db_pool, request.into_inner()).await?;
+        Ok(Response::new(response))
+    }
+
+    async fn delete_adresar(
+        &self,
+        request: Request<DeleteAdresarRequest>,
+    ) -> Result<Response<DeleteAdresarResponse>, Status> {
+        let response = delete_adresar(&self.db_pool, request.into_inner()).await?;
+        Ok(Response::new(response))
+    }
+
+    async fn get_adresar_count(
+        &self,
+        request: Request<Empty>,
+    ) -> Result<Response<CountResponse>, Status> {
+        let response = get_adresar_count(&self.db_pool, request.into_inner()).await?;
+        Ok(Response::new(response))
+    }
+
+    async fn get_adresar_by_position(
+        &self,
+        request: Request<PositionRequest>,
+    ) -> Result<Response<AdresarResponse>, Status> {
+        let response = get_adresar_by_position(&self.db_pool, request.into_inner()).await?;
+        Ok(Response::new(response))
+    }
+}

src/server/services/table_structure_service.rs

@@ -0,0 +1,33 @@
+// src/server/services/table_structure_service.rs
+use tonic::{Request, Response, Status};
+use crate::proto::multieko2::table_structure::table_structure_service_server::{
+    TableStructureService, TableStructureServiceServer,
+};
+use crate::table_structure::handlers;
+use sqlx::PgPool;
+
+#[derive(Debug)]
+pub struct TableStructureHandler {
+    pub db_pool: PgPool,
+}
+
+#[tonic::async_trait]
+impl TableStructureService for TableStructureHandler {
+    async fn get_adresar_table_structure(
+        &self,
+        request: Request<crate::proto::multieko2::common::Empty>,
+    ) -> Result<Response<TableStructureResponse>, Status> {
+        let response = handlers::get_adresar_table_structure(&self.db_pool, request.into_inner())
+            .await?;
+        Ok(Response::new(response))
+    }
+
+    async fn get_uctovnictvo_table_structure(
+        &self,
+        request: Request<crate::proto::multieko2::common::Empty>,
+    ) -> Result<Response<TableStructureResponse>, Status> {
+        let response =
+            handlers::get_uctovnictvo_table_structure(&self.db_pool, request.into_inner()).await?;
+        Ok(Response::new(response))
+    }
+}

src/server/services/uctovnictvo_service.rs

@@ -0,0 +1,56 @@
+// src/server/services/uctovnictvo_service.rs
+use tonic::{Request, Response, Status};
+use crate::proto::multieko2::uctovnictvo::{
+    uctovnictvo_server::{Uctovnictvo, UctovnictvoServer},
+    PostUctovnictvoRequest, UctovnictvoResponse, GetUctovnictvoRequest, PutUctovnictvoRequest,
+};
+use crate::uctovnictvo::handlers;
+use sqlx::PgPool;
+
+#[derive(Debug)]
+pub struct UctovnictvoService {
+    pub db_pool: PgPool,
+}
+
+#[tonic::async_trait]
+impl Uctovnictvo for UctovnictvoService {
+    async fn post_uctovnictvo(
+        &self,
+        request: Request<PostUctovnictvoRequest>,
+    ) -> Result<Response<UctovnictvoResponse>, Status> {
+        let response = post_uctovnictvo(&self.db_pool, request.into_inner()).await?;
+        Ok(Response::new(response))
+    }
+
+    async fn get_uctovnictvo(
+        &self,
+        request: Request<GetUctovnictvoRequest>,
+    ) -> Result<Response<UctovnictvoResponse>, Status> {
+        let response = get_uctovnictvo(&self.db_pool, request.into_inner()).await?;
+        Ok(Response::new(response))
+    }
+
+    async fn get_uctovnictvo_count(
+        &self,
+        request: Request<Empty>,
+    ) -> Result<Response<CountResponse>, Status> {
+        let response = get_uctovnictvo_count(&self.db_pool, request.into_inner()).await?;
+        Ok(Response::new(response))
+    }
+
+    async fn get_uctovnictvo_by_position(
+        &self,
+        request: Request<PositionRequest>,
+    ) -> Result<Response<UctovnictvoResponse>, Status> {
+        let response = get_uctovnictvo_by_position(&self.db_pool, request.into_inner()).await?;
+        Ok(Response::new(response))
+    }
+
+    async fn put_uctovnictvo(
+        &self,
+        request: Request<PutUctovnictvoRequest>,
+    ) -> Result<Response<UctovnictvoResponse>, Status> {
+        let response = put_uctovnictvo(&self.db_pool, request.into_inner()).await?;
+        Ok(Response::new(response))
+    }
+}