xbp 10.17.2

XBP is a zero-config build pack that can also interact with proxies, kafka, sockets, synthetic monitors.
Documentation 
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

use crate::cli::commands::{
    NetworkConfigSubCommand, NetworkFloatingIpSubCommand, NetworkSubCommand,
};
use crate::sdk::network::{
    add_floating_ip, list_floating_ips, list_network_config_sources, AddFloatingIpRequest,
};
use anyhow::Result;

pub async fn run_network(command: NetworkSubCommand, _debug: bool) -> Result<()> {
    match command {
        NetworkSubCommand::FloatingIp(floating_ip) => match floating_ip.command {
            NetworkFloatingIpSubCommand::Add {
                ip,
                cidr,
                interface,
                label,
                apply,
                dry_run,
            } => {
                let response = add_floating_ip(AddFloatingIpRequest {
                    ip,
                    cidr,
                    interface,
                    label,
                    apply,
                    dry_run,
                })
                .await?;
                println!("{}", serde_json::to_string_pretty(&response)?);
            }
            NetworkFloatingIpSubCommand::List { json } => {
                let response = list_floating_ips().await?;
                if json {
                    println!("{}", serde_json::to_string_pretty(&response)?);
                } else {
                    print_floating_ips_table(&response.items);
                }
            }
        },
        NetworkSubCommand::Config(config) => match config.command {
            NetworkConfigSubCommand::List { json } => {
                let response = list_network_config_sources().await?;
                if json {
                    println!("{}", serde_json::to_string_pretty(&response)?);
                } else {
                    print_network_config_sources_table(
                        &response.sources,
                        response.detected_backend,
                    );
                }
            }
        },
    }

    Ok(())
}

fn print_floating_ips_table(items: &[crate::sdk::network::FloatingIpEntry]) {
    if items.is_empty() {
        println!("No floating IP entries found.");
        return;
    }

    println!(
        "{:<8} {:<14} {:<20} {:<8} {:<10} SOURCE",
        "BACKEND", "INTERFACE", "IP/CIDR", "RUNTIME", "CONFIG"
    );
    println!("{}", "-".repeat(96));
    for item in items {
        println!(
            "{:<8} {:<14} {:<20} {:<8} {:<10} {}",
            item.backend,
            item.interface,
            item.address_cidr,
            if item.runtime { "yes" } else { "no" },
            if item.config { "yes" } else { "no" },
            item.source_file.as_deref().unwrap_or("-"),
        );
    }
}

fn print_network_config_sources_table(
    sources: &[crate::sdk::network::NetworkConfigSource],
    detected_backend: crate::sdk::network::NetworkBackend,
) {
    println!("Detected backend: {}", detected_backend);
    if sources.is_empty() {
        println!("No network config sources discovered.");
        return;
    }

    println!("{:<8} {:<6} PATH", "BACKEND", "EXISTS");
    println!("{}", "-".repeat(96));
    for source in sources {
        println!(
            "{:<8} {:<6} {}",
            source.backend,
            if source.exists { "yes" } else { "no" },
            source.path
        );
    }
}