Struct PlacementTable 

pub struct PlacementTable { /* private fields */ }

Role to serving node.

Implementations

impl PlacementTable

pub fn new( node_id: impl Into<String>, dialer: Option<Arc<dyn MeshDialer>>, audit: Option<Arc<dyn ProxyAudit>>, ) -> Self

Table for node node_id. Without a dialer there is no mesh: only local instances resolve.

pub fn with_advert_ttl(self, ttl: Duration) -> Self

Lifetime of a received advertisement (refreshed by each repeat).

pub fn allow_remote_node(&self, role: &str, node: &str, on: bool)

Allow or stop allowing node to serve role to this node. This is the consumer-side counterpart of expose_to_mesh and the governed decision to send this node’s prompts to that node: without it no remote instance resolves, however it advertises.

pub fn node_id(&self) -> &str

This node’s id.

pub fn dialer(&self) -> Option<&Arc<dyn MeshDialer>>

The mesh dialer, when there is one.

pub fn generation(&self) -> u64

Changes so far. A router cache keyed on this is never stale.

pub fn subscribe(&self) -> Receiver<u64>

Wakes on every change (invalidate_all_placement on it).

pub fn register_local( &self, role: &str, base: &str, model: Option<String>, api: &str, runtime: &str, ) -> Result<(), ProxyError>

Serve role from the loopback server at base. Refused when the endpoint is not http://<loopback ip>:<port>.

pub fn deregister_local(&self, role: &str)

Stop serving role locally.

pub async fn sync_local( &self, role: &str, rt: &InferRuntime, h: &InstanceHandle, ) -> SyncOutcome

Re-evaluate role against its adapter instance: reconcile (a dead managed server is restarted within its policy), probe, and serve it only while it answers.

pub fn expose_to_mesh(&self, role: &str, on: bool)

Allow or stop serving role to mesh peers. Beyond loopback this is a governed decision (ADR-101 section 7): the caller decides, this records it.

pub fn proxy_port(&self, role: &str) -> Option<u16>

The loopback proxy port registered for role (tests, status).

pub fn set_proxy_port(&self, role: &str, port: u16)

The loopback proxy port that fronts role on this node.

pub fn allow_mesh_peer(&self, role: &str, peer: &str, on: bool)

Allow or stop allowing peer to use this node’s instance of role (the serving-side counterpart of allow_remote_node). Exposure (expose_to_mesh) says the role may leave loopback at all; this says to whom. Default deny, audited.

pub fn ingest_advertisement( &self, sender: &str, ad: &ServiceAdvertisement, ) -> bool

Take an infer.<role> advertisement received from sender, the node id the connection was verified as. Heard only when the advertisement is the sender’s own (ad.node_id == sender), the sender is an enforced-admission full node with a trusted scope, and this node allowlisted sender for the role. A repeat refreshes the TTL.

pub fn remove_node(&self, node_id: &str)

A peer left or was revoked: forget what it advertised.

pub fn resolve(&self, role: &str) -> Option<Target>

Where role is served: this node first, then an admitted peer. Admission is re-checked here, so a revoked peer stops resolving at once even before its entry is removed.

pub fn local_for_peer(&self, role: &str, peer: &str) -> Option<MeshLocal>

The local instance of role, only when it is exposed to the mesh and peer is on the role’s serve allowlist: what that peer’s forwarded request may reach. Never a remote target, so a request cannot be bounced from node to node.

pub fn mesh_peer_allowed(&self, role: &str, peer: &str) -> bool

Whether peer is on role’s serve allowlist.

pub fn exposed_roles(&self) -> Vec<String>

Roles currently exposed to the mesh.

pub fn peer_listed_any(&self, peer: &str) -> bool

Whether peer is on any role’s serve allowlist.

pub fn base_url_for_role(&self, role: &str) -> Option<String>

Base URL for in-process consumers (PlacementResolver): the instance itself when it is local, this node’s loopback proxy when it is remote (the proxy speaks the mesh). None falls back.

pub fn local_base_for_role(&self, role: &str) -> Option<String>

Base URL of a server for role on this node only (.../v1), for consumers that cannot go through the mesh.

pub fn advertisement( &self, role: &str, now_secs: u64, ) -> Option<ServiceAdvertisement>

infer.<role> advertisement for a locally served role that is exposed to the mesh.

pub fn advertisements(&self, now_secs: u64) -> Vec<ServiceAdvertisement>

Advertisements of every exposed local role.

Trait Implementations

impl ServePolicy for PlacementTable

fn instance_for(&self, role: &str, peer: &str) -> Option<MeshLocal>

The loopback instance this node exposes to peer for role, or None (not exposed, or peer is not on the role’s serve allowlist).

fn peer_listed(&self, peer: &str) -> bool

Whether peer is on any role’s serve allowlist.