updated websocket branch

README.md

@@ -56,7 +56,7 @@ See [here](NOTES.md)
 ## License
 
 ```text
-Copyright (c) 2021, 2022 PaulBSD
+Copyright (c) 2021, 2022, 2023 PaulBSD
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

src/ipblc.rs

@@ -18,7 +18,6 @@ use tokio::sync::RwLock;
 pub const PKG_NAME: &str = env!("CARGO_PKG_NAME");
 const BL_CHAN_SIZE: usize = 32;
 const ZMQ_CHAN_SIZE: usize = 64;
-const API_CHAN_SIZE: usize = 64;
 
 pub async fn run() {
     let fqdn = gethostname(true);
@@ -33,33 +32,28 @@ pub async fn run() {
     println!("Launching {}, version {}", PKG_NAME, pkgversion);
     fwinit();
 
-    let (_apitx, mut apirx): (Sender<String>, Receiver<String>) = channel(API_CHAN_SIZE);
+    apiserver(&ctxarc).await.unwrap();
-
-    let ctxclone = Arc::clone(&ctxarc);
-    apiserver(&ctxclone).await.unwrap();
 
     // initialize sockets
     let (ipeventtx, mut ipeventrx): (Sender<IpEvent>, Receiver<IpEvent>) = channel(ZMQ_CHAN_SIZE);
-    let (wspubsubsocket, mut wsreqsocket) = websocketinit(&ctxclone, &ipeventtx).await;
+    let wssocket = websocketinit(&ctxarc, &ipeventtx).await;
 
-    let mut blrx = watchfiles(&ctxclone).await;
+    let mut blrx = watchfiles(&ctxarc).await;
 
     let ctxclone = Arc::clone(&ctxarc);
     tokio::spawn(async move {
         compare_files_changes(&ctxclone, &mut blrx, &ipeventtx).await;
     });
 
-    let ctxclone = Arc::clone(&ctxarc);
+    let bootstrap_event = ctxarc.read().await.cfg.bootstrap_event().clone();
-    let bootstrap_event = ctxclone.read().await.cfg.bootstrap_event().clone();
+
-    send_to_ipbl_websocket(&mut wsreqsocket, &bootstrap_event, &mut ret).await;
+    send_to_ipbl_websocket(&wssocket, &bootstrap_event, &mut ret).await;
 
     loop {
         ret = Vec::new();
 
         // wait for logs parse and zmq channel receive
-        //let mut received_ip = ipdatarx.recv();
         let ipdata_wait = ipeventrx.recv();
-        let apimsg_wait = apirx.recv();
         let force_wait = sleep_ms(200);
 
         let ctxclone = Arc::clone(&ctxarc);
@@ -78,7 +72,7 @@ pub async fn run() {
                             hostname: fqdn.clone(),
                             ipdata: ip_to_send,
                         };
-                        send_to_ipbl_websocket(&mut wsreqsocket, &ipe, &mut ret).await;
+                        send_to_ipbl_websocket(&wssocket, &ipe, &mut ret).await;
                     }
                     continue
                 }
@@ -97,11 +91,10 @@ pub async fn run() {
                             ipdata: ipevent.ipdata,
                         };
                         send_to_ipbl_api(&ctx, &event, &mut ret).await;
-                        send_to_ipbl_websocket(&mut wsreqsocket, &event, &mut ret).await;
+                        send_to_ipbl_websocket(&wssocket, &event, &mut ret).await;
                     }
                 }
             }
-            _val = apimsg_wait => {}
             _val = force_wait => {}
         };
 
@@ -110,35 +103,34 @@ pub async fn run() {
             let mut ctx = ctxarc.write().await;
             ctx.gc_blocklist().await;
             toblock = ctx.get_blocklist_toblock().await;
+
+            // apply firewall blocking
+            match fwblock(&toblock, &mut ret, &mut fwlen) {
+                Ok(_) => {}
+                Err(err) => {
+                    println!("Err: {err}, unable to push firewall rules, use super user")
+                }
+            };
         }
-        // apply firewall blocking
-        match fwblock(&toblock, &mut ret, &mut fwlen) {
-            Ok(_) => {}
-            Err(err) => {
-                println!("Err: {err}, unable to push firewall rules, use super user")
-            }
-        };
 
         // log lines
         if ret.len() > 0 {
             println!("{ret}", ret = ret.join(", "));
         }
 
-        {
+        let now_cfg_reload = Local::now().trunc_subsecs(0);
-            let now_cfg_reload = Local::now().trunc_subsecs(0);
+        if (now_cfg_reload - last_cfg_reload) > Duration::seconds(5) {
-            if (now_cfg_reload - last_cfg_reload) > Duration::seconds(5) {
+            // reload configuration from the server
-                // reload configuration from the server
+            let mut ctx = ctxclone.write().await;
-                let mut ctx = ctxclone.write().await;
+            match ctx.load().await {
-                match ctx.load().await {
+                Ok(_) => {
-                    Ok(_) => {
+                    last_cfg_reload = Local::now().trunc_subsecs(0);
-                        last_cfg_reload = Local::now().trunc_subsecs(0);
-                    }
-                    Err(err) => {
-                        println!("error loading config: {err}");
-                    }
                 }
-            };
+                Err(err) => {
-        }
+                    println!("error loading config: {err}");
+                }
+            }
+        };
     }
 }
 

src/websocket.rs

@@ -1,49 +1,42 @@
 use crate::config::{Context, WebSocketCfg};
 use crate::ip::IpEvent;
 use crate::utils::gethostname;
-use std::net::TcpStream;
-use tungstenite::stream::*;
-use tungstenite::*;
 
+use std::net::TcpStream;
 use std::sync::Arc;
 use tokio::sync::mpsc::Sender;
 use tokio::sync::RwLock;
+use tungstenite::stream::*;
+use tungstenite::*;
 
 pub async fn websocketconnect<'a>(
     wscfg: &WebSocketCfg,
 ) -> Result<WebSocket<MaybeTlsStream<TcpStream>>, Error> {
-    let (socket, response) = connect(&wscfg.endpoint).expect("Can't connect");
+    let (socket, _response) = connect(&wscfg.endpoint).expect("Can't connect");
     Ok(socket)
 }
 
 pub async fn websocketinit(
     ctx: &Arc<RwLock<Context>>,
     ipeventtx: &Sender<IpEvent>,
-) -> (
+) -> Arc<RwLock<WebSocket<MaybeTlsStream<TcpStream>>>> {
-    Arc<RwLock<WebSocket<MaybeTlsStream<TcpStream>>>>,
-    WebSocket<MaybeTlsStream<TcpStream>>,
-) {
     let ctxarc = Arc::clone(&ctx);
 
-    let wsreqsocket;
+    let wssocket;
-    let wssubsocket;
+    let wssocketcb;
-    let wssubsocketcb;
     {
         let ctx = ctxarc.read().await;
-        wsreqsocket = websocketconnect(&ctx.cfg.ws.get("reqrep").unwrap())
+        wssocket = Arc::new(RwLock::new(
-            .await
+            websocketconnect(&ctx.cfg.ws.get("websocket").unwrap())
-            .unwrap();
-        wssubsocket = Arc::new(RwLock::new(
-            websocketconnect(&ctx.cfg.ws.get("pubsub").unwrap())
                 .await
                 .unwrap(),
         ));
 
-        wssubsocketcb = wssubsocket.clone();
+        wssocketcb = wssocket.clone();
     }
 
-    wslistenpubsub(wssubsocket, ipeventtx.clone()).await;
+    wslistenpubsub(wssocket, ipeventtx.clone()).await;
-    return (wssubsocketcb, wsreqsocket);
+    return wssocketcb;
 }
 
 async fn wslistenpubsub(
@@ -83,18 +76,22 @@ async fn wslistenpubsub(
 }
 
 pub async fn send_to_ipbl_websocket(
-    reqsocket: &mut WebSocket<MaybeTlsStream<TcpStream>>,
+    wssocket: &Arc<RwLock<WebSocket<MaybeTlsStream<TcpStream>>>>,
     ip: &IpEvent,
     _ret: &mut Vec<String>,
 ) {
     let msg = format!("{val}", val = serde_json::to_string(&ip).unwrap());
-    match reqsocket.write_message(Message::Text(msg)) {
+
+    let wsclone = Arc::clone(wssocket);
+    let mut ws = wsclone.write().await;
+
+    match ws.write_message(Message::Text(msg)) {
         Ok(_) => {}
         Err(e) => {
             println!("{e:?}")
         }
     };
-    match reqsocket.read_message() {
+    match ws.read_message() {
         Ok(o) => {
             println!("{o}")
         }