zenobuf-cli 0.3.1

Command-line tools for the Zenobuf framework - monitor topics, call services, manage parameters
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! List command for the Zenobuf CLI

use clap::Subcommand;
use console::style;
use std::collections::HashSet;
use zenoh::{self, key_expr::KeyExpr};

use crate::error::Result;

/// Subcommands for the list command
#[derive(Subcommand)]
pub enum ListCommands {
    /// List nodes
    Nodes,
    /// List topics
    Topics,
    /// List services
    Services,
}

/// Executes the list command
pub async fn execute(cmd: ListCommands) -> Result<()> {
    match cmd {
        ListCommands::Nodes => list_nodes().await,
        ListCommands::Topics => list_topics().await,
        ListCommands::Services => list_services().await,
    }
}

/// Lists all nodes
async fn list_nodes() -> Result<()> {
    println!("{}", style("Nodes:").bold());

    // Connect to Zenoh
    let session = zenoh::open(zenoh::config::Config::default()).await?;

    // Query for nodes using the node prefix
    let node_prefix = "zenobuf/node/**";
    let selector = KeyExpr::try_from(node_prefix)?;

    let mut nodes = HashSet::new();
    let replies = session.get(selector).await?;

    while let Ok(reply) = replies.recv_async().await {
        if let Ok(sample) = reply.result() {
            let key = sample.key_expr().as_str();
            // Extract node name from the key expression
            if let Some(node_name) = key.strip_prefix("zenobuf/node/") {
                nodes.insert(node_name.to_string());
            }
        }
    }

    if nodes.is_empty() {
        println!("  No nodes found");
    } else {
        for node in nodes {
            println!("  {}", node);
        }
    }

    Ok(())
}

/// Lists all topics
async fn list_topics() -> Result<()> {
    println!("{}", style("Topics:").bold());

    // Connect to Zenoh
    let session = zenoh::open(zenoh::config::Config::default()).await?;

    // Query for topics using the topic prefix
    let topic_prefix = "zenobuf/topic/**";
    let selector = KeyExpr::try_from(topic_prefix)?;

    let mut topics = HashSet::new();
    let replies = session.get(selector).await?;

    while let Ok(reply) = replies.recv_async().await {
        if let Ok(sample) = reply.result() {
            let key = sample.key_expr().as_str();
            // Extract topic name from the key expression
            if let Some(topic_name) = key.strip_prefix("zenobuf/topic/") {
                topics.insert(topic_name.to_string());
            }
        }
    }

    if topics.is_empty() {
        println!("  No topics found");
    } else {
        for topic in topics {
            println!("  {}", topic);
        }
    }

    Ok(())
}

/// Lists all services
async fn list_services() -> Result<()> {
    println!("{}", style("Services:").bold());

    // Connect to Zenoh
    let session = zenoh::open(zenoh::config::Config::default()).await?;

    // Query for services using the service prefix
    let service_prefix = "zenobuf/service/**";
    let selector = KeyExpr::try_from(service_prefix)?;

    let mut services = HashSet::new();
    let replies = session.get(selector).await?;

    while let Ok(reply) = replies.recv_async().await {
        if let Ok(sample) = reply.result() {
            let key = sample.key_expr().as_str();
            // Extract service name from the key expression
            if let Some(service_name) = key.strip_prefix("zenobuf/service/") {
                services.insert(service_name.to_string());
            }
        }
    }

    if services.is_empty() {
        println!("  No services found");
    } else {
        for service in services {
            println!("  {}", service);
        }
    }

    Ok(())
}