xbp 10.30.3

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

use crate::cli::commands::{DomainsCmd, DomainsProviderKind, DomainsSubCommand};
use crate::commands::cloudflare_credentials::{
    build_cloudflare_client, CloudflareCredentialOverrides,
};
use crate::config::update_dns_inventory_cache;

pub async fn run_domains(cmd: DomainsCmd, _debug: bool) -> Result<(), String> {
    if cmd.provider != DomainsProviderKind::Cloudflare {
        return Err(
            "Only Cloudflare is supported for `xbp domains` in this release.".to_string(),
        );
    }

    let account_id_override = cmd.account_id.clone();
    let client = build_cloudflare_client(
        CloudflareCredentialOverrides {
            token: cmd.token.clone(),
            account_id: account_id_override.clone(),
        },
        true,
    )
    .await?;
    let account_id = account_id_override;

    match cmd.command {
        DomainsSubCommand::Search(args) => {
            let mut results = client.search_domains(&args.query, &args.extensions).await?;
            if let Some(limit) = args.limit {
                results.truncate(limit);
            }
            update_dns_inventory_cache(|cache| {
                cache.record_cloudflare_domain_availability(account_id, &results)
            })?;
            print_json(&results)
        }
        DomainsSubCommand::Check(args) => {
            let results = client.check_domains(&args.domains).await?;
            update_dns_inventory_cache(|cache| {
                cache.record_cloudflare_domain_availability(account_id, &results)
            })?;
            print_json(&results)
        }
        DomainsSubCommand::List(_) => {
            let (domains, result_info) = client.list_registered_domains().await?;
            update_dns_inventory_cache(|cache| {
                cache.record_cloudflare_registered_domains(account_id, &domains)
            })?;
            print_json(&serde_json::json!({
                "provider": "cloudflare",
                "domains": domains,
                "result_info": result_info
            }))
        }
    }
}

fn print_json(value: &impl serde::Serialize) -> Result<(), String> {
    println!(
        "{}",
        serde_json::to_string_pretty(value)
            .map_err(|error| format!("Failed to encode JSON output: {}", error))?
    );
    Ok(())
}