Files
woiken-sandboxes/src/oci.rs
T
niklas b50e846b11 fix(#7): pin busybox by digest, kernel downloads use the filtered agent
busybox:musl was a mutable tag re-resolved daily for the binary that runs as
PID 1 in every VM. Kernel/GitHub downloads now go through the same
public-only resolver as registries.
2026-10-22 19:55:23 +02:00

546 lines
23 KiB
Rust

//! Minimal OCI/Docker registry client: anonymous pull of linux/arm64 images,
//! sha256-verified blobs, layers flattened into one tar (whiteouts applied).
use anyhow::{Context, Result, anyhow, bail};
use serde_json::Value;
use sha2::{Digest, Sha256};
use std::collections::HashSet;
use std::fs::{self, File};
use std::io::{BufReader, Read, Write};
use std::net::{IpAddr, Ipv4Addr, SocketAddr, ToSocketAddrs};
use std::os::unix::fs::MetadataExt;
use std::path::{Path, PathBuf};
const ACCEPT: &str = "application/vnd.oci.image.index.v1+json, application/vnd.docker.distribution.manifest.list.v2+json, application/vnd.oci.image.manifest.v1+json, application/vnd.docker.distribution.manifest.v2+json";
pub struct Image {
pub rootfs: PathBuf,
pub config: Value, // the "config" object of the image config (Env, User, Cmd, ...)
pub digest: String,
}
struct Ref {
registry: String,
repo: String,
reference: String,
}
fn parse_ref(s: &str) -> Ref {
let (name, reference) = match s.split_once('@') {
Some((n, d)) => (n.to_string(), d.to_string()),
None => match s.rfind(':') {
Some(i) if !s[i..].contains('/') => (s[..i].to_string(), s[i + 1..].to_string()),
_ => (s.to_string(), "latest".to_string()),
},
};
let first = name.split('/').next().unwrap();
let (registry, repo) = if name.contains('/') && (first.contains('.') || first.contains(':') || first == "localhost") {
(first.to_string(), name[first.len() + 1..].to_string())
} else if name.contains('/') {
("registry-1.docker.io".into(), name)
} else {
("registry-1.docker.io".into(), format!("library/{name}"))
};
let registry = if registry == "docker.io" { "registry-1.docker.io".into() } else { registry };
Ref { registry, repo, reference }
}
/// Globally routable address? Used to stop a remote registry from steering the host at
/// loopback / LAN / link-local services (cloud metadata, local daemons) via auth realms or redirects.
pub fn is_public(ip: IpAddr) -> bool {
match ip {
IpAddr::V4(v) => {
let o = v.octets();
!(v.is_private()
|| v.is_loopback()
|| v.is_link_local()
|| v.is_unspecified()
|| v.is_broadcast()
|| v.is_multicast()
|| v.is_documentation()
|| o[0] == 0
|| (o[0] == 100 && o[1] & 0xc0 == 64)) // CGNAT 100.64/10
}
IpAddr::V6(v) => {
let v4 = |hi: u16, lo: u16| is_public(Ipv4Addr::from((hi as u32) << 16 | lo as u32).into());
match v.segments() {
[0, 0, 0, 0, 0, 0xffff, hi, lo] => v4(hi, lo), // IPv4-mapped
[0x64, 0xff9b, 0, 0, 0, 0, hi, lo] => v4(hi, lo), // NAT64 well-known prefix
[0x2002, hi, lo, ..] => v4(hi, lo), // 6to4
[0x2001, 0xdb8, ..] | [0x2001, 0, ..] => false, // documentation, Teredo
s => s[0] & 0xe000 == 0x2000, // global unicast 2000::/3 only
}
}
}
}
/// Every HTTP agent: a silent server (connect or any single read, TLS handshake included) fails after 30 s instead of hanging.
pub fn agent() -> ureq::AgentBuilder {
let t = std::time::Duration::from_secs(30);
ureq::AgentBuilder::new().timeout_connect(t).timeout_read(t)
}
/// Registry the user named as local: `localhost` or a non-public IP literal. Decided by name only --
/// a DNS name pointing at loopback (e.g. *.127.0.0.1.nip.io) is controlled by whoever owns the zone.
fn explicit_local(registry: &str) -> bool {
let host = registry.split_once(':').map_or(registry, |(h, _)| h);
host == "localhost" || host.parse().is_ok_and(|ip| !is_public(ip))
}
/// HTTP agent for a registry. Public registries get an agent that refuses to connect to non-public
/// addresses (covers token realms and blob redirects too); an explicitly local registry
/// (e.g. localhost:5000, 192.168.1.5:5000) was chosen by the user and keeps the default agent.
pub fn agent_for(registry: &str) -> ureq::Agent {
if explicit_local(registry) {
return agent().build();
}
agent()
.resolver(|addr: &str| -> std::io::Result<Vec<SocketAddr>> {
let ok: Vec<SocketAddr> = addr.to_socket_addrs()?.filter(|a| is_public(a.ip())).collect();
if ok.is_empty() {
return Err(std::io::Error::other(format!("refusing non-public address for {addr}")));
}
Ok(ok)
})
.build()
}
/// Registry-supplied digests end up in URLs and cache paths: only accept canonical sha256.
fn check_digest(d: &str) -> Result<&str> {
let hex = d.strip_prefix("sha256:").ok_or_else(|| anyhow!("unsupported digest {d:?}"))?;
if hex.len() != 64 || !hex.bytes().all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)) {
bail!("malformed digest {d:?}");
}
Ok(d)
}
/// Reference parts go into registry URLs: no traversal, only the OCI distribution-spec charset.
fn validate_ref(r: &Ref) -> Result<()> {
let comp = |c: &str| !c.is_empty() && c != "." && c != ".." && c.bytes().all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b"._-".contains(&b));
let (host, port) = r.registry.split_once(':').unwrap_or((&r.registry, "443"));
let label = |l: &str| !l.is_empty() && l.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-');
if !host.split('.').all(label) || port.parse::<u16>().is_err() {
bail!("bad registry {:?}", r.registry);
}
if !r.repo.split('/').all(comp) {
bail!("bad repository {:?}", r.repo);
}
if r.reference.contains(':') {
check_digest(&r.reference)?;
} else if r.reference.is_empty() || r.reference.len() > 128 || !r.reference.bytes().all(|b| b.is_ascii_alphanumeric() || b"._-".contains(&b)) || r.reference.starts_with(['.', '-']) {
bail!("bad tag {:?}", r.reference);
}
Ok(())
}
struct Client {
agent: ureq::Agent,
base: String,
token: Option<String>,
}
impl Client {
fn get(&mut self, path: &str, accept: &str) -> Result<ureq::Response> {
let url = format!("{}{}", self.base, path);
for _ in 0..2 {
let mut req = self.agent.get(&url).set("Accept", accept);
if let Some(t) = &self.token {
req = req.set("Authorization", &format!("Bearer {t}"));
}
match req.call() {
Ok(r) => return Ok(r),
Err(ureq::Error::Status(401, r)) if self.token.is_none() => {
let h = r.header("www-authenticate").ok_or_else(|| anyhow!("401 without challenge"))?;
self.token = Some(fetch_token(&self.agent, h)?);
}
Err(e) => return Err(anyhow!("GET {url}: {e}")),
}
}
bail!("GET {url}: unauthorized (private images are not supported)")
}
fn json(&mut self, path: &str, accept: &str) -> Result<(Value, String)> {
let mut body = Vec::new();
self.get(path, accept)?.into_reader().take(4 << 20).read_to_end(&mut body)?; // manifests are small
let digest = format!("sha256:{}", hex::encode(Sha256::digest(&body)));
Ok((serde_json::from_slice(&body)?, digest))
}
}
fn fetch_token(agent: &ureq::Agent, challenge: &str) -> Result<String> {
let rest = challenge.strip_prefix("Bearer ").ok_or_else(|| anyhow!("unsupported auth: {challenge}"))?;
let mut realm = String::new();
let mut query = Vec::new();
for part in rest.split("\",") {
let (k, v) = part.split_once('=').unwrap_or((part, ""));
let v = v.trim_matches('"');
match k.trim() {
"realm" => realm = v.to_string(),
k => query.push((k.to_string(), v.to_string())),
}
}
if !realm.starts_with("https://") {
bail!("refusing non-https auth realm {realm:?}");
}
let mut req = agent.get(&realm);
for (k, v) in &query {
req = req.query(k, v);
}
let v: Value = serde_json::from_reader(req.call()?.into_reader().take(1 << 20))?;
v["token"].as_str().or(v["access_token"].as_str()).map(String::from).ok_or_else(|| anyhow!("no token in auth response"))
}
/// Tags move; re-resolve a cached tag after this long (digest refs never change).
const REF_TTL: std::time::Duration = std::time::Duration::from_secs(24 * 3600);
/// Pull (or reuse cached) image, returning its flattened rootfs tar + config.
pub fn pull(home: &Path, image: &str, refresh: bool) -> Result<Image> {
validate_ref(&parse_ref(image)).with_context(|| format!("invalid image reference {image:?}"))?;
fs::create_dir_all(home.join("images/refs"))?;
let ref_file = ref_path(home, image);
let old = fs::read_to_string(&ref_file).ok().map(|d| d.trim().to_string());
let Some(img) = old.as_deref().and_then(|d| load(home, d).ok()) else { return fetch(home, image, &ref_file) };
let age = fs::metadata(&ref_file).and_then(|m| m.modified()).ok().and_then(|t| t.elapsed().ok());
if !refresh && (image.contains('@') || age.is_some_and(|a| a < REF_TTL)) {
return Ok(img);
}
match fetch(home, image, &ref_file) {
Ok(new) => {
drop_unreferenced(home, &img.digest)?; // tag moved: the old multi-GB tar is dead weight
Ok(new)
}
Err(e) if !refresh => {
eprintln!("wsbx: could not re-resolve {image} ({e:#}); using cached copy");
Ok(img)
}
Err(e) => Err(e),
}
}
/// Flattened name for humans plus a hash of the exact reference, so `a_b:t` and `a/b:t` never share a ref file.
/// (Pre-hash ref files are simply ignored: the image is re-resolved and gc drops them.)
fn ref_path(home: &Path, image: &str) -> PathBuf {
let h = hex::encode(Sha256::digest(image));
home.join("images/refs").join(format!("{}-{}", image.replace(['/', ':', '@'], "_"), &h[..16]))
}
fn image_dir(home: &Path, digest: &str) -> PathBuf {
home.join("images").join(digest.replace(':', "-"))
}
/// Remove an image unless some ref still points at it. A VM still provisioning from its tar keeps
/// its open file descriptor, so unlinking under it is safe.
fn drop_unreferenced(home: &Path, digest: &str) -> Result<()> {
let used = fs::read_dir(home.join("images/refs"))?.flatten().any(|e| fs::read_to_string(e.path()).is_ok_and(|d| d.trim() == digest));
if !used && check_digest(digest).is_ok() {
let _ = fs::remove_dir_all(image_dir(home, digest));
}
Ok(())
}
/// Delete every cached image not referenced (via its tag) by one of `keep`; returns bytes freed.
pub fn gc(home: &Path, keep: &[String]) -> Result<u64> {
let keep: HashSet<PathBuf> = keep.iter().map(|i| ref_path(home, i)).collect();
let mut live = HashSet::new();
for e in fs::read_dir(home.join("images/refs"))?.flatten() {
match fs::read_to_string(e.path()) {
Ok(d) if keep.contains(&e.path()) => drop(live.insert(image_dir(home, d.trim()))),
_ => fs::remove_file(e.path())?,
}
}
let mut freed = 0;
for e in fs::read_dir(home.join("images"))?.flatten() {
let p = e.path();
if e.file_name() == "refs" || live.contains(&p) {
continue;
}
// ponytail: also removes a .tmp dir of a pull running right now; that pull fails and can be retried
freed += fs::read_dir(&p)?.flatten().filter_map(|f| f.metadata().ok()).map(|m| m.blocks() * 512).sum::<u64>();
fs::remove_dir_all(p)?;
}
Ok(freed)
}
fn fetch(home: &Path, image: &str, ref_file: &Path) -> Result<Image> {
let r = parse_ref(image);
let mut c = Client { agent: agent_for(&r.registry), base: format!("https://{}/v2/{}", r.registry, r.repo), token: None };
eprintln!("wsbx: resolving {image}");
let (mut manifest, mut digest) = c.json(&format!("/manifests/{}", r.reference), ACCEPT)?;
if r.reference.contains(':') && digest != check_digest(&r.reference)? {
bail!("{image}: registry returned manifest {digest}, not the requested digest");
}
if let Some(list) = manifest["manifests"].as_array() {
let m = list
.iter()
.find(|m| m["platform"]["os"] == "linux" && m["platform"]["architecture"] == "arm64")
.ok_or_else(|| anyhow!("{image} has no linux/arm64 variant"))?;
let d = check_digest(m["digest"].as_str().unwrap_or(""))?.to_string();
let (m2, d2) = c.json(&format!("/manifests/{d}"), ACCEPT)?;
if d2 != d {
bail!("manifest digest mismatch");
}
(manifest, digest) = (m2, d2);
}
let dir = image_dir(home, &digest);
if let Ok(img) = load(home, &digest) {
fs::write(ref_file, &digest)?; // also bumps mtime -> TTL restarts
return Ok(img);
}
let tmp = dir.with_extension("tmp");
let _ = fs::remove_dir_all(&tmp);
fs::create_dir_all(&tmp)?;
let cfg_digest = check_digest(manifest["config"]["digest"].as_str().unwrap_or(""))?;
let cfg_path = tmp.join("config.json");
blob(&mut c, cfg_digest, &cfg_path)?;
let cfg: Value = serde_json::from_slice(&fs::read(&cfg_path)?)?;
if cfg["architecture"] != "arm64" {
bail!("{image} is not arm64");
}
let layers = manifest["layers"].as_array().ok_or_else(|| anyhow!("bad manifest"))?;
let mut paths = Vec::new();
for (i, l) in layers.iter().enumerate() {
let d = check_digest(l["digest"].as_str().unwrap_or(""))?;
let size = l["size"].as_u64().unwrap_or(0);
eprintln!("wsbx: layer {}/{} {} ({} MB)", i + 1, layers.len(), &d[7..19], size / 1_000_000);
let p = tmp.join(format!("layer{i}"));
blob(&mut c, d, &p)?;
paths.push(p);
}
eprintln!("wsbx: flattening layers");
flatten(&paths, &tmp.join("rootfs.tar"))?;
for p in paths {
fs::remove_file(p)?;
}
let _ = fs::remove_dir_all(&dir);
fs::rename(&tmp, &dir)?;
fs::write(ref_file, &digest)?;
load(home, &digest)
}
fn load(home: &Path, digest: &str) -> Result<Image> {
let dir = image_dir(home, digest);
let cfg: Value = serde_json::from_slice(&fs::read(dir.join("config.json"))?)?;
let rootfs = dir.join("rootfs.tar");
if !rootfs.exists() {
bail!("incomplete image");
}
Ok(Image { rootfs, config: cfg["config"].clone(), digest: digest.to_string() })
}
pub struct HashWriter<W: Write>(pub W, pub Sha256);
impl<W: Write> Write for HashWriter<W> {
fn write(&mut self, b: &[u8]) -> std::io::Result<usize> {
let n = self.0.write(b)?;
self.1.update(&b[..n]);
Ok(n)
}
fn flush(&mut self) -> std::io::Result<()> {
self.0.flush()
}
}
fn blob(c: &mut Client, digest: &str, out: &Path) -> Result<()> {
let mut w = HashWriter(File::create(out)?, Sha256::new());
std::io::copy(&mut c.get(&format!("/blobs/{digest}"), "*/*")?.into_reader(), &mut w)?;
let got = format!("sha256:{}", hex::encode(w.1.finalize()));
if got != digest {
bail!("digest mismatch for {digest}: got {got}");
}
Ok(())
}
fn open_layer(p: &Path) -> Result<Box<dyn Read>> {
let mut f = BufReader::new(File::open(p)?);
let mut magic = [0u8; 4];
f.read_exact(&mut magic)?;
let f = BufReader::new(File::open(p)?);
Ok(match magic {
[0x1f, 0x8b, ..] => Box::new(flate2::read::GzDecoder::new(f)),
[0x28, 0xb5, 0x2f, 0xfd] => bail!("zstd layers are not supported yet"),
_ => Box::new(f),
})
}
fn norm(p: &Path) -> String {
let s = p.to_string_lossy();
s.trim_start_matches("./").trim_start_matches('/').trim_end_matches('/').to_string()
}
/// Strict ancestors of a path: "a/b/c" -> "a", "a/b".
fn ancestors(p: &str) -> impl Iterator<Item = &str> {
p.match_indices('/').map(move |(i, _)| &p[..i])
}
/// Merge layers (bottom first in `layers`) into one tar.
/// Pass 1 walks top-down to decide which entries survive; pass 2 writes bottom-up
/// so parents are created before children and upper metadata wins.
pub fn flatten(layers: &[PathBuf], out: &Path) -> Result<()> {
let mut keep: Vec<Vec<bool>> = vec![Vec::new(); layers.len()];
let mut seen: HashSet<String> = HashSet::new(); // every path provided by an upper layer
let mut files: HashSet<String> = HashSet::new(); // non-dirs from upper layers
let mut gone: HashSet<String> = HashSet::new(); // whiteouts + opaque dirs (hide lower content)
let mut opaque: HashSet<String> = HashSet::new();
for (li, lp) in layers.iter().enumerate().rev() {
let (mut new_gone, mut new_opaque) = (Vec::new(), Vec::new());
let mut ar = tar::Archive::new(open_layer(lp)?);
for e in ar.entries()? {
let e = e?;
let p = norm(&e.path()?);
let (dir, name) = p.rsplit_once('/').map(|(d, n)| (d.to_string(), n)).unwrap_or((String::new(), p.as_str()));
let mut k = false;
if name == ".wh..wh..opq" {
new_opaque.push(dir);
} else if let Some(n) = name.strip_prefix(".wh.") {
new_gone.push(if dir.is_empty() { n.to_string() } else { format!("{dir}/{n}") });
} else if !p.is_empty() {
let is_dir = e.header().entry_type().is_dir();
let hidden = gone.contains(&p)
|| ancestors(&p).any(|a| gone.contains(a) || opaque.contains(a) || files.contains(a))
|| (seen.contains(&p) && (!is_dir || files.contains(&p)));
if !hidden {
k = true;
seen.insert(p.clone());
if !is_dir {
files.insert(p);
}
}
}
keep[li].push(k);
}
gone.extend(new_gone);
opaque.extend(new_opaque);
}
let mut b = tar::Builder::new(std::io::BufWriter::new(File::create(out)?));
for (li, lp) in layers.iter().enumerate() {
let mut ar = tar::Archive::new(open_layer(lp)?);
for (i, e) in ar.entries()?.enumerate() {
let mut e = e?;
if !keep[li][i] {
continue;
}
let p = norm(&e.path()?);
let src = e.header().clone();
let t = src.entry_type();
let mut h = tar::Header::new_gnu();
h.set_mode(src.mode()?);
h.set_uid(src.uid()?);
h.set_gid(src.gid()?);
h.set_mtime(src.mtime().unwrap_or(0));
h.set_size(0);
if t.is_symlink() || t.is_hard_link() {
h.set_entry_type(t);
let target = e.link_name()?.ok_or_else(|| anyhow!("link without target: {p}"))?;
let target = if t.is_hard_link() { PathBuf::from(norm(&target)) } else { target.into_owned() };
b.append_link(&mut h, &p, target)?;
} else if t.is_file() || t == tar::EntryType::Continuous {
h.set_entry_type(tar::EntryType::Regular);
h.set_size(src.size()?);
b.append_data(&mut h, &p, &mut e)?;
} else if t.is_dir() || t.is_character_special() || t.is_block_special() || t.is_fifo() {
h.set_entry_type(t);
h.set_device_major(src.device_major().ok().flatten().unwrap_or(0))?;
h.set_device_minor(src.device_minor().ok().flatten().unwrap_or(0))?;
b.append_data(&mut h, &p, std::io::empty())?;
}
}
}
b.into_inner()?.flush()?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
fn layer(dir: &Path, name: &str, entries: &[(&str, bool)]) -> PathBuf {
let p = dir.join(name);
let mut b = tar::Builder::new(File::create(&p).unwrap());
for (path, is_dir) in entries {
let mut h = tar::Header::new_gnu();
h.set_entry_type(if *is_dir { tar::EntryType::Directory } else { tar::EntryType::Regular });
h.set_mode(0o755);
h.set_uid(0);
h.set_gid(0);
h.set_mtime(0);
h.set_size(0);
b.append_data(&mut h, path, std::io::empty()).unwrap();
}
b.finish().unwrap();
p
}
#[test]
fn whiteouts_and_opaque() {
let d = std::env::temp_dir().join(format!("wsbx-test-{}", std::process::id()));
fs::create_dir_all(&d).unwrap();
let l0 = layer(&d, "l0", &[("etc", true), ("etc/a", false), ("etc/b", false), ("opt", true), ("opt/x", false), ("f", false)]);
let l1 = layer(&d, "l1", &[("etc/.wh.a", false), ("opt/.wh..wh..opq", false), ("opt/y", false), ("f", false)]);
let out = d.join("out.tar");
flatten(&[l0, l1], &out).unwrap();
let mut ar = tar::Archive::new(File::open(&out).unwrap());
let got: Vec<String> = ar.entries().unwrap().map(|e| norm(&e.unwrap().path().unwrap())).collect();
assert_eq!(got, ["etc", "etc/b", "opt", "opt/y", "f"]);
fs::remove_dir_all(&d).unwrap();
}
#[test]
fn public_addresses() {
for ip in ["127.0.0.1", "10.1.2.3", "172.16.0.1", "192.168.64.1", "169.254.169.254", "100.64.0.1", "0.0.0.0", "::1", "fe80::1", "fd00::1", "::ffff:127.0.0.1",
"64:ff9b::7f00:1", "64:ff9b::a00:1", "64:ff9b:1::1", "2002:7f00:1::1", "2002:c0a8:101::", "::7f00:1", "::a00:1",
"2001:db8::1", "2001::1", "ff02::1"] {
assert!(!is_public(ip.parse().unwrap()), "{ip} must be rejected");
}
for ip in ["8.8.8.8", "140.82.121.4", "2606:4700::6810:84e5", "64:ff9b::808:808", "2002:808:808::1", "::ffff:8.8.8.8"] {
assert!(is_public(ip.parse().unwrap()), "{ip} must be allowed");
}
}
#[test]
fn local_registries() {
for l in ["localhost:5000", "localhost", "127.0.0.1:5000", "192.168.1.5:5000"] {
assert!(explicit_local(l), "{l}");
}
for r in ["evil.127.0.0.1.nip.io:8443", "localhost.evil.com", "ghcr.io", "8.8.8.8:443", "registry-1.docker.io"] {
assert!(!explicit_local(r), "{r}");
}
}
#[test]
fn bad_refs() {
for bad in ["alpine@sha256:../../x", "../x", "a/../b", "alpine:../x", "Alpine", "a//b"] {
assert!(validate_ref(&parse_ref(bad)).is_err(), "{bad}");
}
for ok in ["alpine", "ghcr.io/a/b:1.2", "docker/sandbox-templates:claude-code", "localhost:5000/x"] {
assert!(validate_ref(&parse_ref(ok)).is_ok(), "{ok}");
}
}
#[test]
fn ref_paths_distinct() {
let h = Path::new("/h");
assert_ne!(ref_path(h, "evil_bar:v1"), ref_path(h, "evil/bar:v1"));
assert_ne!(ref_path(h, "docker_sandbox-templates_claude-code"), ref_path(h, "docker/sandbox-templates:claude-code"));
assert_eq!(ref_path(h, "alpine"), ref_path(h, "alpine"));
}
#[test]
fn digests() {
assert!(check_digest(&format!("sha256:{}", "a".repeat(64))).is_ok());
for bad in ["sha256:../../x", "sha256:ABC", "md5:00", ""] {
assert!(check_digest(bad).is_err(), "{bad}");
}
}
#[test]
fn refs() {
let r = parse_ref("alpine");
assert_eq!((r.registry.as_str(), r.repo.as_str(), r.reference.as_str()), ("registry-1.docker.io", "library/alpine", "latest"));
let r = parse_ref("ghcr.io/a/b:1.2");
assert_eq!((r.registry.as_str(), r.repo.as_str(), r.reference.as_str()), ("ghcr.io", "a/b", "1.2"));
let r = parse_ref("localhost:5000/x");
assert_eq!((r.registry.as_str(), r.repo.as_str(), r.reference.as_str()), ("localhost:5000", "x", "latest"));
}
}