Struct NodeHeartbeat 

pub struct NodeHeartbeat {
    pub peer_id: PeerIdString,
    pub status: NodeStatus,
    pub available_storage: Bytes,
    pub available_bandwidth: u64,
    pub active_connections: u32,
    pub timestamp: DateTime<Utc>,
}

Heartbeat message from node to coordinator.

Fields

peer_id: PeerIdString

Node’s peer ID.

status: NodeStatus

Current node status.

available_storage: Bytes

Available storage (bytes).

available_bandwidth: u64

Available bandwidth (bps).

active_connections: u32

Number of active connections.

timestamp: DateTime<Utc>

Timestamp of the heartbeat.

Implementations

impl NodeHeartbeat

pub fn new(peer_id: impl Into<String>, status: NodeStatus) -> Self

Create a new heartbeat with current timestamp.

Examples

use chie_shared::{NodeHeartbeat, NodeStatus};

// Create online heartbeat
let heartbeat = NodeHeartbeat::new("12D3KooWNode", NodeStatus::Online);
assert_eq!(heartbeat.peer_id, "12D3KooWNode");
assert_eq!(heartbeat.status, NodeStatus::Online);
assert_eq!(heartbeat.available_storage, 0);

// Create custom heartbeat with resources
let mut custom = NodeHeartbeat::new("12D3KooWOther", NodeStatus::Online);
custom.available_storage = 100 * 1024 * 1024 * 1024; // 100 GB
custom.available_bandwidth = 10_000_000; // 10 Mbps
custom.active_connections = 42;
assert_eq!(custom.active_connections, 42);

Trait Implementations

impl Clone for NodeHeartbeat

fn clone(&self) -> NodeHeartbeat

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NodeHeartbeat

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NodeHeartbeat

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for NodeHeartbeat

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

where __S: Serializer,

Serialize this value into the given Serde serializer.