Struct GlobalRegistryServer 

pub struct GlobalRegistryServer {
    pub config: GlobalRegistryServerConfig,
    pub seed: u64,
    pub entries: HashMap<PeerId, (u64, Address)>,
    /* private fields */
}

Server half of GlobalRegistry. Maintains PeerId → (expires_at_ns, source_address) over the announced cohort and exposes the cohort as a bb_runtime::contracts::PeerSelector source. Eviction is lazy: Sample / CurrentView drop entries whose expires_at_ns has elapsed before consulting the registry.

Fields

config: GlobalRegistryServerConfig

Configurable TTL bounds + heartbeat policy.

seed: u64

RNG seed for deterministic Sample selection. Persisted so a restored server samples consistently.

entries: HashMap<PeerId, (u64, Address)>

Registry: PeerId → (expires_at_ns, source_address). Restored alongside seed so cohort continuity survives snapshot/restore.

Implementations

impl GlobalRegistryServer

pub fn new(seed: u64) -> Self

Construct a fresh server with the default TTL/heartbeat policy and seed driving deterministic Sample selection.

pub fn with_config(seed: u64, config: GlobalRegistryServerConfig) -> Self

Construct with an explicit config override.

pub fn heartbeat_interval_ns(&self) -> u64

Server-derived heartbeat interval. Integer division on default_ttl_ns / 3 gives the client three windows to refresh before eviction.

Trait Implementations

impl AnyComponent for GlobalRegistryServer

fn as_any(&self) -> &dyn Any

Downcast view - immutable.

fn as_any_mut(&mut self) -> &mut dyn Any

Downcast view - mutable.

impl Bootstrap for GlobalRegistryServer

type Error = Infallible

Library-maker-defined error type. Must satisfy the standard engine error bounds so the framework can box it into the dispatch error channel.

fn bootstrap(&mut self, _ctx: &mut BootstrapCtx) -> Result<(), Self::Error>

Run one-shot setup. Default no-op so Components without an initialization phase need no boilerplate. Authors override to mmap state, allocate backend tensors, prime calibration buffers, etc.

impl Clone for GlobalRegistryServer

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ConcreteComponent for GlobalRegistryServer

const TYPE_NAME: &'static str = "GlobalRegistryServer"

Stable identifier. Convention: <crate>::<TypeName>.

const PACKAGE: ComponentPackage = ::bytesandbrains::concrete::ComponentPackage::Application

Origin tag; defaults to Application.

const DEPENDENCIES: &'static [DependencyDecl]

Sibling components this depends on. Populated by the bb::Concrete derive from #[bb::depends(...)].

type Config = ()

Per-deployment config. Use () for stateless concretes.

type Error = Infallible

Error from Self::new; use Infallible if construction can’t fail.

fn new(_config: &Self::Config) -> Result<Self, Self::Error>

Construct from &Self::Config. Install calls this once per slot.

fn serialize(&self) -> Vec<u8>

Serialize state to bytes, including config-derived fields.

fn restore(bytes: &[u8]) -> Result<Self, RestoreError>

Reconstruct from serialize output.

impl Debug for GlobalRegistryServer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for GlobalRegistryServer

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for GlobalRegistryServer

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PeerSelector for GlobalRegistryServer

type Error = OpError

Library-maker-defined error type.

fn select( &mut self, ctx: &mut RuntimeResourceRef<'_>, params: SelectParams, _completion: CompletionHandle<Vec<PeerId>, Self::Error>, ) -> ContractResponse<Vec<PeerId>, Self::Error>

Generic selection — params carries selector-specific config. Concrete impls handle the variants they support and fail the unsupported ones via ContractResponse::Now carrying an error. ctx exposes ctx.peers.addresses (the framework’s AddressBook), the engine’s per-op runtime surface, and ctx.dependency::<T>(slot) for reaching any concrete bound via #[depends(...)].

fn current_view( &mut self, ctx: &mut RuntimeResourceRef<'_>, _completion: CompletionHandle<Vec<PeerId>, Self::Error>, ) -> ContractResponse<Vec<PeerId>, Self::Error>

Snapshot the current view of known peers (owned snapshot — async serialization needs owned values).

fn sample( &mut self, ctx: &mut RuntimeResourceRef<'_>, n: u32, completion: CompletionHandle<Vec<PeerId>, Self::Error>, ) -> ContractResponse<Vec<PeerId>, Self::Error>

Sample n peers from the current view. Calls land on select(SelectParams::Random { n }) by default. Concrete impls may override to keep an optimized fast path.

impl PeerSelectorRuntime for GlobalRegistryServer

type Error = OpError

Peer-sampling-impl-specific error type.

fn atomic_opset(&self) -> AtomicOpsetDecl

Atomic-op opset this impl owns.

fn dispatch_atomic( &mut self, op_type: &str, _inputs: &[(&str, &dyn SlotValue)], _ctx: &mut RuntimeResourceRef<'_>, ) -> Result<DispatchResult, Self::Error>

Rust-dispatch entry point for atomic ops.

impl ProtocolRuntime for GlobalRegistryServer

type Error = OpError

Protocol-impl-specific error type.

fn atomic_opset(&self) -> AtomicOpsetDecl

Atomic-op opset this protocol declares. Both inbound envelope routing AND user-graph DSL ops register here.

fn dispatch_atomic( &mut self, op_type: &str, inputs: &[(&str, &dyn SlotValue)], ctx: &mut RuntimeResourceRef<'_>, ) -> Result<DispatchResult, OpError>

Single dispatch entry. For inbound envelopes the framework synthesizes inputs from the wire envelope:

impl Serialize for GlobalRegistryServer

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.