Paul Lecuq
ee5119c512
Some checks reported errors
continuous-integration/drone/push Build encountered an error
105 lines
3.0 KiB
Rust
105 lines
3.0 KiB
Rust
use crate::config::{Context, ZMQ};
|
|
use crate::ip::IpData;
|
|
use crate::utils::gethostname;
|
|
|
|
use std::sync::Arc;
|
|
use tokio::sync::mpsc::Sender;
|
|
use tokio::sync::RwLock;
|
|
|
|
const ZMQPROTO: &str = "tcp";
|
|
|
|
pub async fn zconnect<'a>(
|
|
zmqcfg: &ZMQ,
|
|
zmqtype: zmq::SocketType,
|
|
) -> Result<zmq::Socket, zmq::Error> {
|
|
let zctx = zmq::Context::new();
|
|
let zmqhost = &zmqcfg.hostname;
|
|
let zmqport = &zmqcfg.port;
|
|
let socket = zctx.socket(zmqtype).unwrap();
|
|
let connectstring = format!("{ZMQPROTO}://{zmqhost}:{zmqport}");
|
|
socket.connect(&connectstring.as_str())?;
|
|
Ok(socket)
|
|
}
|
|
|
|
pub async fn zmqinit(ctx: &Arc<RwLock<Context>>, ipdatatx: &Sender<IpData>) -> zmq::Socket {
|
|
let ctxarc = Arc::clone(&ctx);
|
|
|
|
let zmqreqsocket;
|
|
let zmqsubsocket;
|
|
{
|
|
let zmqctx = ctxarc.read().await;
|
|
zmqreqsocket = zconnect(&zmqctx.cfg.zmq.get("reqrep").unwrap(), zmq::REQ)
|
|
.await
|
|
.unwrap();
|
|
zmqsubsocket = zconnect(&zmqctx.cfg.zmq.get("pubsub").unwrap(), zmq::SUB)
|
|
.await
|
|
.unwrap();
|
|
}
|
|
|
|
listenpubsub(&ctx, ipdatatx.clone(), zmqsubsocket).await;
|
|
return zmqreqsocket;
|
|
}
|
|
|
|
async fn listenpubsub(ctx: &Arc<RwLock<Context>>, txpubsub: Sender<IpData>, socket: zmq::Socket) {
|
|
let prefix;
|
|
{
|
|
let ctx = ctx.read().await;
|
|
prefix = format!(
|
|
"{sub} ",
|
|
sub = ctx.cfg.zmq.get("pubsub").unwrap().subscription
|
|
);
|
|
socket
|
|
.set_subscribe(ctx.cfg.zmq.get("pubsub").unwrap().subscription.as_bytes())
|
|
.expect("failed setting subscription");
|
|
}
|
|
|
|
tokio::spawn(async move {
|
|
loop {
|
|
let msgs: Option<String> = match socket.recv_string(0) {
|
|
Ok(s) => match s {
|
|
Ok(ss) => Some(ss),
|
|
Err(e) => {
|
|
println!("{e:?}");
|
|
None
|
|
}
|
|
},
|
|
Err(e) => {
|
|
println!("{e:?}");
|
|
None
|
|
}
|
|
};
|
|
match msgs {
|
|
Some(ss) => {
|
|
let msg = ss.strip_prefix(prefix.as_str()).unwrap();
|
|
let tosend: IpData = serde_json::from_str(msg).unwrap();
|
|
if tosend.hostname != gethostname(true) || tosend.mode == "init".to_string() {
|
|
txpubsub.send(tosend).await.unwrap();
|
|
}
|
|
}
|
|
None => {}
|
|
};
|
|
}
|
|
});
|
|
}
|
|
|
|
pub async fn send_to_ipbl_zmq(reqsocket: &zmq::Socket, ip: &IpData) {
|
|
let msg = format!("{val}", val = serde_json::to_string(&ip).unwrap());
|
|
match reqsocket.send(&msg, 0) {
|
|
Ok(_) => {}
|
|
Err(e) => {
|
|
println!("{e:?}")
|
|
}
|
|
};
|
|
match reqsocket.recv_string(0) {
|
|
Ok(o) => match o {
|
|
Ok(_) => {}
|
|
Err(ee) => {
|
|
println!("{ee:?}")
|
|
}
|
|
},
|
|
Err(e) => {
|
|
println!("{e:?}")
|
|
}
|
|
};
|
|
}
|