Struct NodeMetadata 

pub struct NodeMetadata {

    pub node_id: NodeId,
    pub name: Option<String>,
    pub description: Option<String>,
    pub owner: Option<String>,
    pub location: Option<LocationInfo>,
    pub topology: TopologyHints,
    pub status: NodeStatus,
    pub custom: HashMap<String, String>,
    pub version: u64,
    pub updated_at: u64,
    pub created_at: u64,
    pub tags: HashSet<String>,
    pub roles: HashSet<String>,
}

Complete node metadata

Fields

node_id: NodeId

Unique node identifier

name: Option<String>

Human-readable node name

description: Option<String>

Node description

owner: Option<String>

Owner identifier (org, user, etc.)

location: Option<LocationInfo>

Geographic location

topology: TopologyHints

Topology hints

status: NodeStatus

Current status

custom: HashMap<String, String>

Custom key-value metadata

version: u64

Metadata version (monotonic)

updated_at: u64

Last update timestamp (Unix millis)

created_at: u64

Creation timestamp (Unix millis)

tags: HashSet<String>

Tags for categorization

roles: HashSet<String>

Node roles

Implementations

impl NodeMetadata

pub fn validate_bounds(&self) -> Result<(), MetadataError>

Validate that the metadata fits within the per-field boundedness caps (string lengths, tag/role/custom counts, preferred-peers / hop-distances / public-addresses sizes).

Without these caps the deserialize path is unbounded — every Vec / HashMap / String would accept whatever the peer shipped, and MetadataStore::upsert would happily index millions of attacker-supplied tags into the per-tag inverted-index DashMap. upsert (and update_versioned) call validate_bounds before touching the indexes; oversized metadata surfaces as MetadataError::Invalid(...).

pub fn new(node_id: NodeId) -> Self

Create new node metadata

pub fn with_name(self, name: impl Into<String>) -> Self

Set name

pub fn with_owner(self, owner: impl Into<String>) -> Self

Set owner

pub fn with_location(self, location: LocationInfo) -> Self

Set location

pub fn with_topology(self, topology: TopologyHints) -> Self

Set topology

pub fn with_status(self, status: NodeStatus) -> Self

Set status

pub fn with_tag(self, tag: impl Into<String>) -> Self

Add tag

pub fn with_role(self, role: impl Into<String>) -> Self

Add role

pub fn with_custom( self, key: impl Into<String>, value: impl Into<String>, ) -> Self

Add custom metadata

pub fn touch(&mut self)

Update and increment version

pub fn age(&self) -> Duration

Get age since last update

pub fn is_stale(&self, max_age: Duration) -> bool

Check if metadata is stale

pub fn routing_score(&self) -> f64

Calculate routing score for this node

Trait Implementations

impl Clone for NodeMetadata

fn clone(&self) -> NodeMetadata

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NodeMetadata

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NodeMetadata

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for NodeMetadata

fn eq(&self, other: &NodeMetadata) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for NodeMetadata

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for NodeMetadata