arqen 0.9.1

Backend infrastructure for agent-ready applications
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

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ColorChoice {
    Auto,
    Always,
    Never,
}

impl ColorChoice {
    pub fn parse(s: &str) -> Self {
        match s.to_lowercase().as_str() {
            "always" | "yes" | "true" => Self::Always,
            "never" | "no" | "false" => Self::Never,
            _ => Self::Auto,
        }
    }
}

use std::io::IsTerminal;

pub struct Output {
    json: bool,
    quiet: bool,
    verbose: bool,
    #[allow(dead_code)]
    color: ColorChoice,
}

impl Output {
    pub fn from_args(json: bool, quiet: bool, verbose: bool, color: &str) -> Self {
        Self {
            json,
            quiet,
            verbose,
            color: ColorChoice::parse(color),
        }
    }

    pub fn is_json(&self) -> bool {
        self.json
    }

    pub fn is_quiet(&self) -> bool {
        self.quiet
    }

    pub fn is_verbose(&self) -> bool {
        self.verbose
    }

    pub fn print(&self, msg: &str) {
        if !self.quiet {
            println!("{}", msg);
        }
    }

    pub fn print_banner(&self, addr: &std::net::SocketAddr, storage: &str, environment: &str) {
        if self.json || self.quiet {
            return;
        }
        let use_color = match self.color {
            ColorChoice::Always => true,
            ColorChoice::Never => false,
            ColorChoice::Auto => std::io::stdout().is_terminal(),
        };
        let cyan = if use_color { "\x1b[36m" } else { "" };
        let dim = if use_color { "\x1b[2m" } else { "" };
        let reset = if use_color { "\x1b[0m" } else { "" };
        println!(
            "{cyan}     _\n    / \\\n   / __ \\  _ __ __ _  ___ _ __\n  / /  \\ \\| '__/ _` |/ _ \\ '__|\n / /____\\ \\| | | (_| |  __/ |\n/_/      \\_\\_|  \\__, |\\___|_|\n                  |___/{reset}"
        );
        println!(
            "{dim}  Arqen v{} · {} · {}{reset}",
            env!("CARGO_PKG_VERSION"),
            environment,
            storage
        );
        println!(
            "  API:    http://{addr}\n  Health: http://{addr}/health\n  Docs:   http://{addr}/docs\n  Agent:  http://{addr}/agent\n"
        );
    }

    pub fn print_json(&self, value: serde_json::Value) {
        if let Ok(s) = serde_json::to_string_pretty(&value) {
            println!("{}", s);
        }
    }

    pub fn print_verbose(&self, msg: &str) {
        if self.verbose && !self.quiet {
            eprintln!("[verbose] {}", msg);
        }
    }

    pub fn print_error(&self, msg: &str) {
        eprintln!("error: {}", msg);
    }
}