images.rs 92.8%

194 of 209 lines run, 32 of 76 functions · run #496 on main · run missed

//! Images by hash (oxygenflow#39, OxygenFlow docs/jetstream.md §8): rootfs
//! images kept site-wide for runners to fetch, so nobody copies an image
//! between machines. An image arrives as chunks (Oxygen's FastCDC, sent
//! only when this hub lacks them) and then its manifest, which is accepted
//! only when every chunk is here and the image they make has the hash it
//! is named by. Chunks are kept zstd-compressed under
//! `<data>/images/chunks`, shared by every image that has them.

use crate::db::{now_ms, Pool};
use jet::images::{is_hash, Manifest};
use std::io::Write;
use std::path::{Path, PathBuf};

/// Where this hub keeps images.
#[derive(Clone, Debug)]
pub struct Store {
    root: PathBuf,
}

impl Store {
    pub fn new(data: &Path) -> Store {
        Store { root: data.join("images") }
    }

    fn chunk_path(&self, hash: &str) -> PathBuf {
        self.root.join("chunks").join(&hash[..2]).join(hash)
    }

    fn manifest_path(&self, hash: &str) -> PathBuf {
        self.root.join("manifests").join(format!("{hash}.json"))
    }

    pub fn has_chunk(&self, hash: &str) -> bool {
        is_hash(hash) && self.chunk_path(hash).exists()
    }

    /// Keep chunk `hash`, whose bytes the caller has checked.
    pub fn put_chunk(&self, hash: &str, bytes: &[u8]) -> std::io::Result<()> {
        let path = self.chunk_path(hash);
        if path.exists() {
            return Ok(());
        }
        std::fs::create_dir_all(path.parent().expect("a chunk's directory"))?;
        let tmp = path.with_extension(format!("tmp{}", std::process::id()));
        let mut f = std::fs::File::create(&tmp)?;
        f.write_all(&zstd::encode_all(bytes, 3)?)?;
        f.sync_all()?;
        std::fs::rename(&tmp, &path)
    }

    pub fn chunk(&self, hash: &str) -> std::io::Result<Vec<u8>> {
        if !is_hash(hash) {
            return Err(std::io::Error::new(std::io::ErrorKind::NotFound, "not a chunk name"));
        }
        zstd::decode_all(std::fs::File::open(self.chunk_path(hash))?)
    }

    pub fn manifest(&self, hash: &str) -> Option<Manifest> {
        if !is_hash(hash) {
            return None;
        }
        serde_json::from_slice(&std::fs::read(self.manifest_path(hash)).ok()?).ok()
    }

    /// Accept manifest `m`: well formed, every chunk here, and the image
    /// they make hashing to its name. Reads the whole image once.
    pub fn verify_and_keep(&self, m: &Manifest) -> Result<(), String> {
        m.check().map_err(|e| e.to_string())?;
        let mut whole = blake3::Hasher::new();
        for c in &m.chunks {
            if c.is_zeros() {
                whole.update(&vec![0u8; c.len()]);
                continue;
            }
            let bytes = self.chunk(c.hash()).map_err(|_| format!("chunk {} was not sent; send it first", &c.hash()[..12]))?;
            if bytes.len() != c.len() {
                return Err(format!("chunk {} is {} bytes, not {}", &c.hash()[..12], bytes.len(), c.len()));
            }
            whole.update(&bytes);
        }
        let got = whole.finalize().to_hex().to_string();
        if got != m.hash {
            return Err(format!("the chunks make an image named {}, not {}", &got[..12], &m.hash[..12]));
        }
        self.keep_manifest(m)
    }

    /// Write manifest `m`, whose image is here.
    fn keep_manifest(&self, m: &Manifest) -> Result<(), String> {
        let path = self.manifest_path(&m.hash);
        std::fs::create_dir_all(path.parent().expect("the manifests directory")).map_err(|e| e.to_string())?;
        let tmp = path.with_extension("json.tmp");
        std::fs::write(&tmp, serde_json::to_vec(m).map_err(|e| e.to_string())?).map_err(|e| e.to_string())?;
        std::fs::rename(&tmp, &path).map_err(|e| e.to_string())
    }

    /// What image `m` is for, read from its own files (OxygenFlow spec
    /// §11.2, oxygenhub#173): its shell's ELF header, found through its ext4
    /// out of the kept chunks, a few of them, not the whole image. `None`
    /// when it is not ext4 or has no shell to read.
    pub fn read_arch(&self, m: &Manifest) -> Option<&'static str> {
        let mut starts = Vec::with_capacity(m.chunks.len());
        let mut end = 0u64;
        for c in &m.chunks {
            starts.push(end);
            end += c.len() as u64;
        }
        let mut cache: std::collections::HashMap<usize, Vec<u8>> = std::collections::HashMap::new();
        let short = || std::io::Error::new(std::io::ErrorKind::UnexpectedEof, "past the image's end");
        jet::rootfs::arch(&mut |at: u64, buf: &mut [u8]| {
            let mut done = 0usize;
            while done < buf.len() {
                let pos = at + done as u64;
                let i = starts.partition_point(|&s| s <= pos).checked_sub(1).ok_or_else(short)?;
                let c = &m.chunks[i];
                let within = (pos - starts[i]) as usize;
                if within >= c.len() {
                    return Err(short());
                }
                let n = (c.len() - within).min(buf.len() - done);
                if c.is_zeros() {
                    buf[done..done + n].fill(0);
                } else {
                    if !cache.contains_key(&i) {
                        if cache.len() >= 32 {
                            cache.clear();
                        }
                        cache.insert(i, self.chunk(c.hash())?);
                    }
                    let bytes = &cache[&i];
                    if bytes.len() != c.len() {
                        return Err(short());
                    }
                    buf[done..done + n].copy_from_slice(&bytes[within..within + n]);
                }
                done += n;
            }
            Ok(())
        })
    }

    /// Keep image `m`, checked as [`Store::verify_and_keep`], with the
    /// architecture its own files name: the manifest's word is taken only
    /// when the image cannot be read. The manifest as kept.
    pub fn keep_reading_arch(&self, m: &Manifest) -> Result<Manifest, String> {
        self.verify_and_keep(m)?;
        match self.read_arch(m) {
            Some(a) if m.arch.as_deref() != Some(a) => {
                let mut kept = m.clone();
                kept.arch = Some(a.to_string());
                self.keep_manifest(&kept)?;
                Ok(kept)
            }
            _ => Ok(m.clone()),
        }
    }

    /// Record `arch` in kept image `hash`'s manifest.
    fn set_arch(&self, hash: &str, arch: &str) -> Result<(), String> {
        let mut m = self.manifest(hash).ok_or("no such image")?;
        m.arch = Some(arch.to_string());
        self.keep_manifest(&m)
    }
}

/// Record an image this hub now keeps.
pub async fn record(pool: &Pool, m: &Manifest, uploader: &str) -> sqlx::Result<()> {
    sqlx::query(
        "INSERT INTO jet_images (hash, size, arch, chunks, uploader, created_ms) VALUES ($1, $2, $3, $4, $5, $6) \
         ON CONFLICT (hash) DO UPDATE SET arch = excluded.arch WHERE excluded.arch != ''",
    )
    .bind(&m.hash)
    .bind(m.size as i64)
    .bind(m.arch.clone().unwrap_or_default())
    .bind(m.chunks.len() as i64)
    .bind(uploader)
    .bind(now_ms())
    .execute(pool)
    .await?;
    if let Some(a) = m.arch.as_ref().filter(|a| !a.is_empty()) {
        crate::db::flow::record_image_archs(pool, &[(m.hash.clone(), a.clone())].into_iter().collect()).await?;
    }
    Ok(())
}

/// Learn what every image is for (oxygenhub#173), once at start: read
/// each kept image that has no architecture from its own files, then give
/// any image still unknown the architecture its jobs passed on. A runner's
/// own report, read from the image it holds, wins over what was learned.
/// How many images were read.
pub async fn learn_archs(app: &crate::Shared) -> sqlx::Result<usize> {
    let mut read = 0;
    for k in kept(&app.db).await?.into_iter().filter(|k| k.arch.is_empty()) {
        let store = app.images();
        let hash = k.hash.clone();
        let arch = tokio::task::spawn_blocking(move || {
            let a = store.read_arch(&store.manifest(&hash)?)?;
            store.set_arch(&hash, a).ok()?;
            Some(a)
        })
        .await
        .ok()
        .flatten();
        if let Some(a) = arch {
            sqlx::query("UPDATE jet_images SET arch = $1 WHERE hash = $2").bind(a).bind(&k.hash).execute(&app.db).await?;
            crate::db::flow::record_image_archs(&app.db, &[(k.hash.clone(), a.to_string())].into_iter().collect()).await?;
            read += 1;
        }
    }
    crate::db::flow::learn_archs_from_runs(&app.db).await?;
    Ok(read)
}

/// Every image this hub keeps, by hash.
pub async fn held(pool: &Pool) -> sqlx::Result<std::collections::HashSet<String>> {
    Ok(sqlx::query_scalar::<_, String>("SELECT hash FROM jet_images").fetch_all(pool).await?.into_iter().collect())
}

/// An image this hub keeps (`jet_images`).
#[derive(sqlx::FromRow)]
pub struct Kept {
    pub hash: String,
    pub size: i64,
    pub arch: String,
    pub chunks: i64,
    pub uploader: String,
    pub created_ms: i64,
}

pub async fn kept(pool: &Pool) -> sqlx::Result<Vec<Kept>> {
    sqlx::query_as("SELECT hash, size, arch, chunks, uploader, created_ms FROM jet_images").fetch_all(pool).await
}

/// One repository's use of one image: its jobs since `since_ms`, and when
/// it last ran one.
#[derive(sqlx::FromRow)]
pub struct Use {
    pub image: String,
    pub owner: String,
    pub name: String,
    pub jobs: i64,
    pub last_ms: i64,
}

/// What each repository's jobs ran on since `since_ms`, newest first.
pub async fn uses(pool: &Pool, since_ms: i64) -> sqlx::Result<Vec<Use>> {
    let rootfs = crate::db::json_text("j.sandbox", "rootfs");
    sqlx::query_as(&format!(
        "SELECT lower({rootfs}) AS image, p.owner, p.name, COUNT(*) AS jobs,
                MAX(COALESCE(j.started_ms, r.created_ms)) AS last_ms
         FROM flow_jobs j JOIN flow_runs r ON r.id = j.run_id JOIN repositories p ON p.id = r.repo_id
         WHERE r.created_ms >= $1 AND COALESCE({rootfs}, '') != ''
         GROUP BY lower({rootfs}), p.id, p.owner, p.name ORDER BY last_ms DESC"
    ))
    .bind(since_ms)
    .fetch_all(pool)
    .await
}

/// What one repository's jobs ran on since `since_ms`, newest first
/// (its Images page, oxygenhub#254).
pub async fn uses_of(pool: &Pool, repo_id: i64, since_ms: i64) -> sqlx::Result<Vec<Use>> {
    let rootfs = crate::db::json_text("j.sandbox", "rootfs");
    sqlx::query_as(&format!(
        "SELECT lower({rootfs}) AS image, p.owner, p.name, COUNT(*) AS jobs,
                MAX(COALESCE(j.started_ms, r.created_ms)) AS last_ms
         FROM flow_jobs j JOIN flow_runs r ON r.id = j.run_id JOIN repositories p ON p.id = r.repo_id
         WHERE r.created_ms >= $1 AND p.id = $2 AND COALESCE({rootfs}, '') != ''
         GROUP BY lower({rootfs}), p.id, p.owner, p.name ORDER BY last_ms DESC"
    ))
    .bind(since_ms)
    .bind(repo_id)
    .fetch_all(pool)
    .await
}

/// The architecture runners reported for each image (`flow_images`).
pub async fn reported_archs(pool: &Pool) -> sqlx::Result<std::collections::HashMap<String, String>> {
    Ok(sqlx::query_as::<_, (String, String)>("SELECT hash, arch FROM flow_images").fetch_all(pool).await?.into_iter().collect())
}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

1		//! Images by hash (oxygenflow#39, OxygenFlow docs/jetstream.md §8): rootfs
2		//! images kept site-wide for runners to fetch, so nobody copies an image
3		//! between machines. An image arrives as chunks (Oxygen's FastCDC, sent
4		//! only when this hub lacks them) and then its manifest, which is accepted
5		//! only when every chunk is here and the image they make has the hash it
6		//! is named by. Chunks are kept zstd-compressed under
7		//! `<data>/images/chunks`, shared by every image that has them.
8
9		use crate::db::{now_ms, Pool};
10		use jet::images::{is_hash, Manifest};
11		use std::io::Write;
12		use std::path::{Path, PathBuf};
13
14		/// Where this hub keeps images.
15		#[derive(Clone, Debug)]
16		pub struct Store {
17		root: PathBuf,
18		}
19
20		impl Store {
21	25×	pub fn new(data: &Path) -> Store {
22	25×	Store { root: data.join("images") }
23	25×	}
24
25	60036×	fn chunk_path(&self, hash: &str) -> PathBuf {
26	60036×	self.root.join("chunks").join(&hash[..2]).join(hash)
27	60036×	}
28
29	17×	fn manifest_path(&self, hash: &str) -> PathBuf {
30	17×	self.root.join("manifests").join(format!("{hash}.json"))
31	17×	}
32
33	60006×	pub fn has_chunk(&self, hash: &str) -> bool {
34	60006×	is_hash(hash) && self.chunk_path(hash).exists()
35	60006×	}
36
37		/// Keep chunk `hash`, whose bytes the caller has checked.
38	8×	pub fn put_chunk(&self, hash: &str, bytes: &[u8]) -> std::io::Result<()> {
39	8×	let path = self.chunk_path(hash);
40	8×	if path.exists() {
41	0×	return Ok(());
42	8×	}
43	8×	std::fs::create_dir_all(path.parent().expect("a chunk's directory"))?;
44	8×	let tmp = path.with_extension(format!("tmp{}", std::process::id()));
45	8×	let mut f = std::fs::File::create(&tmp)?;
46	8×	f.write_all(&zstd::encode_all(bytes, 3)?)?;
47	8×	f.sync_all()?;
48	8×	std::fs::rename(&tmp, &path)
49	8×	}
50
51	22×	pub fn chunk(&self, hash: &str) -> std::io::Result<Vec<u8>> {
52	22×	if !is_hash(hash) {
53	0×	return Err(std::io::Error::new(std::io::ErrorKind::NotFound, "not a chunk name"));
54	22×	}
55	22×	zstd::decode_all(std::fs::File::open(self.chunk_path(hash))?)
56	22×	}
57
58	12×	pub fn manifest(&self, hash: &str) -> Option<Manifest> {
59	12×	if !is_hash(hash) {
60	0×	return None;
61	12×	}
62	12×	serde_json::from_slice(&std::fs::read(self.manifest_path(hash)).ok()?).ok()
63	12×	}
64
65		/// Accept manifest `m`: well formed, every chunk here, and the image
66		/// they make hashing to its name. Reads the whole image once.
67	5×	pub fn verify_and_keep(&self, m: &Manifest) -> Result<(), String> {
68	5×	m.check().map_err(\|e\| e.to_string())?;
69	5×	let mut whole = blake3::Hasher::new();
70	55×	for c in &m.chunks {
71	55×	if c.is_zeros() {
72	43×	whole.update(&vec![0u8; c.len()]);
73	43×	continue;
74	12×	}
75	12×	let bytes = self.chunk(c.hash()).map_err(\|_\| format!("chunk {} was not sent; send it first", &c.hash()[..12]))?;
76	11×	if bytes.len() != c.len() {
77	0×	return Err(format!("chunk {} is {} bytes, not {}", &c.hash()[..12], bytes.len(), c.len()));
78	11×	}
79	11×	whole.update(&bytes);
80		}
81	4×	let got = whole.finalize().to_hex().to_string();
82	4×	if got != m.hash {
83	1×	return Err(format!("the chunks make an image named {}, not {}", &got[..12], &m.hash[..12]));
84	3×	}
85	3×	self.keep_manifest(m)
86	5×	}
87
88		/// Write manifest `m`, whose image is here.
89	5×	fn keep_manifest(&self, m: &Manifest) -> Result<(), String> {
90	5×	let path = self.manifest_path(&m.hash);
91	5×	std::fs::create_dir_all(path.parent().expect("the manifests directory")).map_err(\|e\| e.to_string())?;
92	5×	let tmp = path.with_extension("json.tmp");
93	5×	std::fs::write(&tmp, serde_json::to_vec(m).map_err(\|e\| e.to_string())?).map_err(\|e\| e.to_string())?;
94	5×	std::fs::rename(&tmp, &path).map_err(\|e\| e.to_string())
95	5×	}
96
97		/// What image `m` is for, read from its own files (OxygenFlow spec
98		/// §11.2, oxygenhub#173): its shell's ELF header, found through its ext4
99		/// out of the kept chunks, a few of them, not the whole image. `None`
100		/// when it is not ext4 or has no shell to read.
101	5×	pub fn read_arch(&self, m: &Manifest) -> Option<&'static str> {
102	5×	let mut starts = Vec::with_capacity(m.chunks.len());
103	5×	let mut end = 0u64;
104	78×	for c in &m.chunks {
105	78×	starts.push(end);
106	78×	end += c.len() as u64;
107	78×	}
108	5×	let mut cache: std::collections::HashMap<usize, Vec<u8>> = std::collections::HashMap::new();
109	5×	let short = \|\| std::io::Error::new(std::io::ErrorKind::UnexpectedEof, "past the image's end");
110	31×	jet::rootfs::arch(&mut \|at: u64, buf: &mut [u8]\| {
111	31×	let mut done = 0usize;
112	62×	while done < buf.len() {
113	31×	let pos = at + done as u64;
114	177×	let i = starts.partition_point(\|&s\| s <= pos).checked_sub(1).ok_or_else(short)?;
115	31×	let c = &m.chunks[i];
116	31×	let within = (pos - starts[i]) as usize;
117	31×	if within >= c.len() {
118	0×	return Err(short());
119	31×	}
120	31×	let n = (c.len() - within).min(buf.len() - done);
121	31×	if c.is_zeros() {
122	0×	buf[done..done + n].fill(0);
123	0×	} else {
124	31×	if !cache.contains_key(&i) {
125	7×	if cache.len() >= 32 {
126	0×	cache.clear();
127	7×	}
128	7×	cache.insert(i, self.chunk(c.hash())?);
129	24×	}
130	31×	let bytes = &cache[&i];
131	31×	if bytes.len() != c.len() {
132	0×	return Err(short());
133	31×	}
134	31×	buf[done..done + n].copy_from_slice(&bytes[within..within + n]);
135		}
136	31×	done += n;
137		}
138	31×	Ok(())
139	31×	})
140	5×	}
141
142		/// Keep image `m`, checked as [`Store::verify_and_keep`], with the
143		/// architecture its own files name: the manifest's word is taken only
144		/// when the image cannot be read. The manifest as kept.
145	5×	pub fn keep_reading_arch(&self, m: &Manifest) -> Result<Manifest, String> {
146	5×	self.verify_and_keep(m)?;
147	3×	match self.read_arch(m) {
148	1×	Some(a) if m.arch.as_deref() != Some(a) => {
149	1×	let mut kept = m.clone();
150	1×	kept.arch = Some(a.to_string());
151	1×	self.keep_manifest(&kept)?;
152	1×	Ok(kept)
153		}
154	2×	_ => Ok(m.clone()),
155		}
156	5×	}
157
158		/// Record `arch` in kept image `hash`'s manifest.
159	1×	fn set_arch(&self, hash: &str, arch: &str) -> Result<(), String> {
160	1×	let mut m = self.manifest(hash).ok_or("no such image")?;
161	1×	m.arch = Some(arch.to_string());
162	1×	self.keep_manifest(&m)
163	1×	}
164		}
165
166		/// Record an image this hub now keeps.
167	4×	pub async fn record(pool: &Pool, m: &Manifest, uploader: &str) -> sqlx::Result<()> {
168	4×	sqlx::query(
169	4×	"INSERT INTO jet_images (hash, size, arch, chunks, uploader, created_ms) VALUES ($1, $2, $3, $4, $5, $6) \
170	4×	ON CONFLICT (hash) DO UPDATE SET arch = excluded.arch WHERE excluded.arch != ''",
171	4×	)
172	4×	.bind(&m.hash)
173	4×	.bind(m.size as i64)
174	4×	.bind(m.arch.clone().unwrap_or_default())
175	4×	.bind(m.chunks.len() as i64)
176	4×	.bind(uploader)
177	4×	.bind(now_ms())
178	4×	.execute(pool)
179	4×	.await?;
180	4×	if let Some(a) = m.arch.as_ref().filter(\|a\| !a.is_empty()) {
181	3×	crate::db::flow::record_image_archs(pool, &[(m.hash.clone(), a.clone())].into_iter().collect()).await?;
182	1×	}
183	4×	Ok(())
184	4×	}
185
186		/// Learn what every image is for (oxygenhub#173), once at start: read
187		/// each kept image that has no architecture from its own files, then give
188		/// any image still unknown the architecture its jobs passed on. A runner's
189		/// own report, read from the image it holds, wins over what was learned.
190		/// How many images were read.
191	192×	pub async fn learn_archs(app: &crate::Shared) -> sqlx::Result<usize> {
192	192×	let mut read = 0;
193	192×	for k in kept(&app.db).await?.into_iter().filter(\|k\| k.arch.is_empty()) {
194	2×	let store = app.images();
195	2×	let hash = k.hash.clone();
196	2×	let arch = tokio::task::spawn_blocking(move \|\| {
197	2×	let a = store.read_arch(&store.manifest(&hash)?)?;
198	1×	store.set_arch(&hash, a).ok()?;
199	1×	Some(a)
200	2×	})
201	2×	.await
202	2×	.ok()
203	2×	.flatten();
204	2×	if let Some(a) = arch {
205	1×	sqlx::query("UPDATE jet_images SET arch = $1 WHERE hash = $2").bind(a).bind(&k.hash).execute(&app.db).await?;
206	1×	crate::db::flow::record_image_archs(&app.db, &[(k.hash.clone(), a.to_string())].into_iter().collect()).await?;
207	1×	read += 1;
208	1×	}
209		}
210	192×	crate::db::flow::learn_archs_from_runs(&app.db).await?;
211	192×	Ok(read)
212	192×	}
213
214		/// Every image this hub keeps, by hash.
215	377×	pub async fn held(pool: &Pool) -> sqlx::Result<std::collections::HashSet<String>> {
216	377×	Ok(sqlx::query_scalar::<_, String>("SELECT hash FROM jet_images").fetch_all(pool).await?.into_iter().collect())
217	377×	}
218
219		/// An image this hub keeps (`jet_images`).
220		#[derive(sqlx::FromRow)]
221		pub struct Kept {
222		pub hash: String,
223		pub size: i64,
224		pub arch: String,
225		pub chunks: i64,
226		pub uploader: String,
227		pub created_ms: i64,
228		}
229
230	195×	pub async fn kept(pool: &Pool) -> sqlx::Result<Vec<Kept>> {
231	195×	sqlx::query_as("SELECT hash, size, arch, chunks, uploader, created_ms FROM jet_images").fetch_all(pool).await
232	195×	}
233
234		/// One repository's use of one image: its jobs since `since_ms`, and when
235		/// it last ran one.
236		#[derive(sqlx::FromRow)]
237		pub struct Use {
238		pub image: String,
239		pub owner: String,
240		pub name: String,
241		pub jobs: i64,
242		pub last_ms: i64,
243		}
244
245		/// What each repository's jobs ran on since `since_ms`, newest first.
246	2×	pub async fn uses(pool: &Pool, since_ms: i64) -> sqlx::Result<Vec<Use>> {
247	2×	let rootfs = crate::db::json_text("j.sandbox", "rootfs");
248	2×	sqlx::query_as(&format!(
249	2×	"SELECT lower({rootfs}) AS image, p.owner, p.name, COUNT(*) AS jobs,
250	2×	MAX(COALESCE(j.started_ms, r.created_ms)) AS last_ms
251	2×	FROM flow_jobs j JOIN flow_runs r ON r.id = j.run_id JOIN repositories p ON p.id = r.repo_id
252	2×	WHERE r.created_ms >= $1 AND COALESCE({rootfs}, '') != ''
253	2×	GROUP BY lower({rootfs}), p.id, p.owner, p.name ORDER BY last_ms DESC"
254	2×	))
255	2×	.bind(since_ms)
256	2×	.fetch_all(pool)
257	2×	.await
258	2×	}
259
260		/// What one repository's jobs ran on since `since_ms`, newest first
261		/// (its Images page, oxygenhub#254).
262	1×	pub async fn uses_of(pool: &Pool, repo_id: i64, since_ms: i64) -> sqlx::Result<Vec<Use>> {
263	1×	let rootfs = crate::db::json_text("j.sandbox", "rootfs");
264	1×	sqlx::query_as(&format!(
265	1×	"SELECT lower({rootfs}) AS image, p.owner, p.name, COUNT(*) AS jobs,
266	1×	MAX(COALESCE(j.started_ms, r.created_ms)) AS last_ms
267	1×	FROM flow_jobs j JOIN flow_runs r ON r.id = j.run_id JOIN repositories p ON p.id = r.repo_id
268	1×	WHERE r.created_ms >= $1 AND p.id = $2 AND COALESCE({rootfs}, '') != ''
269	1×	GROUP BY lower({rootfs}), p.id, p.owner, p.name ORDER BY last_ms DESC"
270	1×	))
271	1×	.bind(since_ms)
272	1×	.bind(repo_id)
273	1×	.fetch_all(pool)
274	1×	.await
275	1×	}
276
277		/// The architecture runners reported for each image (`flow_images`).
278	2×	pub async fn reported_archs(pool: &Pool) -> sqlx::Result<std::collections::HashMap<String, String>> {
279	2×	Ok(sqlx::query_as::<_, (String, String)>("SELECT hash, arch FROM flow_images").fetch_all(pool).await?.into_iter().collect())
280	2×	}

Coverage / crates/hub/src/images.rs 92.8%

Keyboard