cortexflow-cli 0.1.4

CortexFlow command line interface made to interact with the CortexBrain core components
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

#![allow(warnings)]
use std::result::Result::Ok;
use colored::Colorize;
use agent_api::requests::send_check_blocklist_request;
use agent_api::requests::send_create_blocklist_request;
use agent_api::requests::remove_ip_from_blocklist_request;
use anyhow::Error;
use clap::{ Args, Parser, Subcommand };
use agent_api::client::{ connect_to_client, connect_to_server_reflection };

//policies subcommands
#[derive(Subcommand, Debug, Clone)]
pub enum PoliciesCommands {
    #[command(name = "create-blocklist", about = "Create a blocklist to filter ips")]
    CreateBlocklist,
    #[command(name = "check-blocklist", about = "Check current ip blocklist")]
    CheckBlocklist,
    #[command(name="remove-ip",about ="Remove an ip from the blocklist")]
    RemoveIpFromBlocklist
}

// cfcli policies <args>
#[derive(Args, Debug, Clone)]
pub struct PoliciesArgs {
    #[command(subcommand)]
    pub policy_cmd: PoliciesCommands,
    #[arg(long, short)]
    pub flags: Option<String>,
}

pub async fn create_blocklist(ip: &str) -> Result<(), Error> {
    println!("{} {}", "=====>".blue().bold(), "Connecting to cortexflow Client".white());

    match connect_to_client().await {
        Ok(client) => {
            println!("{} {}", "=====>".blue().bold(), "Connected to CortexFlow Client".green());
            match send_create_blocklist_request(client, ip).await {
                Ok(response) => {
                    println!("{:?}", response.into_inner().events);
                }
                Err(e) => {
                    println!(
                        "{} {} {} {}",
                        "=====>".blue().bold(),
                        "An error occured".red(),
                        "Error:",
                        e
                    );
                    return Err(e)
                }
            }
        }
        Err(e) => {
            println!(
                "{} {}",
                "=====>".blue().bold(),
                "Failed to connect to CortexFlow Client".red()
            );
            return Err(e)
        }
    }
    Ok(())
}

pub async fn check_blocklist() -> Result<(), Error> {
    println!("{} {}", "=====>".blue().bold(), "Connecting to cortexflow Client".white());

    match connect_to_client().await {
        Ok(client) => {
            println!("{} {}", "=====>".blue().bold(), "Connected to CortexFlow Client".green());
            match send_check_blocklist_request(client).await {
                Ok(response) => {
                    println!("{:?}", response.into_inner().events);
                }
                Err(e) => {
                    println!(
                        "{} {} {} {}",
                        "=====>".blue().bold(),
                        "An error occured".red(),
                        "Error:",
                        e
                    );
                    return Err(e);
                }
            }
        }
        Err(e) => {
            println!(
                "{} {}",
                "=====>".blue().bold(),
                "Failed to connect to CortexFlow Client".red()
            );
            return Err(e);
        }
    }
    Ok(())
}
pub async fn remove_ip(ip:&str) -> Result<(), Error> {
    println!("{} {}", "=====>".blue().bold(), "Connecting to cortexflow Client".white());
    match connect_to_client().await {
        Ok(client) => {
            println!("{} {}", "=====>".blue().bold(), "Connected to CortexFlow Client".green());
            match remove_ip_from_blocklist_request(client,ip).await {
                Ok(response) => {
                    println!("{:?}", response.into_inner().events);
                }
                Err(e) => {
                    println!(
                        "{} {} {} {}",
                        "=====>".blue().bold(),
                        "An error occured".red(),
                        "Error:",
                        e
                    );
                    return Err(e);
                }
            }
        }
        Err(e) => {
            println!(
                "{} {}",
                "=====>".blue().bold(),
                "Failed to connect to CortexFlow Client".red()
            );
            return Err(e);
        }
    }
    Ok(())
}