biov 0.1.4

A uv-style tool manager for bioinformatics: reproducible Docker-backed tools with digest-pinned lockfiles (installs as `bv`)
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
146
147

use std::io::Write as _;
use std::path::Path;
use std::process::{Command, Stdio};

use anyhow::Context;
use owo_colors::{OwoColorize, Stream};

/// Log in to GHCR, build the image, push it, and return the resolved digest.
pub fn build_and_push(
    context_dir: &Path,
    dockerfile: &Path,
    image_ref: &str,
    ghcr_token: &str,
    github_username: &str,
    platform: &str,
) -> anyhow::Result<String> {
    docker_login(ghcr_token, github_username)?;
    docker_build(context_dir, dockerfile, image_ref, platform)?;
    docker_push(image_ref)?;
    resolve_digest(image_ref)
}

fn docker_login(token: &str, username: &str) -> anyhow::Result<()> {
    eprintln!(
        "  {} ghcr.io as {}",
        "Logging in".if_supports_color(Stream::Stderr, |t| t.cyan().bold().to_string()),
        username
    );
    let mut child = Command::new("docker")
        .args(["login", "ghcr.io", "-u", username, "--password-stdin"])
        .stdin(Stdio::piped())
        .stdout(Stdio::null())
        .stderr(Stdio::piped())
        .spawn()
        .context("failed to spawn 'docker login'")?;

    child
        .stdin
        .as_mut()
        .unwrap()
        .write_all(token.as_bytes())
        .context("failed to write token to docker login")?;

    let out = child.wait_with_output().context("docker login failed")?;
    if !out.status.success() {
        let stderr = String::from_utf8_lossy(&out.stderr);
        anyhow::bail!("docker login failed: {}", stderr.trim());
    }
    Ok(())
}

fn docker_build(
    context_dir: &Path,
    dockerfile: &Path,
    image_ref: &str,
    platform: &str,
) -> anyhow::Result<()> {
    eprintln!(
        "  {} {} for linux/{}",
        "Building".if_supports_color(Stream::Stderr, |t| t.cyan().bold().to_string()),
        image_ref,
        platform
    );
    let status = Command::new("docker")
        .args([
            "build",
            "--platform",
            &format!("linux/{}", platform),
            "-f",
            &dockerfile.to_string_lossy(),
            "-t",
            image_ref,
            &context_dir.to_string_lossy(),
        ])
        .status()
        .context("failed to spawn 'docker build'")?;

    if !status.success() {
        anyhow::bail!("docker build failed (exit {})", status);
    }
    Ok(())
}

fn docker_push(image_ref: &str) -> anyhow::Result<()> {
    eprintln!(
        "  {} {}",
        "Pushing".if_supports_color(Stream::Stderr, |t| t.cyan().bold().to_string()),
        image_ref
    );
    let status = Command::new("docker")
        .args(["push", image_ref])
        .status()
        .context("failed to spawn 'docker push'")?;

    if !status.success() {
        anyhow::bail!("docker push failed (exit {})", status);
    }
    Ok(())
}

fn resolve_digest(image_ref: &str) -> anyhow::Result<String> {
    let out = Command::new("docker")
        .args(["inspect", "--format", "{{index .RepoDigests 0}}", image_ref])
        .output()
        .context("failed to inspect image")?;

    if out.status.success() {
        let raw = String::from_utf8_lossy(&out.stdout).trim().to_string();
        if let Some(digest) = extract_digest(&raw) {
            return Ok(digest);
        }
    }

    // Fallback: docker manifest inspect
    manifest_digest(image_ref)
}

fn manifest_digest(image_ref: &str) -> anyhow::Result<String> {
    let out = Command::new("docker")
        .args(["manifest", "inspect", "--verbose", image_ref])
        .output()
        .context("docker manifest inspect failed")?;

    if !out.status.success() {
        anyhow::bail!(
            "could not resolve digest for {}: {}",
            image_ref,
            String::from_utf8_lossy(&out.stderr).trim()
        );
    }

    let text = String::from_utf8_lossy(&out.stdout);
    let v: serde_json::Value =
        serde_json::from_str(&text).context("failed to parse manifest inspect output")?;

    let digest = v["Descriptor"]["digest"]
        .as_str()
        .ok_or_else(|| anyhow::anyhow!("digest not found in manifest inspect output"))?
        .to_string();

    Ok(digest)
}

fn extract_digest(repo_digest: &str) -> Option<String> {
    let at = repo_digest.find('@')?;
    Some(repo_digest[at + 1..].to_string())
}