A modern terminal with a built-in multiplexer: close it and your sessions keep running. Run shells and tons of AI agents across your machines, then pick them up from desktop, browser, TUI and more. Written in Rust with no UI framework: interface drawn straight on the GPU. No Electron, GPUI or webview.
Rust agentagent-orchestrationaiai-agentsclaude-codecodexcoding-agentlinuxmacosmultiplayermultiplexerrustterminalterminal-emulatorterminal-multiplexertmuxtuiweztermwindows
//! Peer delta update tracking.
use std::{collections::HashSet, net::IpAddr, sync::Arc};
use kameo::{
actor::ActorRef,
message::{Context, Message},
reply::ReplySender,
};
use ts_control::Node;
use ts_transport::PeerId;
use crate::{Error, env::Env};
mod peer_db;
pub use peer_db::PeerDb;
/// Actor that tracks peer delta updates and emits new states.
pub struct PeerTracker {
peer_db: PeerDb,
seen_state_update: bool,
pending_requests: Vec<Pending>,
env: Env,
}
impl PeerTracker {
fn peer_by_name_opt(&self, name: &str) -> Option<&Node> {
let name = name.trim_end_matches('.');
self.peer_db.get(&name).map(|(_id, node)| node)
}
fn peer_by_tailnet_ip_opt(&self, ip: IpAddr) -> Option<&Node> {
self.peer_db.get(&ip).map(|(_id, node)| node)
}
}
impl kameo::Actor for PeerTracker {
type Args = Env;
type Error = Error;
async fn on_start(env: Self::Args, slf: ActorRef<Self>) -> Result<Self, Self::Error> {
env.subscribe::<Arc<ts_control::StateUpdate>>(&slf).await?;
env.register(None, &slf).await?;
Ok(Self {
peer_db: PeerDb::default(),
pending_requests: Default::default(),
seen_state_update: false,
env,
})
}
}
enum Pending {
PeerByName(PeerByName, ReplySender<Option<Node>>),
AcceptedRoute(PeerByAcceptedRoute, ReplySender<Vec<Node>>),
TailnetIp(PeerByTailnetIp, ReplySender<Option<Node>>),
}
// For messages with arguments, a struct is generated with the args as fields. They aren't
// documented, and we can't apply attributes directly to the fields. Hence, wrap in a module where
// docs are turned off everywhere.
#[allow(missing_docs)]
mod msg_impl {
use std::net::IpAddr;
use kameo::prelude::DelegatedReply;
use super::*;
#[kameo::messages]
impl PeerTracker {
/// Lookup a peer by name.
///
/// Waits until we've received at least one peer update from control.
#[message(ctx)]
pub async fn peer_by_name(
&mut self,
ctx: &mut Context<Self, DelegatedReply<Option<Node>>>,
name: String,
) -> DelegatedReply<Option<Node>> {
let (deleg, sender) = ctx.reply_sender();
let Some(sender) = sender else { return deleg };
if !self.seen_state_update {
tracing::debug!(query = name, "no peer state seen yet, queueing request");
self.pending_requests
.push(Pending::PeerByName(PeerByName { name }, sender));
return deleg;
}
sender.send(self.peer_by_name_opt(&name).cloned());
deleg
}
/// Lookup all peers that accept packets addressed to the given IP.
///
/// This includes the peer's tailnet address and any subnet routes it provides. Only
/// the peers with the most specific subnet route match that covers `ip` will be
/// returned.
///
/// E.g., suppose:
///
/// - We're querying for `10.1.2.3`
/// - `PeerA` and `PeerB` have accepted routes for `10.1.2.0/24`
/// - `PeerC` has an accepted route for `10.1.0.0/16`
///
/// Only `PeerA` and `PeerB` will be returned, since they have the most specific
/// prefix match.
#[message(ctx)]
pub fn peer_by_accepted_route(
&mut self,
ctx: &mut Context<Self, DelegatedReply<Vec<Node>>>,
ip: IpAddr,
) -> DelegatedReply<Vec<Node>> {
let (deleg, sender) = ctx.reply_sender();
let Some(sender) = sender else { return deleg };
if !self.seen_state_update {
tracing::debug!(query = %ip, "no peer state seen yet, queueing request");
self.pending_requests
.push(Pending::AcceptedRoute(PeerByAcceptedRoute { ip }, sender));
return deleg;
}
sender.send(
self.peer_db
.get_route(ip.into())
.map(|(_id, node)| node.clone())
.collect(),
);
deleg
}
/// Lookup the peer that has the given tailnet IP address.
#[message(ctx)]
pub fn peer_by_tailnet_ip(
&mut self,
ctx: &mut Context<Self, DelegatedReply<Option<Node>>>,
ip: IpAddr,
) -> DelegatedReply<Option<Node>> {
let (deleg, sender) = ctx.reply_sender();
let Some(sender) = sender else { return deleg };
if !self.seen_state_update {
tracing::debug!(query = %ip, "no peer state seen yet, queueing request");
self.pending_requests
.push(Pending::TailnetIp(PeerByTailnetIp { ip }, sender));
return deleg;
}
sender.send(self.peer_by_tailnet_ip_opt(ip).cloned());
deleg
}
// ThinkTerm (peer list): added.
/// Every peer we know of, or None before the first netmap. Unlike the lookups, this
/// doesn't wait for one.
#[message]
pub fn all_peers(&mut self) -> Option<Vec<Node>> {
self.seen_state_update
.then(|| self.peer_db.peers().values().cloned().collect())
}
}
}
pub use msg_impl::*;
#[derive(Debug, Clone, Default)]
pub(crate) struct PeerState {
#[allow(unused)]
pub deletions: HashSet<PeerId>,
#[allow(unused)]
pub upserts: HashSet<PeerId>,
pub peers: Arc<PeerDb>,
}
impl Message<Arc<ts_control::StateUpdate>> for PeerTracker {
type Reply = ();
async fn handle(
&mut self,
msg: Arc<ts_control::StateUpdate>,
_ctx: &mut Context<Self, Self::Reply>,
) {
let Some(peer_update) = &msg.peer_update else {
// ThinkTerm (peer list): added.
// A whole netmap leaves the peers out when there are none: the tailnet is known to
// have none from it. Only a whole one, with the DERP map every first netmap carries:
// a tracker restarted mid-stream would take a later update of the node alone for
// an empty tailnet, and answer from that until control sent a whole netmap again.
if msg.node.is_some() && msg.derp.is_some() {
self.service_pending_requests();
}
return;
};
let mut upserts = HashSet::default();
let mut deletions = HashSet::default();
match peer_update {
ts_control::PeerUpdate::Full(new_nodes) => {
tracing::trace!("full peer update");
let new_ids = new_nodes
.iter()
.map(|x| &x.stable_id)
.collect::<HashSet<_>>();
self.peer_db.retain(|id, peer| {
let retain = new_ids.contains(&peer.stable_id);
if !retain {
deletions.insert(id);
}
retain
});
for node in new_nodes {
let peer_id = self.peer_db.upsert(node);
upserts.insert(peer_id);
}
}
ts_control::PeerUpdate::Delta {
patch,
remove,
upsert,
} => {
tracing::trace!("delta peer update");
for peer in remove {
let Some((id, _node)) = self.peer_db.remove(peer) else {
tracing::error!(control_node_id = peer, "removed peer was unknown");
continue;
};
deletions.insert(id);
}
for peer in upsert {
let id = self.peer_db.upsert(peer);
upserts.insert(id);
}
for update in patch {
if let Some(id) = self.peer_db.patch(update) {
upserts.insert(id);
} else {
tracing::warn!(?update, "no peer for update");
}
}
}
}
tracing::debug!(
n_upsert = upserts.len(),
n_delete = deletions.len(),
peer_count = self.peer_db.peers().len(),
"new peer state"
);
self.service_pending_requests();
if let Err(e) = self
.env
.publish(Arc::new(PeerState {
upserts,
deletions,
peers: Arc::new(self.peer_db.clone()),
}))
.await
{
tracing::error!(error = %e, "publishing peer state update");
}
}
}
impl PeerTracker {
fn service_pending_requests(&mut self) {
if self.seen_state_update {
return;
}
self.seen_state_update = true;
if !self.pending_requests.is_empty() {
tracing::debug!(
n_pending = self.pending_requests.len(),
"state update received, servicing pending requests"
);
}
for req in core::mem::take(&mut self.pending_requests) {
match req {
Pending::PeerByName(PeerByName { name }, reply) => {
reply.send(self.peer_by_name_opt(&name).cloned());
}
Pending::TailnetIp(PeerByTailnetIp { ip }, reply) => {
reply.send(self.peer_by_tailnet_ip_opt(ip).cloned());
}
Pending::AcceptedRoute(PeerByAcceptedRoute { ip }, reply) => {
reply.send(
self.peer_db
.get_route(ip.into())
.map(|(_id, node)| node.clone())
.collect(),
);
}
}
}
}
}