unshell-nodes-rs/unshell-rs-lib/src/networkers/server.rs

use std::{sync::Arc, thread};

use crate::{
    layers::{LayerConfig, create_server_builder},
    networkers::{Connection, ServerTrait},
};

#[allow(dead_code)]
pub fn run_listener_state<S, C, R, A>(
    server: S,
    layers: Vec<LayerConfig>,
    on_connect_callback: R,
    state: Arc<A>,
)
/*-> Arc<Mutex<Vec<C>>>*/
where
    S: ServerTrait<C> + Sync + Send + 'static,
    C: Connection + 'static,
    R: Fn(Box<dyn Connection + Send + 'static>, Arc<A>) + Sync + Send + 'static,
    A: Sync + Send + 'static,
{
    thread::spawn(move || {
        let layer_builder = create_server_builder::<C>(layers).unwrap();
        info!("Started listener {}", server.get_info());
        loop {
            match server.accept() {
                Ok(conn) => match layer_builder(conn) {
                    Ok(conn) => {
                        info!("New connection ({})", conn.get_info());
                        on_connect_callback(conn, Arc::clone(&state));
                    }
                    Err(e) => {
                        error!("Failed to create layers: {:?}", e);
                    }
                },

                Err(e) => {
                    error!("Failed to accept connection: {:?}", e);
                }
            }
        }
    });
}

#[allow(dead_code)]
pub fn run_listener<S, C, R>(server: S, layers: Vec<LayerConfig>, on_connect_callback: R)
/*-> Arc<Mutex<Vec<C>>>*/
where
    S: ServerTrait<C> + Sync + Send + 'static,
    C: Connection + 'static,
    R: Fn(Box<dyn Connection + Send + 'static>) + Sync + Send + 'static,
{
    // let clients: Arc<Mutex<Vec<C>>> = Arc::new(Mutex::new(Vec::new()));
    // let clients_clone = Arc::clone(&clients);

    thread::spawn(move || {
        let layer_builder = create_server_builder::<C>(layers).unwrap();

        info!("Started listener {}", server.get_info());
        loop {
            match server.accept() {
                Ok(conn) => match layer_builder(conn) {
                    Ok(conn) => {
                        let con_info = conn.get_info();
                        info!("New connection ({})", con_info);
                        on_connect_callback(conn);
                    }
                    Err(e) => {
                        error!("Failed to create layers: {:?}", e);
                    }
                },
                Err(e) => {
                    error!("Failed to accept connection: {:?}", e);
                }
            }
        }
    });
}