use crate::error::{Error, Result};
use jiff::Zoned;
use std::path::{Path, PathBuf};
use std::process::Command;
fn zfs_status(args: &[&str]) -> Result<std::process::ExitStatus> {
Command::new("/sbin/zfs").args(args).status().map_err(|e| {
Error::Zfs(format!(
"Failed to run zfs {}: {}",
args.first().unwrap_or(&"?"),
e
))
})
}
fn zfs_output(args: &[&str]) -> Result<std::process::Output> {
Command::new("/sbin/zfs").args(args).output().map_err(|e| {
Error::Zfs(format!(
"Failed to run zfs {}: {}",
args.first().unwrap_or(&"?"),
e
))
})
}
fn zfs_run(args: &[&str], fail_msg: impl FnOnce() -> String) -> Result<()> {
if zfs_status(args)?.success() {
Ok(())
} else {
Err(Error::Zfs(fail_msg()))
}
}
pub struct ZfsManager {
base_dataset: String,
jails_mountpoint: PathBuf,
}
impl ZfsManager {
pub fn new(
pool: impl Into<String>,
base: impl Into<String>,
jails_mountpoint: impl Into<PathBuf>,
) -> Self {
let pool = pool.into();
let base = base.into();
Self {
base_dataset: format!("{pool}/{base}"),
jails_mountpoint: jails_mountpoint.into(),
}
}
fn jails_dataset(&self) -> String {
format!("{}/jails", self.base_dataset)
}
fn jail_dataset(&self, name: &str) -> String {
format!("{}/{}", self.jails_dataset(), name)
}
pub fn jail_dataset_name(&self, name: &str) -> String {
self.jail_dataset(name)
}
pub fn jail_path(&self, name: &str) -> PathBuf {
self.jails_mountpoint.join(name)
}
pub fn init(&self) -> Result<()> {
if !self.dataset_exists(&self.base_dataset)? {
Self::create_dataset(&self.base_dataset)?;
}
let jails = self.jails_dataset();
let mountpoint = self.jails_mountpoint.display().to_string();
if !self.dataset_exists(&jails)? {
Self::create_dataset(&jails)?;
Self::set_property(&jails, "mountpoint", &mountpoint)?;
}
Ok(())
}
#[allow(clippy::unused_self)] pub fn dataset_exists(&self, dataset: &str) -> Result<bool> {
Ok(zfs_output(&["list", "-H", "-o", "name", dataset])?
.status
.success())
}
fn create_dataset(dataset: &str) -> Result<()> {
zfs_run(&["create", "-p", "-o", "compression=lz4", dataset], || {
format!("Failed to create dataset '{dataset}'")
})
}
pub fn jail_dataset_exists(&self, name: &str) -> Result<bool> {
self.dataset_exists(&self.jail_dataset(name))
}
pub(crate) fn release_dataset(&self, release: &str) -> String {
format!("{}/releases/{}", self.base_dataset, release)
}
const PRISTINE: &'static str = "pristine";
pub fn release_dataset_exists(&self, release: &str) -> Result<bool> {
self.dataset_exists(&self.release_dataset(release))
}
pub fn create_release_dataset(&self, release: &str, mountpoint: &Path) -> Result<()> {
let dataset = self.release_dataset(release);
if !self.dataset_exists(&dataset)? {
Self::create_dataset(&dataset)?;
}
Self::set_property(&dataset, "mountpoint", &mountpoint.display().to_string())
}
pub fn snapshot_release_pristine(&self, release: &str) -> Result<()> {
let dataset = self.release_dataset(release);
let snapshot = format!("{}@{}", dataset, Self::PRISTINE);
if Self::snapshot_exists(&snapshot)? {
return Ok(());
}
Self::take_snapshot(&snapshot)
}
pub fn release_is_cloneable(&self, release: &str) -> bool {
let snapshot = format!("{}@{}", self.release_dataset(release), Self::PRISTINE);
Self::snapshot_exists(&snapshot).unwrap_or(false)
}
pub fn clone_jail_from_release(&self, release: &str, jail: &str) -> Result<PathBuf> {
let snapshot = format!("{}@{}", self.release_dataset(release), Self::PRISTINE);
let target = self.jail_dataset(jail);
if self.dataset_exists(&target)? {
return Err(Error::Zfs(format!("Dataset '{target}' already exists")));
}
zfs_run(&["clone", &snapshot, &target], || {
format!("Failed to clone '{snapshot}' to '{target}'")
})?;
Self::set_property(
&target,
"mountpoint",
&self.jail_path(jail).display().to_string(),
)?;
Ok(self.jail_path(jail))
}
pub(crate) fn commit_dataset_to_release(
&self,
source: &str,
release: &str,
release_mountpoint: &Path,
) -> Result<()> {
if !self.dataset_exists(source)? {
return Err(Error::Zfs(format!("Dataset '{source}' does not exist")));
}
let target = self.release_dataset(release);
if self.dataset_exists(&target)? {
return Err(Error::Zfs(format!("Release '{release}' already exists")));
}
let snapshot = format!("{}@{}", source, Self::PRISTINE);
if !Self::snapshot_exists(&snapshot)? {
Self::take_snapshot(&snapshot)?;
}
zfs_run(&["clone", &snapshot, &target], || {
format!("Failed to clone '{snapshot}' to '{target}'")
})?;
if !zfs_status(&["promote", &target])?.success() {
let _ = zfs_status(&["destroy", &target]);
return Err(Error::Zfs(format!("Failed to promote '{target}'")));
}
Self::set_property(
&target,
"mountpoint",
&release_mountpoint.display().to_string(),
)
}
pub(crate) fn container_dataset(&self, name: &str) -> String {
format!("{}/containers/{}", self.base_dataset, name)
}
pub(crate) fn clone_release_into(
&self,
release: &str,
dataset: &str,
mountpoint: &Path,
) -> Result<()> {
let snapshot = format!("{}@{}", self.release_dataset(release), Self::PRISTINE);
let mountpoint = format!("mountpoint={}", mountpoint.display());
zfs_run(
&["clone", "-p", "-o", &mountpoint, &snapshot, dataset],
|| format!("Failed to clone '{snapshot}' to '{dataset}'"),
)
}
pub(crate) fn destroy_dataset(&self, dataset: &str) -> Result<()> {
if !self.dataset_exists(dataset)? {
return Ok(());
}
zfs_run(&["destroy", "-r", dataset], || {
format!("Failed to destroy dataset '{dataset}'")
})
}
#[allow(clippy::unused_self)] pub(crate) fn destroy_dataset_without_dependents(&self, dataset: &str) -> Result<()> {
let output = zfs_output(&["destroy", "-r", dataset])?;
if output.status.success() {
return Ok(());
}
Err(Error::Zfs(format!(
"Failed to destroy '{dataset}': {}",
String::from_utf8_lossy(&output.stderr).trim()
)))
}
pub(crate) fn list_container_datasets(&self) -> Vec<String> {
Self::list_children(&format!("{}/containers", self.base_dataset))
}
pub fn layer_snapshot_name(index: usize, hash: &str) -> String {
format!("bs-layer-{index}-{hash}")
}
pub fn has_layer(&self, jail: &str, layer: &str) -> bool {
let snapshot = format!("{}@{}", self.jail_dataset(jail), layer);
Self::snapshot_exists(&snapshot).unwrap_or(false)
}
pub fn create_layer(&self, jail: &str, layer: &str) -> Result<()> {
Self::take_snapshot(&format!("{}@{}", self.jail_dataset(jail), layer))
}
pub fn rollback_to_layer(&self, jail: &str, layer: &str) -> Result<()> {
let snapshot = format!("{}@{}", self.jail_dataset(jail), layer);
zfs_run(&["rollback", "-r", &snapshot], || {
format!("Failed to rollback to '{snapshot}'")
})
}
fn take_snapshot(snapshot_full: &str) -> Result<()> {
zfs_run(&["snapshot", snapshot_full], || {
format!("Failed to snapshot '{snapshot_full}'")
})
}
fn snapshot_exists(snapshot_full: &str) -> Result<bool> {
Ok(
zfs_output(&["list", "-H", "-t", "snapshot", "-o", "name", snapshot_full])?
.status
.success(),
)
}
pub fn create_jail_dataset(&self, name: &str) -> Result<PathBuf> {
let dataset = self.jail_dataset(name);
if self.dataset_exists(&dataset)? {
return Err(Error::Zfs(format!("Dataset '{dataset}' already exists")));
}
let mountpoint = format!("mountpoint={}", self.jail_path(name).display());
zfs_run(
&[
"create",
"-p",
"-o",
"compression=lz4",
"-o",
&mountpoint,
&dataset,
],
|| format!("Failed to create dataset '{dataset}'"),
)?;
Ok(self.jail_path(name))
}
const EPHEMERAL_PROPERTY: &'static str = "blackship:ephemeral";
pub fn mark_jail_dataset(&self, name: &str, ephemeral: bool) -> Result<()> {
Self::set_property(
&self.jail_dataset(name),
Self::EPHEMERAL_PROPERTY,
if ephemeral { "on" } else { "off" },
)
}
pub fn jail_dataset_mark(&self, name: &str) -> Option<bool> {
match Self::get_property(&self.jail_dataset(name), Self::EPHEMERAL_PROPERTY)
.ok()?
.as_str()
{
"on" => Some(true),
"off" => Some(false),
_ => None,
}
}
const MIGRATED_PROPERTY: &'static str = "blackship:migrated";
pub fn fence_jail_dataset(&self, name: &str, destination: &str) -> Result<()> {
let dataset = self.jail_dataset(name);
Self::set_property(&dataset, Self::MIGRATED_PROPERTY, destination)?;
Self::set_property(&dataset, "readonly", "on")
}
pub fn jail_migration_fence(&self, name: &str) -> Option<String> {
let value = Self::get_property(&self.jail_dataset(name), Self::MIGRATED_PROPERTY).ok()?;
(!value.is_empty() && value != "-").then_some(value)
}
pub fn clear_jail_migration_fence(&self, name: &str) -> Result<()> {
let dataset = self.jail_dataset(name);
Self::set_property(&dataset, "readonly", "off")?;
zfs_run(&["inherit", Self::MIGRATED_PROPERTY, &dataset], || {
format!("Failed to clear the migration fence on '{dataset}'")
})
}
pub fn destroy_jail_dataset(&self, name: &str) -> Result<()> {
self.destroy_dataset(&self.jail_dataset(name))
}
pub fn list_jail_datasets(&self) -> Vec<String> {
Self::list_children(&self.jails_dataset())
}
fn list_children(parent: &str) -> Vec<String> {
let prefix = format!("{parent}/");
zfs_output(&[
"list",
"-H",
"-r",
"-d",
"1",
"-o",
"name",
"-t",
"filesystem",
parent,
])
.ok()
.filter(|o| o.status.success())
.map(|o| {
String::from_utf8_lossy(&o.stdout)
.lines()
.filter_map(|line| line.trim().strip_prefix(&prefix).map(str::to_string))
.filter(|name| !name.is_empty() && !name.contains('/'))
.collect()
})
.unwrap_or_default()
}
#[allow(clippy::unused_self)] pub fn dataset_origin(&self, dataset: &str) -> Option<String> {
Self::get_property(dataset, "origin")
.ok()
.filter(|origin| !origin.is_empty() && origin != "-")
}
pub fn get_property(dataset: &str, property: &str) -> Result<String> {
let output = zfs_output(&["get", "-H", "-o", "value", property, dataset])?;
if output.status.success() {
Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
} else {
Err(Error::Zfs(format!(
"Failed to get property '{property}' for dataset '{dataset}'"
)))
}
}
pub fn set_property(dataset: &str, property: &str, value: &str) -> Result<()> {
let current = zfs_output(&["get", "-H", "-o", "value", property, dataset])?;
if current.status.success() && String::from_utf8_lossy(¤t.stdout).trim() == value {
return Ok(());
}
zfs_run(&["set", &format!("{property}={value}"), dataset], || {
format!("Failed to set property '{property}={value}' for dataset '{dataset}'")
})
}
fn require_jail_dataset(&self, jail: &str) -> Result<String> {
let dataset = self.jail_dataset(jail);
if !self.dataset_exists(&dataset)? {
return Err(Error::Zfs(format!("Jail dataset '{jail}' does not exist")));
}
Ok(dataset)
}
fn require_snapshot_exists(snapshot_full: &str, snapshot: &str) -> Result<()> {
let output = zfs_output(&["list", "-H", "-t", "snapshot", snapshot_full])?;
if !output.status.success() {
return Err(Error::Zfs(format!("Snapshot '{snapshot}' does not exist")));
}
Ok(())
}
pub fn create_snapshot(&self, jail: &str, name: Option<&str>) -> Result<String> {
let dataset = self.require_jail_dataset(jail)?;
let snap_name = match name {
Some(n) => n.to_string(),
None => default_snapshot_name(),
};
let snapshot = format!("{dataset}@{snap_name}");
zfs_run(&["snapshot", "-r", &snapshot], || {
format!("Failed to create snapshot '{snapshot}'")
})?;
Ok(snap_name)
}
pub fn list_snapshots(&self, jail: &str) -> Result<Vec<SnapshotInfo>> {
let dataset = self.require_jail_dataset(jail)?;
let output = zfs_output(&[
"list",
"-H",
"-t",
"snapshot",
"-o",
"name,creation,used,refer",
"-r",
&dataset,
])?;
if !output.status.success() {
return Err(Error::Zfs("Failed to list snapshots".into()));
}
let stdout = String::from_utf8_lossy(&output.stdout);
let mut snapshots = Vec::new();
for line in stdout.lines() {
let parts: Vec<&str> = line.split('\t').collect();
if parts.len() >= 4 {
let full_name = parts[0];
if let Some(at_pos) = full_name.find('@') {
let name = &full_name[at_pos + 1..];
snapshots.push(SnapshotInfo {
name: name.to_string(),
creation: parts[1].to_string(),
used: parts[2].to_string(),
refer: parts[3].to_string(),
});
}
}
}
Ok(snapshots)
}
pub fn rollback_snapshot(&self, jail: &str, snapshot: &str, force: bool) -> Result<()> {
let dataset = self.jail_dataset(jail);
let snapshot_full = format!("{dataset}@{snapshot}");
Self::require_snapshot_exists(&snapshot_full, snapshot)?;
let mut args = vec!["rollback"];
if force {
args.push("-r"); }
args.push(&snapshot_full);
zfs_run(&args, || {
format!(
"Failed to rollback to snapshot '{snapshot}'. Use --force to destroy newer snapshots."
)
})
}
pub fn delete_snapshot(&self, jail: &str, snapshot: &str) -> Result<()> {
let dataset = self.jail_dataset(jail);
let snapshot_full = format!("{dataset}@{snapshot}");
zfs_run(&["destroy", &snapshot_full], || {
format!("Failed to delete snapshot '{snapshot}'")
})
}
pub fn clone_from_snapshot(
&self,
source_jail: &str,
snapshot: &str,
new_jail: &str,
) -> Result<PathBuf> {
let source_dataset = self.jail_dataset(source_jail);
let snapshot_full = format!("{source_dataset}@{snapshot}");
let target_dataset = self.jail_dataset(new_jail);
Self::require_snapshot_exists(&snapshot_full, &format!("{source_jail}@{snapshot}"))?;
if self.dataset_exists(&target_dataset)? {
return Err(Error::Zfs(format!("Jail '{new_jail}' already exists")));
}
zfs_run(&["clone", &snapshot_full, &target_dataset], || {
format!("Failed to clone snapshot '{snapshot_full}' to '{new_jail}'")
})?;
Ok(self.jail_path(new_jail))
}
}
fn default_snapshot_name() -> String {
format!("snap-{}", Zoned::now().strftime("%Y%m%d-%H%M%S"))
}
#[derive(Debug, Clone)]
pub struct SnapshotInfo {
pub name: String,
pub creation: String,
pub used: String,
pub refer: String,
}
#[cfg(test)]
mod tests;