718 lines
26 KiB
Rust
718 lines
26 KiB
Rust
use super::*;
|
|
|
|
#[derive(Debug)]
|
|
pub struct FsTransaction {
|
|
rootfs: PathBuf,
|
|
pub(super) tx_dir: PathBuf,
|
|
backed_up: Vec<String>,
|
|
created: Vec<String>,
|
|
relocated: Vec<String>,
|
|
removed: Vec<String>,
|
|
}
|
|
|
|
pub(super) fn is_directory_empty(path: &Path) -> Result<bool> {
|
|
let mut entries = fs::read_dir(path)
|
|
.with_context(|| format!("Failed to read directory {}", path.display()))?;
|
|
Ok(entries.next().transpose()?.is_none())
|
|
}
|
|
|
|
pub(super) fn backup_existing_path(src: &Path, backup_path: &Path, rel: &str) -> Result<()> {
|
|
let metadata = src
|
|
.symlink_metadata()
|
|
.with_context(|| format!("Failed to inspect existing path {}", rel))?;
|
|
|
|
if let Some(parent) = backup_path.parent() {
|
|
fs::create_dir_all(parent)
|
|
.with_context(|| format!("Failed to create backup dir {}", parent.display()))?;
|
|
}
|
|
|
|
if metadata.file_type().is_symlink() {
|
|
let target = fs::read_link(src)
|
|
.with_context(|| format!("Failed to read existing symlink target {}", rel))?;
|
|
std::os::unix::fs::symlink(&target, backup_path)
|
|
.with_context(|| format!("Failed to backup symlink {}", rel))?;
|
|
} else if metadata.file_type().is_dir() {
|
|
fs::create_dir_all(backup_path)
|
|
.with_context(|| format!("Failed to backup directory {}", rel))?;
|
|
apply_unix_mode(backup_path, &metadata)?;
|
|
} else {
|
|
fs::copy(src, backup_path).with_context(|| format!("Failed to backup file {}", rel))?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub(super) fn move_directory_contents(src_dir: &Path, dst_dir: &Path) -> Result<()> {
|
|
fs::create_dir_all(dst_dir)
|
|
.with_context(|| format!("Failed to create directory {}", dst_dir.display()))?;
|
|
|
|
for entry in
|
|
fs::read_dir(src_dir).with_context(|| format!("Failed to read {}", src_dir.display()))?
|
|
{
|
|
let entry = entry?;
|
|
move_tree_preserving_layout(&entry.path(), &dst_dir.join(entry.file_name()))?;
|
|
}
|
|
|
|
fs::remove_dir(src_dir).with_context(|| format!("Failed to remove {}", src_dir.display()))?;
|
|
Ok(())
|
|
}
|
|
|
|
pub(super) fn copy_tree_preserving_layout_no_overwrite(
|
|
src_root: &Path,
|
|
dst_root: &Path,
|
|
logical_root: &str,
|
|
created: &mut Vec<String>,
|
|
) -> Result<()> {
|
|
for entry in WalkDir::new(src_root).follow_links(false) {
|
|
let entry = entry
|
|
.with_context(|| format!("Failed to walk relocation tree {}", src_root.display()))?;
|
|
let src_path = entry.path();
|
|
let rel = src_path
|
|
.strip_prefix(src_root)
|
|
.with_context(|| format!("Failed to strip relocation root {}", src_root.display()))?;
|
|
if rel.as_os_str().is_empty() {
|
|
continue;
|
|
}
|
|
|
|
let dst_path = dst_root.join(rel);
|
|
let metadata = src_path
|
|
.symlink_metadata()
|
|
.with_context(|| format!("Failed to inspect {}", src_path.display()))?;
|
|
let file_type = metadata.file_type();
|
|
|
|
if file_type.is_dir() {
|
|
match dst_path.symlink_metadata() {
|
|
Ok(dst_meta) => {
|
|
if !dst_meta.file_type().is_dir() {
|
|
anyhow::bail!(
|
|
"Failed to replay relocated directory into {}: destination exists and is not a directory",
|
|
dst_path.display()
|
|
);
|
|
}
|
|
}
|
|
Err(err) if err.kind() == io::ErrorKind::NotFound => {
|
|
fs::create_dir_all(&dst_path).with_context(|| {
|
|
format!("Failed to create directory {}", dst_path.display())
|
|
})?;
|
|
apply_unix_mode(&dst_path, &metadata)?;
|
|
}
|
|
Err(err) => {
|
|
return Err(err)
|
|
.with_context(|| format!("Failed to inspect {}", dst_path.display()));
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if let Some(parent) = dst_path.parent() {
|
|
fs::create_dir_all(parent)
|
|
.with_context(|| format!("Failed to create directory {}", parent.display()))?;
|
|
}
|
|
|
|
if let Ok(dst_metadata) = dst_path.symlink_metadata() {
|
|
if duplicate_staged_path_is_equivalent(src_path, &metadata, &dst_path, &dst_metadata)? {
|
|
continue;
|
|
}
|
|
anyhow::bail!(
|
|
"Failed to replay relocated path into {}: destination already exists",
|
|
dst_path.display()
|
|
);
|
|
}
|
|
|
|
if file_type.is_symlink() {
|
|
let target = fs::read_link(src_path)
|
|
.with_context(|| format!("Failed to read symlink {}", src_path.display()))?;
|
|
std::os::unix::fs::symlink(&target, &dst_path).with_context(|| {
|
|
format!(
|
|
"Failed to create relocated symlink {} -> {}",
|
|
dst_path.display(),
|
|
target.display()
|
|
)
|
|
})?;
|
|
} else {
|
|
fs::copy(src_path, &dst_path).with_context(|| {
|
|
format!(
|
|
"Failed to copy relocated path {} to {}",
|
|
src_path.display(),
|
|
dst_path.display()
|
|
)
|
|
})?;
|
|
apply_unix_mode(&dst_path, &metadata)?;
|
|
}
|
|
|
|
let logical = Path::new(logical_root).join(rel);
|
|
let logical = logical
|
|
.to_str()
|
|
.context("Relocated install paths must be valid UTF-8")?
|
|
.to_string();
|
|
created.push(logical);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub(super) fn symlink_target_path_inside_rootfs(
|
|
rootfs: &Path,
|
|
link_rel: &str,
|
|
target: &Path,
|
|
) -> Result<Option<PathBuf>> {
|
|
let mut normalized = PathBuf::new();
|
|
if target.is_absolute() {
|
|
for component in target.components() {
|
|
match component {
|
|
Component::RootDir => {}
|
|
Component::CurDir => {}
|
|
Component::Normal(segment) => normalized.push(segment),
|
|
Component::ParentDir | Component::Prefix(_) => return Ok(None),
|
|
}
|
|
}
|
|
} else {
|
|
if let Some(parent) = Path::new(link_rel).parent() {
|
|
normalized.push(parent);
|
|
}
|
|
for component in target.components() {
|
|
match component {
|
|
Component::CurDir => {}
|
|
Component::Normal(segment) => normalized.push(segment),
|
|
Component::ParentDir => {
|
|
if !normalized.pop() {
|
|
return Ok(None);
|
|
}
|
|
}
|
|
Component::RootDir | Component::Prefix(_) => return Ok(None),
|
|
}
|
|
}
|
|
}
|
|
|
|
if normalized.as_os_str().is_empty() {
|
|
return Ok(None);
|
|
}
|
|
|
|
Ok(Some(rootfs.join(normalized)))
|
|
}
|
|
|
|
pub(super) fn can_relocate_directory_for_symlink_swap(
|
|
rootfs: &Path,
|
|
link_rel: &str,
|
|
symlink_path: &Path,
|
|
) -> Result<bool> {
|
|
let target = fs::read_link(symlink_path)
|
|
.with_context(|| format!("Failed to read symlink {}", symlink_path.display()))?;
|
|
let Some(target_path) = symlink_target_path_inside_rootfs(rootfs, link_rel, &target)? else {
|
|
return Ok(false);
|
|
};
|
|
|
|
match target_path.symlink_metadata() {
|
|
Ok(metadata) => Ok(metadata.file_type().is_dir()),
|
|
Err(err) if err.kind() == io::ErrorKind::NotFound => Ok(false),
|
|
Err(err) => Err(err)
|
|
.with_context(|| format!("Failed to inspect symlink target {}", target_path.display())),
|
|
}
|
|
}
|
|
|
|
pub(super) fn remove_path_in_place(path: &Path, rel: &str) -> Result<()> {
|
|
let metadata = path
|
|
.symlink_metadata()
|
|
.with_context(|| format!("Failed to inspect existing path {}", rel))?;
|
|
|
|
if metadata.file_type().is_dir() {
|
|
fs::remove_dir(path)
|
|
.with_context(|| format!("Failed to remove obsolete directory {}", rel))?;
|
|
} else {
|
|
fs::remove_file(path)
|
|
.with_context(|| format!("Failed to remove obsolete file/symlink {}", rel))?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub(super) fn backup_and_remove_obsolete_path(
|
|
tx: &mut FsTransaction,
|
|
rootfs: &Path,
|
|
rel: &str,
|
|
require_empty_dir: bool,
|
|
) -> Result<bool> {
|
|
let dest_path = rootfs.join(rel);
|
|
let metadata = match dest_path.symlink_metadata() {
|
|
Ok(metadata) => metadata,
|
|
Err(err) if err.kind() == io::ErrorKind::NotFound => return Ok(false),
|
|
Err(err) => {
|
|
return Err(err).with_context(|| {
|
|
format!("Failed to inspect obsolete path before removal: {}", rel)
|
|
});
|
|
}
|
|
};
|
|
|
|
if metadata.file_type().is_dir() {
|
|
let empty = is_directory_empty(&dest_path)?;
|
|
if !empty {
|
|
if require_empty_dir {
|
|
anyhow::bail!(
|
|
"Refusing to replace existing non-empty directory with packaged file/symlink: {}",
|
|
rel
|
|
);
|
|
}
|
|
return Ok(false);
|
|
}
|
|
}
|
|
|
|
let backup_path = tx.removed_backup_path(rel);
|
|
backup_existing_path(&dest_path, &backup_path, rel)?;
|
|
remove_path_in_place(&dest_path, rel)?;
|
|
tx.removed.push(rel.to_string());
|
|
Ok(true)
|
|
}
|
|
|
|
pub(super) fn remove_obsolete_children_for_dir(
|
|
tx: &mut FsTransaction,
|
|
rootfs: &Path,
|
|
dir_rel: &str,
|
|
remove_paths: &[String],
|
|
) -> Result<()> {
|
|
let prefix = format!("{dir_rel}/");
|
|
let mut nested_paths: Vec<&str> = remove_paths
|
|
.iter()
|
|
.filter_map(|path| path.strip_prefix(&prefix).map(|_| path.as_str()))
|
|
.collect();
|
|
nested_paths.sort_by_key(|path| std::cmp::Reverse(path.matches('/').count()));
|
|
|
|
for rel in nested_paths {
|
|
let _ = backup_and_remove_obsolete_path(tx, rootfs, rel, false)?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
impl FsTransaction {
|
|
fn backup_path(&self, rel: &str) -> PathBuf {
|
|
self.tx_dir.join("backup").join(rel)
|
|
}
|
|
|
|
fn removed_backup_path(&self, rel: &str) -> PathBuf {
|
|
self.tx_dir.join("removed").join(rel)
|
|
}
|
|
|
|
fn relocated_path(&self, rel: &str) -> PathBuf {
|
|
self.tx_dir.join("relocated").join(rel)
|
|
}
|
|
|
|
fn relocate_directory_for_symlink_swap(&mut self, rel: &str) -> Result<()> {
|
|
let src = self.rootfs.join(rel);
|
|
let relocated = self.relocated_path(rel);
|
|
move_directory_contents(&src, &relocated)?;
|
|
self.relocated.push(rel.to_string());
|
|
Ok(())
|
|
}
|
|
|
|
fn replay_relocated_dir_if_present(&mut self, rel: &str) -> Result<()> {
|
|
let relocated = self.relocated_path(rel);
|
|
match relocated.symlink_metadata() {
|
|
Ok(meta) if meta.file_type().is_dir() => {}
|
|
Ok(_) => {
|
|
anyhow::bail!(
|
|
"Relocation staging path is not a directory: {}",
|
|
relocated.display()
|
|
);
|
|
}
|
|
Err(err) if err.kind() == io::ErrorKind::NotFound => return Ok(()),
|
|
Err(err) => {
|
|
return Err(err)
|
|
.with_context(|| format!("Failed to inspect {}", relocated.display()));
|
|
}
|
|
}
|
|
|
|
copy_tree_preserving_layout_no_overwrite(
|
|
&relocated,
|
|
&self.rootfs.join(rel),
|
|
rel,
|
|
&mut self.created,
|
|
)
|
|
}
|
|
|
|
fn restore_relocated_dir(&self, rel: &str) -> Result<()> {
|
|
let relocated = self.relocated_path(rel);
|
|
match relocated.symlink_metadata() {
|
|
Ok(meta) if meta.file_type().is_dir() => {}
|
|
Ok(_) => {
|
|
anyhow::bail!(
|
|
"Relocation staging path is not a directory: {}",
|
|
relocated.display()
|
|
);
|
|
}
|
|
Err(err) if err.kind() == io::ErrorKind::NotFound => return Ok(()),
|
|
Err(err) => {
|
|
return Err(err)
|
|
.with_context(|| format!("Failed to inspect {}", relocated.display()));
|
|
}
|
|
}
|
|
|
|
let dst = self.rootfs.join(rel);
|
|
match dst.symlink_metadata() {
|
|
Ok(meta) if meta.file_type().is_dir() => {}
|
|
Ok(_) => {
|
|
anyhow::bail!(
|
|
"Failed to restore relocated directory contents into {}: destination is not a directory",
|
|
dst.display()
|
|
);
|
|
}
|
|
Err(err) if err.kind() == io::ErrorKind::NotFound => {
|
|
fs::create_dir_all(&dst)
|
|
.with_context(|| format!("Failed to create directory {}", dst.display()))?;
|
|
}
|
|
Err(err) => {
|
|
return Err(err).with_context(|| format!("Failed to inspect {}", dst.display()));
|
|
}
|
|
}
|
|
|
|
move_directory_contents(&relocated, &dst)?;
|
|
cleanup_empty_parent_dirs(&self.tx_dir, &relocated)?;
|
|
Ok(())
|
|
}
|
|
|
|
fn restore_backup_entry(&self, src: &Path, dst: &Path) -> Result<()> {
|
|
let metadata = src
|
|
.symlink_metadata()
|
|
.with_context(|| format!("Failed to inspect backup entry {}", src.display()))?;
|
|
|
|
if let Some(parent) = dst.parent() {
|
|
fs::create_dir_all(parent)
|
|
.with_context(|| format!("Failed to create restore dir {}", parent.display()))?;
|
|
}
|
|
|
|
if metadata.file_type().is_dir() {
|
|
match dst.symlink_metadata() {
|
|
Ok(dst_meta) if dst_meta.file_type().is_dir() => {}
|
|
Ok(dst_meta) if dst_meta.file_type().is_symlink() => {
|
|
fs::remove_file(dst)
|
|
.with_context(|| format!("Failed to remove {}", dst.display()))?;
|
|
}
|
|
Ok(_) => {
|
|
fs::remove_file(dst)
|
|
.with_context(|| format!("Failed to remove {}", dst.display()))?;
|
|
}
|
|
Err(err) if err.kind() == io::ErrorKind::NotFound => {}
|
|
Err(err) => {
|
|
return Err(err)
|
|
.with_context(|| format!("Failed to inspect {}", dst.display()));
|
|
}
|
|
}
|
|
fs::create_dir_all(dst)
|
|
.with_context(|| format!("Failed to restore directory {}", dst.display()))?;
|
|
apply_unix_mode(dst, &metadata)?;
|
|
return Ok(());
|
|
}
|
|
|
|
let _ = fs::remove_file(dst);
|
|
match fs::rename(src, dst) {
|
|
Ok(()) => Ok(()),
|
|
Err(_) if metadata.file_type().is_symlink() => {
|
|
let target = fs::read_link(src)
|
|
.with_context(|| format!("Failed to read backup symlink {}", src.display()))?;
|
|
std::os::unix::fs::symlink(&target, dst)
|
|
.with_context(|| format!("Failed to restore symlink {}", dst.display()))
|
|
}
|
|
Err(_) => {
|
|
fs::copy(src, dst).with_context(|| {
|
|
format!(
|
|
"Failed to restore file {} from {}",
|
|
dst.display(),
|
|
src.display()
|
|
)
|
|
})?;
|
|
Ok(())
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Roll back file operations performed by `install_atomic`.
|
|
pub fn rollback(&self) -> Result<()> {
|
|
// Remove files that were newly created
|
|
for rel in &self.created {
|
|
let dst = self.rootfs.join(rel);
|
|
let _ = fs::remove_file(dst);
|
|
}
|
|
|
|
// Restore overwritten paths first so relocated and removed children have their parent layout.
|
|
for rel in &self.backed_up {
|
|
let src = self.backup_path(rel);
|
|
let dst = self.rootfs.join(rel);
|
|
if src.symlink_metadata().is_ok() {
|
|
self.restore_backup_entry(&src, &dst)?;
|
|
}
|
|
}
|
|
|
|
for rel in &self.relocated {
|
|
self.restore_relocated_dir(rel)?;
|
|
}
|
|
|
|
// Restore removed files/directories.
|
|
for rel in &self.removed {
|
|
let src = self.removed_backup_path(rel);
|
|
let dst = self.rootfs.join(rel);
|
|
if src.symlink_metadata().is_ok() {
|
|
self.restore_backup_entry(&src, &dst)?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Commit the transaction (delete backup directory).
|
|
pub fn commit(self) -> Result<()> {
|
|
let tx_base_dir = self.tx_dir.parent().map(Path::to_path_buf);
|
|
if self.tx_dir.exists() {
|
|
fs::remove_dir_all(&self.tx_dir)?;
|
|
}
|
|
if let Some(tx_base_dir) = tx_base_dir {
|
|
match fs::remove_dir(&tx_base_dir) {
|
|
Ok(()) => {}
|
|
Err(err)
|
|
if matches!(
|
|
err.kind(),
|
|
io::ErrorKind::DirectoryNotEmpty | io::ErrorKind::NotFound
|
|
) => {}
|
|
Err(err) => {
|
|
return Err(err).with_context(|| {
|
|
format!("Failed to remove tx dir {}", tx_base_dir.display())
|
|
});
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// Install staged files using a rollback-capable transaction.
|
|
///
|
|
/// This is used for both first-time installs and updates. For updates, pass a
|
|
/// list of relative paths to remove (old manifest minus new manifest).
|
|
pub fn install_atomic(
|
|
destdir: &Path,
|
|
rootfs: &Path,
|
|
tx_base_dir: &Path,
|
|
remove_paths: &[String],
|
|
keep_paths: &[String],
|
|
) -> Result<FsTransaction> {
|
|
let tx_base_dir = if rootfs != Path::new("/") && tx_base_dir.starts_with(rootfs) {
|
|
rootfs.join(".depot-tx")
|
|
} else {
|
|
tx_base_dir.to_path_buf()
|
|
};
|
|
let keep_rules: Vec<KeepMatcher> = keep_paths
|
|
.iter()
|
|
.map(|p| KeepMatcher::from_spec(p))
|
|
.collect::<Result<Vec<_>>>()?;
|
|
let keep_set: HashSet<String> = keep_rules
|
|
.iter()
|
|
.filter_map(|m| match m {
|
|
KeepMatcher::Exact(p) => Some(p.clone()),
|
|
KeepMatcher::Pattern(_) => None,
|
|
})
|
|
.collect();
|
|
let remove_set: HashSet<&str> = remove_paths.iter().map(String::as_str).collect();
|
|
|
|
fs::create_dir_all(&tx_base_dir)
|
|
.with_context(|| format!("Failed to create tx dir: {}", tx_base_dir.display()))?;
|
|
|
|
let ts = SystemTime::now()
|
|
.duration_since(UNIX_EPOCH)
|
|
.unwrap_or_default()
|
|
.as_millis();
|
|
let pid = std::process::id();
|
|
let tx_dir = tx_base_dir.join(format!("tx-{}-{}", ts, pid));
|
|
let backup_dir = tx_dir.join("backup");
|
|
let removed_dir = tx_dir.join("removed");
|
|
fs::create_dir_all(&backup_dir)?;
|
|
fs::create_dir_all(&removed_dir)?;
|
|
|
|
let mut tx = FsTransaction {
|
|
rootfs: rootfs.to_path_buf(),
|
|
tx_dir,
|
|
backed_up: Vec::new(),
|
|
created: Vec::new(),
|
|
relocated: Vec::new(),
|
|
removed: Vec::new(),
|
|
};
|
|
let mut staged_paths = HashSet::new();
|
|
let mut installed_hardlinks: HashMap<HardlinkKey, String> = HashMap::new();
|
|
|
|
let result: Result<()> = (|| {
|
|
// First, create all directories from destdir (for packages with only directories)
|
|
for entry in WalkDir::new(destdir).into_iter().filter_map(|e| e.ok()) {
|
|
let src_path = entry.path();
|
|
let file_type = entry.file_type();
|
|
|
|
if !file_type.is_dir() || src_path == destdir {
|
|
continue;
|
|
}
|
|
|
|
let rel_path = src_path
|
|
.strip_prefix(destdir)
|
|
.context("Failed to strip destdir prefix")?;
|
|
let rel_path_str = rel_path.to_string_lossy().to_string();
|
|
if is_skipped_install_path(&rel_path_str) {
|
|
continue;
|
|
}
|
|
|
|
let dest_path = rootfs.join(rel_path);
|
|
if !dest_path.exists() {
|
|
fs::create_dir_all(&dest_path)?;
|
|
apply_unix_mode(&dest_path, &src_path.symlink_metadata()?)?;
|
|
}
|
|
staged_paths.insert(rel_path_str);
|
|
}
|
|
|
|
// Copy in new files.
|
|
for entry in WalkDir::new(destdir).into_iter().filter_map(|e| e.ok()) {
|
|
let src_path = entry.path();
|
|
let metadata = src_path
|
|
.symlink_metadata()
|
|
.context("Failed to get metadata")?;
|
|
let file_type = metadata.file_type();
|
|
|
|
// We want to install files AND symlinks (to anything)
|
|
if !file_type.is_file() && !file_type.is_symlink() {
|
|
continue;
|
|
}
|
|
|
|
let rel_path = src_path
|
|
.strip_prefix(destdir)
|
|
.context("Failed to strip destdir prefix")?
|
|
.to_string_lossy()
|
|
.to_string();
|
|
|
|
if is_skipped_install_path(&rel_path) {
|
|
continue;
|
|
}
|
|
|
|
let keep_match = if keep_set.contains(&rel_path) {
|
|
true
|
|
} else {
|
|
keep_rules.iter().any(|m| m.matches(&rel_path))
|
|
};
|
|
let keep_as_depotnew = keep_match && rootfs.join(&rel_path).exists();
|
|
let install_rel_path = if keep_as_depotnew {
|
|
format!("{}.depotnew", rel_path)
|
|
} else {
|
|
rel_path.clone()
|
|
};
|
|
|
|
let dest_path = rootfs.join(&install_rel_path);
|
|
|
|
if let Some(parent) = dest_path.parent() {
|
|
fs::create_dir_all(parent)?;
|
|
}
|
|
|
|
if let Ok(dest_meta) = dest_path.symlink_metadata() {
|
|
let backup_path = tx.backup_path(&install_rel_path);
|
|
if dest_meta.file_type().is_dir() {
|
|
let can_relocate = file_type.is_symlink()
|
|
&& can_relocate_directory_for_symlink_swap(
|
|
rootfs,
|
|
&install_rel_path,
|
|
src_path,
|
|
)?;
|
|
if !remove_set.contains(install_rel_path.as_str()) && !can_relocate {
|
|
anyhow::bail!(
|
|
"Refusing to replace existing directory with packaged file/symlink: {}",
|
|
install_rel_path
|
|
);
|
|
}
|
|
backup_existing_path(&dest_path, &backup_path, &install_rel_path)?;
|
|
tx.backed_up.push(install_rel_path.clone());
|
|
remove_obsolete_children_for_dir(
|
|
&mut tx,
|
|
rootfs,
|
|
&install_rel_path,
|
|
remove_paths,
|
|
)?;
|
|
if file_type.is_symlink() {
|
|
tx.relocate_directory_for_symlink_swap(&install_rel_path)?;
|
|
}
|
|
} else {
|
|
backup_existing_path(&dest_path, &backup_path, &install_rel_path)?;
|
|
tx.backed_up.push(install_rel_path.clone());
|
|
}
|
|
} else {
|
|
tx.created.push(install_rel_path.clone());
|
|
}
|
|
|
|
// Install new file/symlink
|
|
// Remove destination if it exists (we backed it up) so we can overwrite
|
|
if let Ok(dest_meta) = dest_path.symlink_metadata() {
|
|
if dest_meta.file_type().is_dir() {
|
|
let relocated_for_symlink_swap =
|
|
tx.relocated.iter().any(|rel| rel == &install_rel_path);
|
|
if !remove_set.contains(install_rel_path.as_str())
|
|
&& !relocated_for_symlink_swap
|
|
{
|
|
anyhow::bail!(
|
|
"Refusing to replace existing directory with packaged file/symlink: {}",
|
|
install_rel_path
|
|
);
|
|
}
|
|
if !is_directory_empty(&dest_path)? {
|
|
anyhow::bail!(
|
|
"Refusing to replace existing non-empty directory with packaged file/symlink: {}",
|
|
install_rel_path
|
|
);
|
|
}
|
|
fs::remove_dir(&dest_path)?;
|
|
} else {
|
|
fs::remove_file(&dest_path)?;
|
|
}
|
|
}
|
|
|
|
if file_type.is_symlink() {
|
|
let target = fs::read_link(src_path)
|
|
.with_context(|| format!("Failed to read staged symlink {}", rel_path))?;
|
|
std::os::unix::fs::symlink(target, &dest_path)
|
|
.with_context(|| format!("Failed to create symlink: {}", install_rel_path))?;
|
|
tx.replay_relocated_dir_if_present(&install_rel_path)?;
|
|
} else {
|
|
let hardlink_key = if keep_as_depotnew {
|
|
None
|
|
} else {
|
|
hardlink_key(&metadata)
|
|
};
|
|
if let Some(first_rel_path) =
|
|
hardlink_key.and_then(|key| installed_hardlinks.get(&key))
|
|
{
|
|
let first_path = rootfs.join(first_rel_path);
|
|
fs::hard_link(&first_path, &dest_path).with_context(|| {
|
|
format!(
|
|
"Failed to install hardlink: {} -> {}",
|
|
install_rel_path, first_rel_path
|
|
)
|
|
})?;
|
|
} else {
|
|
fs::copy(src_path, &dest_path)
|
|
.with_context(|| format!("Failed to install: {}", install_rel_path))?;
|
|
apply_unix_mode(&dest_path, &metadata)?;
|
|
if let Some(key) = hardlink_key {
|
|
installed_hardlinks.insert(key, install_rel_path.clone());
|
|
}
|
|
}
|
|
}
|
|
staged_paths.insert(install_rel_path);
|
|
}
|
|
|
|
// Remove obsolete files/directories left behind by the previous version.
|
|
for rel in remove_paths {
|
|
if staged_paths.contains(rel) || tx.removed.iter().any(|removed| removed == rel) {
|
|
continue;
|
|
}
|
|
let _ = backup_and_remove_obsolete_path(&mut tx, rootfs, rel, false)?;
|
|
}
|
|
|
|
Ok(())
|
|
})();
|
|
|
|
if let Err(e) = result {
|
|
let _ = tx.rollback();
|
|
return Err(e);
|
|
}
|
|
|
|
Ok(tx)
|
|
}
|