use std::collections::HashMap;
use std::net::{IpAddr, SocketAddr};
use std::sync::Arc;
use std::sync::atomic::{AtomicU64, Ordering};
use std::time::Duration;
use bytes::{Bytes, BytesMut};
use socket2::SockRef;
use tokio::io::AsyncWriteExt;
use tokio::sync::mpsc;
use tokio_util::sync::CancellationToken;
use tokio_util::task::TaskTracker;
use super::peer::{
exchange_resume, go_live, heartbeat_task, met_at, peer_dispatch_task, peer_reader, peer_writer,
read_frame, tell_disconnected,
};
use super::protocol::write_framed;
use super::{
CAP_RESUME, ClusterContext, ClusterFrame, ClusterTlsConfig, DispatchItem, Link, LinkRefused,
MAX_CLUSTER_PEERS, PEER_DISPATCH_QUEUE_CAP, PEER_SESSION_GENERATION, PROTOCOL_VERSION,
PeerInfo, PeerRegistration, RESUME_TIMEOUT, claim_link, encode_hello, encode_peer_announce,
encode_peer_list, epoch_ms, local_capabilities, negotiate_capabilities, negotiate_version,
release_link,
};
pub(crate) enum InboundLinks {
Listener(tokio::net::TcpListener),
MainPort(mpsc::UnboundedReceiver<(tokio::net::TcpStream, SocketAddr)>),
}
#[derive(Default)]
pub(super) struct InboundGate {
pending: std::sync::Mutex<HashMap<IpAddr, usize>>,
pending_total: std::sync::atomic::AtomicUsize,
sessions: std::sync::atomic::AtomicUsize,
}
const MAX_PENDING_HELLOS: usize = 64;
const MAX_PENDING_HELLOS_PER_IP: usize = 4;
pub(super) struct Admitted {
gate: Arc<InboundGate>,
ip: IpAddr,
pending: bool,
session: bool,
}
impl InboundGate {
pub(super) fn admit(self: &Arc<Self>, addr: SocketAddr) -> Option<Admitted> {
let ip = addr.ip();
let mut pending = self.pending.lock().unwrap_or_else(|e| e.into_inner());
let from_ip = pending.entry(ip).or_insert(0);
if *from_ip >= MAX_PENDING_HELLOS_PER_IP
|| self.pending_total.load(Ordering::Relaxed) >= MAX_PENDING_HELLOS
{
if *from_ip == 0 {
pending.remove(&ip);
}
tracing::warn!("[WSE-Cluster] Too many links waiting for HELLO, refusing {addr}");
return None;
}
*from_ip += 1;
self.pending_total.fetch_add(1, Ordering::Relaxed);
Some(Admitted {
gate: Arc::clone(self),
ip,
pending: true,
session: false,
})
}
}
impl Admitted {
fn leave_pending(&mut self) {
if std::mem::take(&mut self.pending) {
let mut pending = self.gate.pending.lock().unwrap_or_else(|e| e.into_inner());
if let Some(from_ip) = pending.get_mut(&self.ip) {
*from_ip -= 1;
if *from_ip == 0 {
pending.remove(&self.ip);
}
}
self.gate.pending_total.fetch_sub(1, Ordering::Relaxed);
}
}
fn session(&mut self) -> bool {
self.leave_pending();
let taken = self
.gate
.sessions
.try_update(Ordering::AcqRel, Ordering::Acquire, |n| {
(n < MAX_CLUSTER_PEERS).then_some(n + 1)
})
.is_ok();
self.session = taken;
taken
}
}
impl Drop for Admitted {
fn drop(&mut self) {
self.leave_pending();
if self.session {
self.gate.sessions.fetch_sub(1, Ordering::AcqRel);
}
}
}
#[derive(Clone)]
pub(super) struct InboundSessionCtx {
pub(super) instance_id: String,
pub(super) ctx: ClusterContext,
pub(super) peer_reg_tx: mpsc::UnboundedSender<PeerRegistration>,
pub(super) global_cancel: CancellationToken,
pub(super) links: TaskTracker,
}
impl InboundSessionCtx {
pub(super) async fn run<S>(self, stream: S, addr: SocketAddr, admitted: Admitted)
where
S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin + Send + 'static,
{
handle_cluster_inbound_generic(stream, addr, self, admitted).await;
}
}
pub(super) async fn accept_cluster_links(
listener: tokio::net::TcpListener,
tls: Option<Arc<arc_swap::ArcSwap<ClusterTlsConfig>>>,
gate: Arc<InboundGate>,
inbound: InboundSessionCtx,
) {
let cancel = inbound.global_cancel.clone();
let mut pause = Duration::ZERO;
loop {
let accepted = tokio::select! {
res = listener.accept() => res,
() = cancel.cancelled() => break,
};
let (stream, addr) = match accepted {
Ok(link) => {
pause = Duration::ZERO;
link
}
Err(e) => {
pause = (pause * 2).clamp(Duration::from_millis(10), Duration::from_secs(1));
tracing::error!("[WSE-Cluster] Cluster accept error: {e} (retrying in {pause:?})");
tokio::select! {
() = tokio::time::sleep(pause) => continue,
() = cancel.cancelled() => break,
}
}
};
let Some(admitted) = gate.admit(addr) else {
continue;
};
let _ = stream.set_nodelay(true);
let sock = SockRef::from(&stream);
let _ = sock.set_send_buffer_size(262_144);
let _ = sock.set_recv_buffer_size(262_144);
let tls_snap = tls.as_ref().map(|holder| holder.load_full());
let session = inbound.clone();
inbound.links.spawn(async move {
match tls_snap {
Some(tls_cfg) => {
match tokio::time::timeout(
Duration::from_secs(5),
tls_cfg.acceptor.accept(stream),
)
.await
{
Ok(Ok(tls_stream)) => session.run(tls_stream, addr, admitted).await,
Ok(Err(e)) => {
tracing::warn!("[WSE-Cluster] TLS accept failed from {addr}: {e}");
}
Err(_) => tracing::warn!("[WSE-Cluster] TLS accept timeout from {addr}"),
}
}
None => session.run(stream, addr, admitted).await,
}
});
}
}
pub(super) fn reached_slot(reached_at: Option<&str>, from: SocketAddr) -> Option<String> {
let at = reached_at?;
match at.strip_prefix(':') {
Some(port) => port
.parse::<u16>()
.ok()
.filter(|port| *port != 0)
.map(|port| {
let mut at = from;
at.set_port(port);
at.to_string()
}),
None => Some(at.to_owned()),
}
}
async fn handle_cluster_inbound_generic<S>(
stream: S,
addr: SocketAddr,
session: InboundSessionCtx,
mut admitted: Admitted,
) where
S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin + Send + 'static,
{
let InboundSessionCtx {
instance_id,
ctx,
peer_reg_tx,
global_cancel,
..
} = session;
let instance_id: &str = &instance_id;
let local_caps = local_capabilities(&ctx);
let (mut reader, mut writer) = tokio::io::split(stream);
let peer_hello =
match tokio::time::timeout(Duration::from_secs(5), read_frame(&mut reader)).await {
Ok(Ok(frame)) => frame,
_ => None,
};
let (peer_instance_id, _peer_version, peer_caps, reached_at) = match peer_hello {
Some(ClusterFrame::Hello {
instance_id: peer_id,
protocol_version,
capabilities,
reached_at,
}) => match negotiate_version(PROTOCOL_VERSION, protocol_version) {
Some(v) => (
peer_id,
v,
negotiate_capabilities(local_caps, capabilities),
reached_at,
),
None => {
tracing::warn!(
"[WSE-Cluster] Version mismatch with inbound {addr}: local={PROTOCOL_VERSION}, remote={protocol_version}"
);
return;
}
},
_ => {
tracing::warn!("[WSE-Cluster] Invalid HELLO from inbound {addr}");
return;
}
};
if let Some(slot) = reached_slot(reached_at.as_deref(), addr) {
met_at(&ctx, &slot, &peer_instance_id);
}
if !admitted.session() {
tracing::warn!(
"[WSE-Cluster] Refusing inbound {addr}: {MAX_CLUSTER_PEERS} peer sessions already"
);
return;
}
let cancel = global_cancel.child_token();
let session_gen = PEER_SESSION_GENERATION.fetch_add(1, Ordering::AcqRel);
let last_activity = Arc::new(AtomicU64::new(epoch_ms()));
let link = Link {
dialer: peer_instance_id.clone(),
session: session_gen,
cancel: cancel.clone(),
activity: Arc::clone(&last_activity),
};
match claim_link(&ctx.links, instance_id, &peer_instance_id, link) {
Ok(()) => {}
Err(LinkRefused::SelfLink) => {
tracing::debug!("[WSE-Cluster] Closing inbound from {addr}: it is this node");
let mut hello_buf = BytesMut::new();
encode_hello(&mut hello_buf, instance_id, local_caps, &ctx.reached_at);
let mut frame = BytesMut::new();
write_framed(&mut frame, &hello_buf);
let _ = writer.write_all(&frame).await;
let _ = writer.flush().await;
return;
}
Err(LinkRefused::Duplicate) => {
tracing::debug!(
"[WSE-Cluster] Closing inbound from {addr}: already linked to instance {peer_instance_id}"
);
return;
}
}
let mut hello_buf = BytesMut::new();
encode_hello(&mut hello_buf, instance_id, local_caps, &ctx.reached_at);
let mut frame = BytesMut::new();
write_framed(&mut frame, &hello_buf);
if writer.write_all(&frame).await.is_err() || writer.flush().await.is_err() {
tracing::error!("[WSE-Cluster] Failed to send HELLO to inbound {addr}");
release_link(&ctx.links, &peer_instance_id, session_gen);
return;
}
let heard = Arc::clone(&ctx.heard.entry(peer_instance_id.clone()).or_default());
let wanted = if peer_caps & CAP_RESUME != 0 {
let resumed = exchange_resume(&mut reader, &mut writer, &ctx, (peer_caps, &heard)).await;
let Some(wanted) = resumed else {
tracing::warn!("[WSE-Cluster] No RESUME from inbound {addr} within {RESUME_TIMEOUT:?}");
release_link(&ctx.links, &peer_instance_id, session_gen);
return;
};
Some(wanted)
} else {
None
};
heard.linked();
if let Some(ref our_addr) = ctx.cluster_addr {
let mut announce_buf = BytesMut::new();
encode_peer_announce(&mut announce_buf, our_addr);
let mut announce_frame = BytesMut::new();
write_framed(&mut announce_frame, &announce_buf);
let _ = writer.write_all(&announce_frame).await;
let _ = writer.flush().await;
}
{
let addrs: Vec<String> = ctx.known_peers.iter().map(|r| r.key().clone()).collect();
if !addrs.is_empty() {
let mut list_buf = BytesMut::new();
encode_peer_list(&mut list_buf, &addrs);
let mut list_frame = BytesMut::new();
write_framed(&mut list_frame, &list_buf);
let _ = writer.write_all(&list_frame).await;
let _ = writer.flush().await;
}
}
tracing::info!(
"[WSE-Cluster] Accepted inbound peer from {addr} (v{_peer_version}, caps=0x{peer_caps:08x})"
);
let peer_addr_str = addr.to_string();
ctx.metrics.connected_peers.fetch_add(1, Ordering::Relaxed);
ctx.metrics.peer_info.insert(
peer_addr_str.clone(),
PeerInfo {
address: peer_addr_str.clone(),
instance_id: peer_instance_id.clone(),
capabilities: peer_caps,
connected_at: epoch_ms(),
},
);
let (write_tx, write_rx) = mpsc::channel::<Bytes>(10_000);
if peer_caps & super::CAP_PRODUCERS != 0 {
ctx.producer_links
.register(&peer_instance_id, write_tx.clone(), session_gen);
}
let (dispatch_tx, dispatch_rx) = mpsc::channel::<DispatchItem>(PEER_DISPATCH_QUEUE_CAP);
let dispatch_handle = tokio::spawn(peer_dispatch_task(
dispatch_rx,
ctx.clone(),
cancel.clone(),
Arc::clone(&heard),
));
let reader_handle = tokio::spawn(peer_reader(
reader,
write_tx.clone(),
peer_addr_str.clone(),
ctx.clone(),
dispatch_tx,
cancel.clone(),
(last_activity.clone(), session_gen, Arc::clone(&heard)),
));
if !go_live(
&mut writer,
&peer_reg_tx,
(&peer_addr_str, write_tx.clone(), peer_caps, cancel.clone()),
wanted,
&ctx,
)
.await
{
cancel.cancel();
}
let writer_handle = tokio::spawn(peer_writer(
write_rx,
writer,
cancel.clone(),
global_cancel.clone(),
ctx.metrics.clone(),
));
let heartbeat_handle = tokio::spawn(heartbeat_task(write_tx, cancel.clone(), last_activity));
cancel.cancelled().await;
let _ = reader_handle.await;
let _ = writer_handle.await;
let _ = dispatch_handle.await;
let _ = heartbeat_handle.await;
heard.ended();
let _ = peer_reg_tx.send(PeerRegistration::Deregister {
peer_addr: peer_addr_str.clone(),
});
ctx.producer_links.release(&peer_instance_id, session_gen);
release_link(&ctx.links, &peer_instance_id, session_gen);
ctx.metrics.connected_peers.fetch_sub(1, Ordering::Relaxed);
ctx.metrics.peer_info.remove(&peer_addr_str);
tell_disconnected(&ctx, peer_addr_str, session_gen, &global_cancel).await;
tracing::info!("[WSE-Cluster] Inbound peer {addr} disconnected");
}