biov 0.1.11

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

use std::process::Stdio;

use bv_core::cache::CacheLayout;
use bv_core::error::Result;
use bv_core::project::BvToml;
use bv_runtime::{
    ContainerRuntime, DockerRuntime, GpuProfile, ImageDigest, ImageMetadata, Mount, OciRef,
    ProgressReporter, RunOutcome, RunSpec, RuntimeInfo,
};
use bv_runtime_apptainer::{ApptainerRuntime, is_available as apptainer_available};

/// A runtime that can be either Docker or Apptainer, chosen at startup.
#[derive(Clone)]
pub enum AnyRuntime {
    Docker(DockerRuntime),
    Apptainer(ApptainerRuntime),
}

impl ContainerRuntime for AnyRuntime {
    fn name(&self) -> &str {
        match self {
            Self::Docker(r) => r.name(),
            Self::Apptainer(r) => r.name(),
        }
    }

    fn health_check(&self) -> Result<RuntimeInfo> {
        match self {
            Self::Docker(r) => r.health_check(),
            Self::Apptainer(r) => r.health_check(),
        }
    }

    fn pull(&self, image: &OciRef, progress: &dyn ProgressReporter) -> Result<ImageDigest> {
        match self {
            Self::Docker(r) => r.pull(image, progress),
            Self::Apptainer(r) => r.pull(image, progress),
        }
    }

    fn run(&self, spec: &RunSpec) -> Result<RunOutcome> {
        match self {
            Self::Docker(r) => r.run(spec),
            Self::Apptainer(r) => r.run(spec),
        }
    }

    fn inspect(&self, digest: &ImageDigest) -> Result<ImageMetadata> {
        match self {
            Self::Docker(r) => r.inspect(digest),
            Self::Apptainer(r) => r.inspect(digest),
        }
    }

    fn is_locally_available(&self, image_ref: &str, digest: &str) -> bool {
        match self {
            Self::Docker(r) => r.is_locally_available(image_ref, digest),
            Self::Apptainer(r) => r.is_locally_available(image_ref, digest),
        }
    }

    fn gpu_args(&self, profile: &GpuProfile) -> Vec<String> {
        match self {
            Self::Docker(r) => r.gpu_args(profile),
            Self::Apptainer(r) => r.gpu_args(profile),
        }
    }

    fn mount_args(&self, mounts: &[Mount]) -> Vec<String> {
        match self {
            Self::Docker(r) => r.mount_args(mounts),
            Self::Apptainer(r) => r.mount_args(mounts),
        }
    }
}

/// Select a runtime from (in priority order): explicit flag, bv.toml, auto-detect.
pub fn resolve_runtime(
    backend_flag: Option<&str>,
    bv_toml: Option<&BvToml>,
) -> anyhow::Result<AnyRuntime> {
    let backend = backend_flag
        .or_else(|| bv_toml.and_then(|t| t.runtime.backend.as_deref()))
        .unwrap_or("auto");

    build_runtime(backend)
}

/// Check if the `docker` binary is on PATH without connecting to the daemon.
/// `docker --version` prints the client version string and exits 0 immediately.
fn docker_binary_on_path() -> bool {
    std::process::Command::new("docker")
        .arg("--version")
        .stdout(Stdio::null())
        .stderr(Stdio::null())
        .status()
        .map(|s| s.success())
        .unwrap_or(false)
}

fn build_runtime(backend: &str) -> anyhow::Result<AnyRuntime> {
    match backend {
        "docker" => Ok(AnyRuntime::Docker(DockerRuntime)),
        "apptainer" | "singularity" => {
            let cache = CacheLayout::new();
            Ok(AnyRuntime::Apptainer(ApptainerRuntime::new(
                cache.sif_dir(),
            )))
        }
        "auto" => {
            // Use a fast binary-presence check rather than a full daemon roundtrip.
            // Each command does its own health_check() once it has the runtime object.
            if docker_binary_on_path() {
                return Ok(AnyRuntime::Docker(DockerRuntime));
            }
            if apptainer_available() {
                let cache = CacheLayout::new();
                return Ok(AnyRuntime::Apptainer(ApptainerRuntime::new(
                    cache.sif_dir(),
                )));
            }
            anyhow::bail!(
                "no container runtime found\n  \
                 Install Docker (https://docs.docker.com/get-docker/) or \
                 Apptainer (https://apptainer.org/docs/admin/main/installation.html)"
            )
        }
        other => anyhow::bail!(
            "unknown backend '{}'; use 'docker', 'apptainer', or 'auto'",
            other
        ),
    }
}