lynn_tcp 1.0.1

Lightweight Tcp framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

use input_dto::{IHandlerCombinedTrait, MsgSelect};
use std::{collections::HashMap, net::SocketAddr, sync::Arc};
use tokio::sync::{RwLock, Semaphore};
use tracing::{debug, warn};

use crate::{
    app::{lynn_user_api::LynnUser, AsyncFunc, TaskBody},
    vo_factory::input_vo::InputBufVO,
};

mod msg_select;
mod router_handler;

type ClientsStructType = Arc<RwLock<HashMap<SocketAddr, LynnUser>>>;

pub mod input_dto {
    pub(crate) use super::msg_select::*;
    pub(crate) use super::router_handler::check_handler_result;
    pub(crate) use super::router_handler::HandlerData;
    pub use super::router_handler::HandlerResult;
    pub(crate) use super::router_handler::IHandlerCombinedTrait;
}

pub(crate) async fn input_dto_build(
    addr: SocketAddr,
    input_buf: InputBufVO,
    process_permit: Arc<Semaphore>,
    clients: ClientsStructType,
    handler_method: Arc<AsyncFunc>,
    thread_pool: TaskBody,
) {
    tokio::spawn(async move {
        // Attempt to acquire a permit from the semaphore.
        let result_permit = process_permit.try_acquire();
        match result_permit {
            Ok(permit) => {
                // If the permit is acquired successfully, create a new `MsgSelect` instance and spawn a handler task.
                let result = MsgSelect::new(addr, input_buf);
                spawn_handler(result, clients, handler_method, thread_pool).await;
                // Release the permit after the handler task is completed.
                drop(permit);
            }
            Err(_) => {
                // If the permit cannot be acquired, log a warning.
                warn!("addr:{} PROCESS_PERMIT_SIZE is full", addr)
            }
        }
    });
}

async fn spawn_handler(
    mut result: MsgSelect,
    clients: ClientsStructType,
    handler_method: Arc<AsyncFunc>,
    thread_pool: TaskBody,
) {
    result.execute(clients, handler_method, thread_pool).await;
}