use crate::error::{Error, Result};
use crate::host::{Host, Layout};
use crate::manifest::validate_name;
use crate::network::store::FileLock;
use crate::provision::Provisioner;
use crate::zfs::ZfsManager;
use std::path::PathBuf;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Release {
pub name: String,
pub path: PathBuf,
pub dataset: Option<String>,
pub cloneable: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Bootstrap {
release: String,
force: bool,
archives: Option<Vec<String>>,
pkgbase: bool,
}
impl Bootstrap {
pub fn release(release: impl Into<String>) -> Self {
Self {
release: release.into(),
force: false,
archives: None,
pkgbase: false,
}
}
#[must_use]
pub const fn force(mut self) -> Self {
self.force = true;
self
}
#[must_use]
pub fn archives<I, S>(mut self, archives: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
self.archives = Some(archives.into_iter().map(Into::into).collect());
self
}
#[must_use]
pub const fn pkgbase(mut self) -> Self {
self.pkgbase = true;
self
}
fn uses_pkgbase(&self) -> bool {
self.pkgbase
|| crate::sys::OsVersion::parse(&self.release).is_ok_and(|v| v.requires_pkgbase())
}
}
impl Host {
pub fn releases(&self) -> Result<Vec<Release>> {
let layout = self.layout();
Ok(provisioner(layout, None)?
.list_releases()?
.into_iter()
.map(|r| describe(layout, r.name, r.path))
.collect())
}
pub fn release(&self, name: &str) -> Result<Option<Release>> {
let layout = self.layout();
let provisioner = provisioner(layout, None)?;
if !provisioner.is_bootstrapped(name)? {
return Ok(None);
}
Ok(Some(describe(
layout,
name.to_string(),
provisioner.release_path(name)?,
)))
}
pub fn has_release(&self, name: &str) -> Result<bool> {
Ok(self.release(name)?.is_some())
}
pub fn bootstrap(&self, plan: &Bootstrap) -> Result<Release> {
Error::require_root("bootstrapping a release")?;
let layout = self.layout();
let release = plan.release.as_str();
validate_name("release", release)?;
let _lock = bootstrap_lock(layout, release)?;
let provisioner = provisioner(layout, plan.archives.clone())?;
let release_path = provisioner.release_path(release)?;
let zfs = layout.zfs();
let mut dataset_backed = false;
if let Some(zfs) = &zfs {
if zfs.release_dataset_exists(release)? {
dataset_backed = true;
} else if !release_path.exists() {
zfs.create_release_dataset(release, &release_path)?;
dataset_backed = true;
} else if plan.force {
crate::sys::remove_tree_with_flags(&release_path).map_err(|e| {
Error::Zfs(format!(
"Failed to remove legacy release dir '{}': {}",
release_path.display(),
e
))
})?;
zfs.create_release_dataset(release, &release_path)?;
dataset_backed = true;
}
}
if plan.uses_pkgbase() {
provisioner.bootstrap_pkgbase(release, plan.force)?;
} else {
provisioner.bootstrap(release, plan.force)?;
}
if dataset_backed && let Some(zfs) = &zfs {
zfs.snapshot_release_pristine(release)?;
}
Ok(describe(layout, release.to_string(), release_path))
}
pub fn ensure_release(&self, name: &str) -> Result<Release> {
if let Some(release) = self.release(name)? {
return Ok(release);
}
match self.bootstrap(&Bootstrap::release(name)) {
Err(Error::ReleaseAlreadyExists(_)) => self
.release(name)?
.ok_or_else(|| Error::ReleaseNotFound(name.to_string())),
other => other,
}
}
pub fn remove_release(&self, name: &str) -> Result<()> {
Error::require_root("removing a release")?;
validate_name("release", name)?;
let layout = self.layout();
let path = layout.releases_dir().join(name);
if let Some(zfs) = layout.zfs()
&& zfs.release_dataset_exists(name)?
{
zfs.destroy_dataset_without_dependents(&zfs.release_dataset(name))?;
let _ = std::fs::remove_dir(&path); return Ok(());
}
if path.exists() {
crate::blueprint::context::reject_symlink_ancestors(layout.data_dir(), &path)?;
crate::sys::remove_tree_with_flags(&path)?;
}
Ok(())
}
}
fn provisioner(layout: &Layout, archives: Option<Vec<String>>) -> Result<Provisioner> {
let config = &layout.config().config;
Provisioner::new(
config.mirror_url.clone(),
config.releases_dir.clone(),
config.cache_dir.clone(),
archives.unwrap_or_else(|| config.bootstrap_archives.clone()),
config.retry.clone(),
)
}
fn bootstrap_lock(layout: &Layout, release: &str) -> Result<FileLock> {
let path = layout
.config()
.config
.cache_dir
.join("locks")
.join(format!("bootstrap-{release}.lock"));
FileLock::acquire(&path)
}
fn describe(layout: &Layout, name: String, path: PathBuf) -> Release {
let zfs = layout.zfs();
let dataset = zfs
.as_ref()
.filter(|zfs| zfs.release_dataset_exists(&name).unwrap_or(false))
.map(|zfs| zfs.release_dataset(&name));
let cloneable = zfs
.as_ref()
.is_some_and(|zfs| zfs.release_is_cloneable(&name));
Release {
name,
path,
dataset,
cloneable,
}
}
pub fn commit_dataset(
layout: &Layout,
zfs: &ZfsManager,
dataset: &str,
release: &str,
) -> Result<Release> {
validate_name("release", release)?;
let release_path = layout.releases_dir().join(release);
if release_path.exists() {
return Err(Error::ReleaseAlreadyExists(release.to_string()));
}
zfs.commit_dataset_to_release(dataset, release, &release_path)?;
Ok(describe(layout, release.to_string(), release_path))
}
#[cfg(test)]
mod tests;