use std::collections::HashMap; use std::net::SocketAddr; use std::sync::atomic::{self, AtomicBool, AtomicU32}; use std::sync::{Arc, Mutex}; use log::{debug, error, trace}; use tokio::net::TcpStream; use tokio::sync::{mpsc, oneshot, watch}; use tokio_util::compat::*; use futures::io::AsyncReadExt; use async_trait::async_trait; use kuska_handshake::async_std::{handshake_client, BoxStream}; use crate::endpoint::*; use crate::error::*; use crate::netapp::*; use crate::proto::*; use crate::util::*; pub(crate) struct ClientConn { pub(crate) remote_addr: SocketAddr, pub(crate) peer_id: NodeID, query_send: mpsc::UnboundedSender)>>, next_query_number: AtomicU32, inflight: Mutex>>>, must_exit: AtomicBool, stop_recv_loop: watch::Sender, } impl ClientConn { pub(crate) async fn init( netapp: Arc, socket: TcpStream, peer_id: NodeID, ) -> Result<(), Error> { let remote_addr = socket.peer_addr()?; let mut socket = socket.compat(); let handshake = handshake_client( &mut socket, netapp.netid.clone(), netapp.id, netapp.privkey.clone(), peer_id, ) .await?; debug!( "Handshake complete (client) with {}@{}", hex::encode(&peer_id), remote_addr ); let (read, write) = socket.split(); let (read, write) = BoxStream::from_handshake(read, write, handshake, 0x8000).split_read_write(); let (query_send, query_recv) = mpsc::unbounded_channel(); let (stop_recv_loop, stop_recv_loop_recv) = watch::channel(false); let conn = Arc::new(ClientConn { remote_addr, peer_id, next_query_number: AtomicU32::from(RequestID::default()), query_send, inflight: Mutex::new(HashMap::new()), must_exit: AtomicBool::new(false), stop_recv_loop, }); netapp.connected_as_client(peer_id, conn.clone()); tokio::spawn(async move { let conn2 = conn.clone(); let conn3 = conn.clone(); tokio::try_join!(conn2.send_loop(query_recv, write), async move { tokio::select!( r = conn3.recv_loop(read) => r, _ = await_exit(stop_recv_loop_recv) => Ok(()), ) }) .map(|_| ()) .log_err("ClientConn send_loop/recv_loop/dispatch_loop"); netapp.disconnected_as_client(&peer_id, conn); }); Ok(()) } pub fn close(&self) { self.must_exit.store(true, atomic::Ordering::SeqCst); self.query_send .send(None) .log_err("could not write None in query_send"); if self.inflight.lock().unwrap().is_empty() { self.stop_recv_loop .send(true) .log_err("could not write true to stop_recv_loop"); } } pub(crate) async fn call( self: Arc, rq: T, path: &str, prio: RequestPriority, ) -> Result<::Response, Error> where T: Message, { let id = self .next_query_number .fetch_add(1, atomic::Ordering::Relaxed); let mut bytes = vec![prio, path.as_bytes().len() as u8]; bytes.extend_from_slice(path.as_bytes()); bytes.extend_from_slice(&rmp_to_vec_all_named(&rq)?[..]); let (resp_send, resp_recv) = oneshot::channel(); let old = self.inflight.lock().unwrap().insert(id, resp_send); if let Some(old_ch) = old { error!( "Too many inflight requests! RequestID collision. Interrupting previous request." ); if old_ch.send(vec![]).is_err() { debug!("Could not send empty response to collisionned request, probably because request was interrupted. Dropping response."); } } trace!("request: query_send {}, {} bytes", id, bytes.len()); self.query_send.send(Some((id, prio, bytes)))?; let resp = resp_recv.await?; if resp.len() == 0 { return Err(Error::Message("Response is 0 bytes, either a collision or a protocol error".into())); } trace!("request response {}: ", id); let code = resp[0]; if code == 0 { Ok(rmp_serde::decode::from_read_ref::<_, ::Response>( &resp[1..], )?) } else { Err(Error::Remote(format!("Remote error code {}", code))) } } } impl SendLoop for ClientConn {} #[async_trait] impl RecvLoop for ClientConn { async fn recv_handler(self: Arc, id: RequestID, msg: Vec) { trace!("ClientConn recv_handler {} ({} bytes)", id, msg.len()); let mut inflight = self.inflight.lock().unwrap(); if let Some(ch) = inflight.remove(&id) { if ch.send(msg).is_err() { debug!("Could not send request response, probably because request was interrupted. Dropping response."); } } if inflight.is_empty() && self.must_exit.load(atomic::Ordering::SeqCst) { self.stop_recv_loop .send(true) .log_err("could not write true to stop_recv_loop"); } } }