athena_rs 3.26.3

Hyper performant polyglot Database driver
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

//! Convenience binary that forces the `server` subcommand.
//!
//! Normally users should invoke the server through the `athena` CLI
//! (`athena server` or just `athena`). This binary exists for symmetry
//! with `athena-cli` and for direct `athena-server` usage in scripts.

use std::env;
use std::path::PathBuf;
use std::process::{Command, ExitCode};
/// Entrypoint for the `athena-server` convenience binary.
fn main() -> ExitCode {
    let mut forwarded: Vec<String> = env::args().skip(1).collect();
    forwarded.insert(0, "server".to_string());
    let invoked = env::args().next().unwrap_or_else(|| "athena-server".to_string());

    match resolve_and_run(&forwarded, &invoked) {
        Ok(exit_code) => exit_code,
        Err(err) => {
            eprintln!("{}: {}", invoked, err);
            eprintln!();
            eprintln!("Hints:");
            eprintln!("  • Recommended:  athena server     (or just `athena`)");
            eprintln!("  • Runtime:      athena_rs server");
            eprintln!("  • Build:        cargo build --bin athena --bin athena_rs --bin athena-server");
            ExitCode::from(1)
        }
    }
}

/// Resolve the Athena runtime and invoke it with the "server" subcommand prepended.
///
/// This is a convenience wrapper so that `athena-server` behaves like
/// `athena server` or `athena_rs server`.
fn resolve_and_run(args: &[String], invoked: &str) -> std::io::Result<ExitCode> {
    let athena = find_athena_binary()?;

    if std::env::var("ATHENA_LAUNCHER_QUIET").is_err() && !is_sibling_path(&athena) {
        let label = std::path::Path::new(invoked)
            .file_name()
            .and_then(|n| n.to_str())
            .unwrap_or("athena-server");
        eprintln!("[{}] → {}", label, athena.display());
    }

    let status = Command::new(&athena)
        .args(args)
        .status()?;

    match status.code() {
        Some(code) if code >= 0 && code <= 255 => Ok(ExitCode::from(code as u8)),
        _ => Ok(ExitCode::from(1)),
    }
}

fn is_sibling_path(p: &std::path::Path) -> bool {
    if let Ok(me) = std::env::current_exe() {
        if let (Some(my_dir), Some(target_dir)) = (me.parent(), p.parent()) {
            return my_dir == target_dir;
        }
    }
    false
}

fn find_athena_binary() -> std::io::Result<PathBuf> {
    if let Some(sib) = sibling_candidate() {
        if sib.is_file() {
            return Ok(sib);
        }
    }

    // Prefer the runtime
    if let Ok(p) = which::which("athena_rs") {
        return Ok(p);
    }
    if let Ok(p) = which::which("athena") {
        return Ok(p);
    }

    Err(std::io::Error::new(
        std::io::ErrorKind::NotFound,
        "could not find 'athena_rs' (Athena runtime) or 'athena'",
    ))
}

fn sibling_candidate() -> Option<PathBuf> {
    let current = env::current_exe().ok()?;
    let dir = current.parent()?;

    let names = if cfg!(windows) {
        ["athena.exe", "athena_rs.exe"]
    } else {
        ["athena", "athena_rs"]
    };

    for name in names {
        let p = dir.join(name);
        if p.is_file() {
            return Some(p);
        }
    }
    None
}