bitrouter 0.27.3

BitRouter
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

//! CLI subcommand for managing runtime routes via the admin API.

use std::net::SocketAddr;

use crate::cli::admin_auth::{admin_get, parse_error_message, request_with_admin_auth};

/// Options for the `route add` subcommand.
pub struct RouteAddOpts {
    pub model: String,
    pub endpoints: Vec<String>,
    pub strategy: Option<String>,
}

/// Run the `route list` subcommand — prints all routes from the running daemon.
pub fn run_list(
    config: &bitrouter_config::BitrouterConfig,
    addr: SocketAddr,
) -> Result<(), Box<dyn std::error::Error>> {
    let resp = admin_get(config, addr, "/admin/routes")?;

    if !resp.status().is_success() {
        let msg = parse_error_message(resp)?;
        return Err(format!("failed to list routes: {msg}").into());
    }

    let body: serde_json::Value = resp.json()?;
    let routes = body["routes"].as_array();
    match routes {
        Some(routes) if !routes.is_empty() => {
            for route in routes {
                let model = route["name"].as_str().unwrap_or("?");
                let source = route["source"].as_str().unwrap_or("?");
                let endpoints = route["endpoints"].as_array();

                let targets: Vec<String> = endpoints
                    .map(|eps| {
                        eps.iter()
                            .map(|ep| {
                                let provider = ep["provider"].as_str().unwrap_or("?");
                                let service_id = ep["service_id"].as_str().unwrap_or("?");
                                if service_id.is_empty() {
                                    provider.to_owned()
                                } else {
                                    format!("{provider}:{service_id}")
                                }
                            })
                            .collect()
                    })
                    .unwrap_or_default();

                let strategy = route["strategy"].as_str().unwrap_or("");
                let strategy_suffix = if strategy.is_empty() {
                    String::new()
                } else {
                    format!(" ({strategy})")
                };

                println!(
                    "  {model}  →  {}{strategy_suffix}  [{source}]",
                    targets.join(", ")
                );
            }
        }
        _ => {
            println!("  (no routes configured)");
        }
    }
    Ok(())
}

/// Run the `route add` subcommand — creates or updates a dynamic route.
pub fn run_add(
    config: &bitrouter_config::BitrouterConfig,
    addr: SocketAddr,
    opts: RouteAddOpts,
) -> Result<(), Box<dyn std::error::Error>> {
    let endpoints: Vec<serde_json::Value> = opts
        .endpoints
        .iter()
        .map(|ep| {
            let (provider, service_id) = ep.split_once(':').unwrap_or((ep, ""));
            serde_json::json!({
                "provider": provider,
                "service_id": service_id,
            })
        })
        .collect();

    let body = serde_json::json!({
        "name": opts.model,
        "strategy": opts.strategy.unwrap_or_else(|| "priority".to_owned()),
        "endpoints": endpoints,
    });

    let url = format!("http://{addr}/admin/routes");
    let client = reqwest::blocking::Client::new();
    let resp = request_with_admin_auth(config, client.post(&url))?
        .json(&body)
        .send()?;

    if resp.status().is_success() {
        println!("route '{}' added", opts.model);
    } else {
        let msg = parse_error_message(resp)?;
        return Err(format!("failed to add route: {msg}").into());
    }
    Ok(())
}

/// Run the `route rm` subcommand — removes a dynamic route.
pub fn run_remove(
    config: &bitrouter_config::BitrouterConfig,
    addr: SocketAddr,
    name: &str,
) -> Result<(), Box<dyn std::error::Error>> {
    let url = format!("http://{addr}/admin/routes/{name}");
    let client = reqwest::blocking::Client::new();
    let resp = request_with_admin_auth(config, client.delete(&url))?.send()?;

    if resp.status().is_success() {
        println!("route '{name}' removed");
    } else {
        let msg = parse_error_message(resp)?;
        return Err(format!("failed to remove route: {msg}").into());
    }
    Ok(())
}