hyprstream_workers/image/
rafs_builder.rs1use std::path::{Path, PathBuf};
32use std::sync::Arc;
33
34use nydus_api::ConfigV2;
35use nydus_builder::attributes::Attributes;
36use nydus_builder::{
37 ArtifactStorage, BlobManager, BootstrapManager, BuildContext, Builder, ConversionType,
38 Features, Prefetch, TarballBuilder, WhiteoutSpec,
39};
40use nydus_rafs::metadata::RafsVersion;
41use nydus_utils::{compress, digest};
42
43use crate::error::{Result, WorkerError};
44
45const RAFS_FS_VERSION: RafsVersion = RafsVersion::V6;
50
51pub fn build_rafs_bootstrap(
65 layer_blob_paths: &[PathBuf],
66 blobs_dir: &Path,
67 bootstrap_path: &Path,
68) -> Result<PathBuf> {
69 if layer_blob_paths.is_empty() {
70 return Err(WorkerError::RafsError(
71 "cannot build RAFS bootstrap: image has no layers".to_owned(),
72 ));
73 }
74
75 let config = Arc::new(ConfigV2::default());
78
79 let mut parent_bootstrap: Option<PathBuf> = None;
84
85 let bootstrap_dir = bootstrap_path.parent().ok_or_else(|| {
89 WorkerError::RafsError(format!(
90 "bootstrap path {} has no parent directory",
91 bootstrap_path.display()
92 ))
93 })?;
94
95 let layer_count = layer_blob_paths.len();
96 for (idx, layer_path) in layer_blob_paths.iter().enumerate() {
97 let is_final = idx + 1 == layer_count;
98
99 let out_bootstrap = if is_final {
103 bootstrap_path.to_path_buf()
104 } else {
105 bootstrap_dir.join(format!(
106 ".rafs-build-{}-layer{}.meta",
107 bootstrap_basename(bootstrap_path),
108 idx
109 ))
110 };
111
112 build_one_layer(
113 layer_path,
114 blobs_dir,
115 &out_bootstrap,
116 parent_bootstrap.as_deref(),
117 idx,
118 config.clone(),
119 )?;
120
121 if let Some(prev) = parent_bootstrap.take() {
124 if prev != out_bootstrap {
125 let _ = std::fs::remove_file(&prev);
126 }
127 }
128 parent_bootstrap = Some(out_bootstrap);
129 }
130
131 if !bootstrap_path.exists() {
132 return Err(WorkerError::RafsError(format!(
133 "RAFS build completed but bootstrap {} is missing",
134 bootstrap_path.display()
135 )));
136 }
137
138 Ok(bootstrap_path.to_path_buf())
139}
140
141fn build_one_layer(
143 layer_path: &Path,
144 blobs_dir: &Path,
145 out_bootstrap: &Path,
146 parent: Option<&Path>,
147 layer_idx: usize,
148 config: Arc<ConfigV2>,
149) -> Result<()> {
150 let blob_storage = ArtifactStorage::FileDir((blobs_dir.to_path_buf(), String::new()));
153 let bootstrap_storage = ArtifactStorage::SingleFile(out_bootstrap.to_path_buf());
155
156 let mut ctx = BuildContext::new(
157 String::new(), true, 0, compress::Algorithm::Zstd, digest::Algorithm::Sha256, false, WhiteoutSpec::Oci, ConversionType::TargzToRafs, layer_path.to_path_buf(), Prefetch::default(),
169 Some(blob_storage),
170 None, false, Features::new(),
173 false, Attributes::default(),
175 );
176 ctx.set_fs_version(RAFS_FS_VERSION);
177 ctx.set_configuration(config);
178
179 let mut bootstrap_mgr = BootstrapManager::new(
180 Some(bootstrap_storage),
181 parent.map(|p| p.to_string_lossy().into_owned()),
182 );
183 let mut blob_mgr = BlobManager::new(digest::Algorithm::Sha256, false);
184
185 let mut builder = TarballBuilder::new(ConversionType::TargzToRafs);
186 builder
187 .build(&mut ctx, &mut bootstrap_mgr, &mut blob_mgr)
188 .map_err(|e| {
189 WorkerError::RafsError(format!(
190 "failed to build RAFS layer {} from {}: {e:#}",
191 layer_idx,
192 layer_path.display()
193 ))
194 })?;
195
196 Ok(())
197}
198
199pub fn bootstrap_blob_ids(bootstrap_path: &Path) -> Result<Vec<String>> {
206 let config = Arc::new(ConfigV2::default());
207 let (rs, _reader) =
208 nydus_rafs::metadata::RafsSuper::load_from_file(bootstrap_path, config, false).map_err(
209 |e| {
210 WorkerError::RafsError(format!(
211 "failed to load RAFS bootstrap {}: {e:#}",
212 bootstrap_path.display()
213 ))
214 },
215 )?;
216 Ok(rs
217 .superblock
218 .get_blob_infos()
219 .iter()
220 .map(|b| b.blob_id())
221 .collect())
222}
223
224fn bootstrap_basename(path: &Path) -> String {
227 path.file_stem()
228 .map(|s| s.to_string_lossy().into_owned())
229 .unwrap_or_else(|| "image".to_owned())
230}
231
232#[cfg(test)]
233#[allow(clippy::unwrap_used, clippy::expect_used)]
234mod tests {
235 use super::*;
236 use flate2::write::GzEncoder;
237 use flate2::Compression;
238 use nydus_rafs::metadata::RafsSuper;
239
240 fn make_gzip_layer(path: &Path, entries: &[(&str, &[u8])]) {
243 let file = std::fs::File::create(path).unwrap();
244 let gz = GzEncoder::new(file, Compression::default());
245 let mut tar = tar::Builder::new(gz);
246 for (name, data) in entries {
247 let mut header = tar::Header::new_gnu();
248 header.set_size(data.len() as u64);
249 header.set_mode(0o644);
250 header.set_mtime(0);
251 header.set_entry_type(tar::EntryType::Regular);
252 tar.append_data(&mut header, name, *data).unwrap();
253 }
254 let gz = tar.into_inner().unwrap();
255 gz.finish().unwrap();
256 }
257
258 #[test]
259 fn builds_bootstrap_from_single_layer() {
260 let tmp = tempfile::tempdir().unwrap();
261 let blobs_dir = tmp.path().join("blobs");
262 let bootstrap_dir = tmp.path().join("bootstrap");
263 std::fs::create_dir_all(&blobs_dir).unwrap();
264 std::fs::create_dir_all(&bootstrap_dir).unwrap();
265
266 let layer = tmp.path().join("layer0.tar.gz");
267 make_gzip_layer(
268 &layer,
269 &[
270 ("etc/hostname", b"worker\n"),
271 ("usr/bin/app", b"#!/bin/sh\necho hi\n"),
272 ],
273 );
274
275 let bootstrap = bootstrap_dir.join("img.meta");
276 let out = build_rafs_bootstrap(&[layer], &blobs_dir, &bootstrap).unwrap();
277 assert_eq!(out, bootstrap);
278
279 let meta = std::fs::metadata(&bootstrap).unwrap();
280 assert!(meta.len() > 0, "bootstrap must be non-empty");
281
282 let config = Arc::new(ConfigV2::default());
284 let (rs, _reader) =
285 RafsSuper::load_from_file(&bootstrap, config, false).expect("bootstrap must load");
286 assert!(rs.meta.inodes_count > 0, "RAFS must have inodes");
287 }
288
289 #[test]
290 fn builds_bootstrap_from_layered_image() {
291 let tmp = tempfile::tempdir().unwrap();
292 let blobs_dir = tmp.path().join("blobs");
293 let bootstrap_dir = tmp.path().join("bootstrap");
294 std::fs::create_dir_all(&blobs_dir).unwrap();
295 std::fs::create_dir_all(&bootstrap_dir).unwrap();
296
297 let lower = tmp.path().join("layer0.tar.gz");
298 make_gzip_layer(
299 &lower,
300 &[("etc/hostname", b"base\n"), ("etc/config", b"v1\n")],
301 );
302 let upper = tmp.path().join("layer1.tar.gz");
303 make_gzip_layer(
305 &upper,
306 &[("etc/config", b"v2\n"), ("etc/extra", b"added\n")],
307 );
308
309 let bootstrap = bootstrap_dir.join("img.meta");
310 let out = build_rafs_bootstrap(&[lower, upper], &blobs_dir, &bootstrap).unwrap();
311 assert_eq!(out, bootstrap);
312 assert!(std::fs::metadata(&bootstrap).unwrap().len() > 0);
313
314 let config = Arc::new(ConfigV2::default());
315 let (rs, _reader) =
316 RafsSuper::load_from_file(&bootstrap, config, false).expect("bootstrap must load");
317 assert!(rs.meta.inodes_count > 0);
318
319 for entry in std::fs::read_dir(&bootstrap_dir).unwrap() {
321 let name = entry.unwrap().file_name();
322 let name = name.to_string_lossy();
323 assert!(
324 !name.starts_with(".rafs-build-"),
325 "intermediate bootstrap leaked: {name}"
326 );
327 }
328 }
329}