Struct PeerTracker 

pub struct PeerTracker { /* private fields */ }

Actor that tracks peer delta updates and emits new states.

Implementations

impl PeerTracker

pub async fn peer_by_name( &mut self, ctx: &mut Context<Self, DelegatedReply<Option<Node>>>, name: String, ) -> DelegatedReply<Option<Node>>

Lookup a peer by name.

Waits until we’ve received at least one peer update from control.

pub fn peer_by_accepted_route( &mut self, ctx: &mut Context<Self, DelegatedReply<Vec<Node>>>, ip: IpAddr, ) -> DelegatedReply<Vec<Node>>

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.

pub fn peer_by_tailnet_ip( &mut self, ctx: &mut Context<Self, DelegatedReply<Option<Node>>>, ip: IpAddr, ) -> DelegatedReply<Option<Node>>

Lookup the peer that has the given tailnet IP address.

pub fn get_status( &mut self, ctx: &mut Context<Self, DelegatedReply<Vec<StatusNode>>>, ) -> DelegatedReply<Vec<StatusNode>>

Build the peer entries of a Status snapshot.

Returns one StatusNode per known peer. The self node is not included here (it lives in the control runner); Runtime::status combines both.

Waits until we’ve received at least one peer update from control.

pub fn whois( &mut self, ctx: &mut Context<Self, DelegatedReply<Option<WhoIs>>>, addr: SocketAddr, ) -> DelegatedReply<Option<WhoIs>>

Resolve which node owns a tailnet source address.

Maps the source IP of addr to the owning node via the tailnet-IP index, returning a WhoIs. The port is ignored (a tailnet IP uniquely identifies a node).

The resulting WhoIs carries no user/login or capability data: this fork’s domain Node does not retain those wire fields. See the status module docs for the gap.

Waits until we’ve received at least one peer update from control.

pub fn watch_netmap(&self) -> Receiver<Vec<StatusNode>>

Subscribe to netmap peer-change events.

Returns a watch::Receiver whose value is the current set of peer StatusNodes, updated on every netmap state update from control. Embedders can await changes via watch::Receiver::changed to react to peers joining, leaving, or changing.

The receiver’s initial value is the peer set at subscription time (empty before the first netmap update). This is a peer-only view; combine with the self node from Runtime::status when a full snapshot is needed.

Trait Implementations

impl Actor for PeerTracker

type Args = Env

Arguments to initialize the actor.

type Error = Error

Actor error type.

async fn on_start( env: Self::Args, slf: ActorRef<Self>, ) -> Result<Self, Self::Error>

Called when the actor starts, before it processes any messages.

fn name() -> &'static str

The name of the actor, which can be useful for logging or debugging.

fn on_message( &mut self, msg: Box<dyn DynMessage<Self>>, actor_ref: ActorRef<Self>, tx: Option<Sender<Result<Box<dyn Any + Send>, SendError<Box<dyn Any + Send>, Box<dyn Any + Send>>>>>, stop: &mut bool, ) -> impl Future<Output = Result<(), Box<dyn ReplyError>>> + Send

Called when the actor receives a message to be processed.

fn on_panic( &mut self, actor_ref: WeakActorRef<Self>, err: PanicError, ) -> impl Future<Output = Result<ControlFlow<ActorStopReason>, Self::Error>> + Send

Called when the actor encounters a panic or an error during “tell” message handling.

fn on_link_died( &mut self, actor_ref: WeakActorRef<Self>, id: ActorId, reason: ActorStopReason, ) -> impl Future<Output = Result<ControlFlow<ActorStopReason>, Self::Error>> + Send

Called when a linked actor dies.

fn on_stop( &mut self, actor_ref: WeakActorRef<Self>, reason: ActorStopReason, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Called before the actor stops.

fn next( &mut self, actor_ref: WeakActorRef<Self>, mailbox_rx: &mut MailboxReceiver<Self>, ) -> impl Future<Output = Option<Signal<Self>>> + Send

Awaits the next signal typically from the mailbox.

impl Message<Arc<StateUpdate>> for PeerTracker

type Reply = ()

The reply sent back to the message caller.

async fn handle( &mut self, msg: Arc<StateUpdate>, _ctx: &mut Context<Self, Self::Reply>, )

Handler for this message.

impl Message<GetStatus> for PeerTracker

type Reply = DelegatedReply<Vec<StatusNode>>

The reply sent back to the message caller.

async fn handle( &mut self, msg: GetStatus, ctx: &mut Context<Self, Self::Reply>, ) -> Self::Reply

Handler for this message.

impl Message<PeerByAcceptedRoute> for PeerTracker

type Reply = DelegatedReply<Vec<Node>>

The reply sent back to the message caller.

async fn handle( &mut self, msg: PeerByAcceptedRoute, ctx: &mut Context<Self, Self::Reply>, ) -> Self::Reply

Handler for this message.

impl Message<PeerByName> for PeerTracker

type Reply = DelegatedReply<Option<Node>>

The reply sent back to the message caller.

async fn handle( &mut self, msg: PeerByName, ctx: &mut Context<Self, Self::Reply>, ) -> Self::Reply

Handler for this message.

impl Message<PeerByTailnetIp> for PeerTracker

type Reply = DelegatedReply<Option<Node>>

The reply sent back to the message caller.

async fn handle( &mut self, msg: PeerByTailnetIp, ctx: &mut Context<Self, Self::Reply>, ) -> Self::Reply

Handler for this message.

impl Message<RepublishState> for PeerTracker

type Reply = ()

The reply sent back to the message caller.

async fn handle( &mut self, _msg: RepublishState, _ctx: &mut Context<Self, Self::Reply>, )

Handler for this message.

impl Message<WatchNetmap> for PeerTracker

type Reply = Receiver<Vec<StatusNode>>

The reply sent back to the message caller.

async fn handle( &mut self, msg: WatchNetmap, _ctx: &mut Context<Self, Self::Reply>, ) -> Self::Reply

Handler for this message.

impl Message<Whois> for PeerTracker

type Reply = DelegatedReply<Option<WhoIs>>

The reply sent back to the message caller.

async fn handle( &mut self, msg: Whois, ctx: &mut Context<Self, Self::Reply>, ) -> Self::Reply

Handler for this message.