xbp 0.9.1

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
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
134
135
136
137
138
139
140
141
142
143
144
145

use crate::cli::commands::{DiagCmd, NginxSubCommand};
use crate::commands::load_xbp_config;
use crate::commands::nginx::run_nginx;
use crate::commands::system_diag::{print_diagnostic_report, run_full_diagnostics};
use crate::logging::{log_error, log_info, log_success, log_warn};
use crate::strategies::get_all_services;
use anyhow::Result;
use regex::Regex;
use std::fs;
use std::io::{self, Write};
use std::path::PathBuf;

pub async fn run_diag(cmd: DiagCmd, debug: bool) -> Result<()> {
    if cmd.nginx {
        check_nginx_interactive(debug).await?;
    } else {
        let config = load_xbp_config().await.ok();
        let mut ports_to_check = Vec::new();

        if let Some(ref cfg) = config {
            let services = get_all_services(cfg);
            for service in services {
                ports_to_check.push(service.port);
            }
        }

        if ports_to_check.is_empty() {
            ports_to_check = vec![80, 443, 3000, 8080, 9090];
        }

        match run_full_diagnostics(ports_to_check).await {
            Ok(report) => {
                print_diagnostic_report(&report).await;
            }
            Err(e) => {
                let _ = log_error("diag", "Failed to run diagnostics", Some(&e.to_string())).await;
            }
        }

        check_nginx_interactive(debug).await?;
    }
    Ok(())
}

/// Check Nginx status and return a list of mismatches: (service_name/domain, expected_port, actual_port)
pub async fn check_nginx_mismatches() -> Result<Vec<(String, u16, u16)>> {
    let config = match load_xbp_config().await {
        Ok(c) => c,
        Err(_) => return Ok(vec![]), // Not in a project or invalid config
    };

    let services = get_all_services(&config);
    let mut mismatches = Vec::new();

    let sites_enabled = PathBuf::from("/etc/nginx/sites-enabled");
    if !sites_enabled.exists() {
        return Ok(vec![]);
    }

    let proxy_pass_regex = Regex::new(r"proxy_pass\s+http://127\.0\.0\.1:(\d+);").unwrap();
    // server_name_regex removed as unused

    for service in services {
        let expected_port = service.port;
        // Try to find config by service name or url (if it's a domain)
        let mut potential_names = vec![service.name.clone()];
        if let Some(url) = &service.url {
            let domain = url
                .trim_start_matches("http://")
                .trim_start_matches("https://")
                .split('/')
                .next()
                .unwrap_or(url);
            potential_names.push(domain.to_string());
        }

        for name in potential_names {
            let config_path = sites_enabled.join(&name);
            if config_path.exists() {
                if let Ok(content) = fs::read_to_string(&config_path) {
                    if let Some(cap) = proxy_pass_regex.captures(&content) {
                        if let Ok(port) = cap[1].parse::<u16>() {
                            if port != expected_port {
                                mismatches.push((name.clone(), expected_port, port));
                                break; // Found the config, stop checking other names
                            }
                        }
                    }
                }
            }
        }
    }

    Ok(mismatches)
}

async fn check_nginx_interactive(debug: bool) -> Result<()> {
    let _ = log_info("diag", "Checking Nginx configuration...", None).await;

    let mismatches = check_nginx_mismatches().await?;

    if mismatches.is_empty() {
        let _ = log_success("diag", "Nginx configuration looks correct.", None).await;
        return Ok(());
    }

    for (name, expected, actual) in mismatches {
        let _ = log_warn(
            "diag",
            &format!(
                "Port mismatch for {}: Nginx uses {}, xbp.json uses {}",
                name, actual, expected
            ),
            None,
        )
        .await;

        print!(
            "Do you want to update Nginx to use port {}? [y/N]: ",
            expected
        );
        io::stdout().flush()?;

        let mut input = String::new();
        io::stdin().read_line(&mut input)?;

        if input.trim().to_lowercase() == "y" {
            // Call nginx update command
            let cmd = NginxSubCommand::Update {
                domain: name.clone(),
                port: expected,
            };
            if let Err(e) = run_nginx(cmd, debug).await {
                let _ = log_error(
                    "diag",
                    &format!("Failed to update Nginx for {}", name),
                    Some(&e.to_string()),
                )
                .await;
            }
        }
    }

    Ok(())
}