agent_api/
requests.rs

1use anyhow::Error;
2use std::result::Result::Ok;
3use tonic::{Request, Response, Streaming, transport::Channel};
4use tonic_reflection::pb::v1::{
5    ServerReflectionRequest, ServerReflectionResponse,
6    server_reflection_client::ServerReflectionClient, server_reflection_request::MessageRequest,
7};
8
9use crate::agent::ActiveConnectionResponse;
10use crate::agent::AddIpToBlocklistRequest;
11use crate::agent::BlocklistResponse;
12use crate::agent::DroppedPacketsResponse;
13use crate::agent::LatencyMetricsResponse;
14use crate::agent::RequestActiveConnections;
15use crate::agent::RmIpFromBlocklistRequest;
16use crate::agent::RmIpFromBlocklistResponse;
17use crate::agent::VethHashMapResponse;
18use crate::agent::VethResponse;
19use crate::agent::agent_client::AgentClient;
20
21#[cfg(feature = "client")]
22pub async fn send_active_connection_request(
23    mut client: AgentClient<Channel>,
24) -> Result<Response<ActiveConnectionResponse>, Error> {
25    let request = Request::new(RequestActiveConnections { pod_ip: None });
26    let response = client.active_connections(request).await?;
27    Ok(response)
28}
29
30#[cfg(feature = "client")]
31pub async fn get_all_features(
32    mut client: ServerReflectionClient<Channel>,
33) -> Result<Response<Streaming<ServerReflectionResponse>>, Error> {
34    let request = ServerReflectionRequest {
35        host: "".to_string(),
36        message_request: Some(MessageRequest::FileContainingSymbol(
37            "agent.Agent".to_string(),
38        )),
39    };
40    let response = client
41        .server_reflection_info(tokio_stream::iter(vec![request]))
42        .await?;
43
44    Ok(response)
45}
46
47#[cfg(feature = "client")]
48pub async fn send_create_blocklist_request(
49    mut client: AgentClient<Channel>,
50    ip: &str,
51) -> Result<Response<BlocklistResponse>, Error> {
52    let ip = Some(ip.to_string());
53    let request = Request::new(AddIpToBlocklistRequest { ip });
54    let response = client.add_ip_to_blocklist(request).await?;
55    Ok(response)
56}
57
58#[cfg(feature = "client")]
59pub async fn send_check_blocklist_request(
60    mut client: AgentClient<Channel>,
61) -> Result<Response<BlocklistResponse>, Error> {
62    let request = Request::new(());
63    let response = client.check_blocklist(request).await?;
64    Ok(response)
65}
66
67#[cfg(feature = "client")]
68pub async fn remove_ip_from_blocklist_request(
69    mut client: AgentClient<Channel>,
70    ip: &str,
71) -> Result<Response<RmIpFromBlocklistResponse>, Error> {
72    let ip = ip.to_string();
73    let request = Request::new(RmIpFromBlocklistRequest { ip });
74    let response = client.rm_ip_from_blocklist(request).await?;
75    Ok(response)
76}
77
78#[cfg(feature = "client")]
79pub async fn send_dropped_packets_request(
80    mut client: AgentClient<Channel>,
81) -> Result<Response<DroppedPacketsResponse>, Error> {
82    let request = Request::new(());
83    let response = client.get_dropped_packets_metrics(request).await?;
84    Ok(response)
85}
86
87#[cfg(feature = "client")]
88pub async fn send_latency_metrics_request(
89    mut client: AgentClient<Channel>,
90) -> Result<Response<LatencyMetricsResponse>, Error> {
91    let request = Request::new(());
92    let response = client.get_latency_metrics(request).await?;
93    Ok(response)
94}
95
96#[cfg(feature = "client")]
97pub async fn send_tracked_veth_request(
98    mut client: AgentClient<Channel>,
99) -> Result<Response<VethResponse>, Error> {
100    let request = Request::new(());
101    let response = client.get_tracked_veth(request).await?;
102    Ok(response)
103}
104
105#[cfg(feature = "client")]
106pub async fn send_veth_tracked_hashmap_req(
107    mut client: AgentClient<Channel>,
108) -> Result<Response<VethHashMapResponse>, Error> {
109    let request = Request::new(());
110    let response = client.get_tracked_veth_from_hash_map(request).await?;
111    Ok(response)
112}
agent_api/requests.rs

agent_api/
requests.rs
