Struct ClusterClient

pub struct ClusterClient { /* private fields */ }

Client for interacting with a cluster

Implementations

impl ClusterClient

pub fn new( cmd_tx: Sender<SubnetCommand>, event_rx: Receiver<SubnetEvent>, ) -> Self

pub const fn available_patterns(&self) -> &HashMap<String, Pattern>

returns an immutable reference to the available patterns

pub fn available_patterns_mut(&mut self) -> &mut HashMap<String, Pattern>

returns a mutable reference to the available patterns

pub fn client_id(&self) -> &str

returns the id of the client

pub const fn peers(&self) -> &HashMap<NodeId, PeerInfo>

returns an immutable reference to the peers

pub fn peers_mut(&mut self) -> &mut HashMap<NodeId, PeerInfo>

returns a mutable reference to the peers

pub async fn find_learning_nodes(&self) -> Vec<NodeId>

Find nodes that can learn patterns

pub fn get_patterns_for_class(&self, class: Triads) -> Vec<&Pattern>

Get patterns for a specific chord class

pub fn get_peers(&self) -> &HashMap<NodeId, PeerInfo>

Get all known peers with their capabilities

pub fn get_peers_with_capability( &self, capability: &str, ) -> Vec<(NodeId, &PeerInfo)>

Get peers with a specific capability

pub async fn process_events(&mut self) -> Result<()>

Process received events from the cluster

pub async fn share_pattern( &self, node_id: NodeId, chord_class: Triads, input: [f32; 3], output: f32, ) -> Result<(), NetworkError>

Share a specific pattern with the network

pub async fn request_pattern_sharing(&self) -> Result<(), NetworkError>

Request all nodes to share their patterns

pub async fn connect(&self, addr: Multiaddr) -> Result<NodeId, NetworkError>

Connect to a peer address

pub async fn request_resource_status(&self) -> Result<(), NetworkError>

Request resource status from all peers

pub async fn allocate_task( &self, task_type: String, work_units: Vec<WorkUnit>, ) -> Result<(), NetworkError>

Allocate work units to network nodes

pub async fn learn_network_patterns(&self) -> Result<(), NetworkError>

Learn patterns that have been shared on the network

pub async fn distribute_surface_patterns(&self) -> Result<(), NetworkError>

Distribute surface patterns to the network

pub async fn form_processing_cluster( &self, task_type: String, ) -> Result<Vec<PeerId>, NetworkError>

Form a processing cluster for a specific task type

pub async fn synchronize_memory(&self) -> Result<(), NetworkError>

Synchronize memory across the network

pub async fn dynamic_work_distribution( &self, operations: Vec<(EdgeId, Vec<LPR>)>, ) -> Result<(), NetworkError>

Create a dynamic work distribution for a set of operations

pub async fn topology_aware_learning(&self) -> Result<(), NetworkError>

Enable topology-aware learning

pub async fn shutdown(&self) -> Result<(), NetworkError>

Shutdown the network