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
|
use std::collections::HashSet;
use std::fs;
use std::path::{Path, PathBuf};
use anyhow::{bail, Context, Result};
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ArtifactManifest {
pub packages: Vec<PackageRecord>,
pub files: Vec<FileRecord>,
pub initrd: Option<InitrdRecord>,
pub services: Vec<ServiceRecord>,
pub archive_members: Vec<ArchiveMemberRecord>,
}
impl ArtifactManifest {
pub fn new(
mut packages: Vec<PackageRecord>,
mut files: Vec<FileRecord>,
initrd: Option<InitrdRecord>,
mut services: Vec<ServiceRecord>,
mut archive_members: Vec<ArchiveMemberRecord>,
) -> Result<Self> {
packages.sort_by(|left, right| left.name.cmp(&right.name));
files.sort_by(|left, right| left.path.cmp(&right.path));
services.sort_by(|left, right| left.name.cmp(&right.name));
archive_members.sort_by(|left, right| left.path.cmp(&right.path));
ensure_unique("package", packages.iter().map(|record| record.name.as_str()))?;
ensure_unique("file", files.iter().map(|record| record.path.as_str()))?;
ensure_unique("service", services.iter().map(|record| record.name.as_str()))?;
ensure_unique("archive member", archive_members.iter().map(|record| record.path.as_str()))?;
Ok(Self { packages, files, initrd, services, archive_members })
}
pub fn load(path: impl AsRef<Path>) -> Result<Self> {
let path = path.as_ref();
let text = fs::read_to_string(path).with_context(|| format!("read artifact manifest {}", path.display()))?;
let manifest: Self = toml::from_str(&text).with_context(|| format!("parse artifact manifest {}", path.display()))?;
Self::new(manifest.packages, manifest.files, manifest.initrd, manifest.services, manifest.archive_members)
}
pub fn write_beside(&self, artifact: impl AsRef<Path>) -> Result<PathBuf> {
let artifact = artifact.as_ref();
let directory = artifact.parent().unwrap_or_else(|| Path::new("."));
let path = directory.join("artifact.manifest.toml");
let text = toml::to_string_pretty(self).context("serialize artifact manifest")?;
fs::write(&path, text).with_context(|| format!("write artifact manifest {}", path.display()))?;
Ok(path)
}
}
fn ensure_unique<'a>(kind: &str, keys: impl IntoIterator<Item = &'a str>) -> Result<()> {
let mut seen = HashSet::new();
for key in keys {
if key.is_empty() || !seen.insert(key) {
bail!("duplicate {kind} record: {key}");
}
}
Ok(())
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct PackageRecord {
pub name: String,
pub version: String,
}
impl PackageRecord {
pub fn new(name: impl Into<String>, version: impl Into<String>) -> Self {
Self { name: name.into(), version: version.into() }
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct FileRecord {
pub path: String,
pub kind: String,
pub digest: Option<String>,
pub target: Option<String>,
}
impl FileRecord {
pub fn file(path: impl Into<String>, digest: impl Into<String>) -> Self {
Self { path: path.into(), kind: "file".into(), digest: Some(digest.into()), target: None }
}
pub fn symlink(path: impl Into<String>, target: impl Into<String>) -> Self {
Self { path: path.into(), kind: "symlink".into(), digest: None, target: Some(target.into()) }
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct InitrdRecord {
pub path: String,
pub sha256: String,
}
impl InitrdRecord {
pub fn new(path: impl Into<String>, sha256: impl Into<String>) -> Self {
Self { path: path.into(), sha256: sha256.into() }
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ServiceRecord {
pub name: String,
pub enabled: bool,
}
impl ServiceRecord {
pub fn new(name: impl Into<String>, enabled: bool) -> Self {
Self { name: name.into(), enabled }
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ArchiveMemberRecord {
pub path: String,
pub kind: String,
}
impl ArchiveMemberRecord {
pub fn new(path: impl Into<String>, kind: impl Into<String>) -> Self {
Self { path: path.into(), kind: kind.into() }
}
}
|
