use super::YankCommand;
use crate::registry::{index_writer, PackageEntry, PackageIndex, VersionEntry};
use anyhow::{bail, Context, Result};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use std::{fs, io::Write, path::Path, process::Command};
#[derive(Serialize, Deserialize)]
pub(super) struct PendingYank {
repository: String,
package: String,
desired: VersionEntry,
before_sha256: String,
after_sha256: String,
push: bool,
}
fn digest(bytes: &[u8]) -> String {
format!("{:x}", Sha256::digest(bytes))
}
pub(super) fn write_atomic(path: &Path, bytes: &[u8]) -> Result<()> {
let mut temporary = tempfile::NamedTempFile::new_in(path.parent().context("Missing parent")?)?;
temporary.write_all(bytes)?;
temporary.as_file().sync_all()?;
temporary.persist(path)?;
Ok(())
}
impl PendingYank {
pub fn start(
path: &Path,
repository: &str,
package: &str,
desired: VersionEntry,
before: &[u8],
after: &[u8],
push: bool,
) -> Result<Self> {
let pending = Self {
repository: repository.to_owned(),
package: package.to_owned(),
desired,
before_sha256: digest(before),
after_sha256: digest(after),
push,
};
write_atomic(
&path.join(".git/ccgo-yank.json"),
&serde_json::to_vec_pretty(&pending)?,
)?;
Ok(pending)
}
pub fn resume(
path: &Path,
command: &YankCommand,
package: &str,
verbose: bool,
) -> Result<Option<Self>> {
let bytes = match fs::read(path.join(".git/ccgo-yank.json")) {
Ok(bytes) => bytes,
Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None),
Err(error) => return Err(error.into()),
};
let pending: Self = serde_json::from_slice(&bytes).context("Invalid pending yank")?;
pending.validate_request(command, package)?;
pending.restore_and_commit(path, package, verbose)?;
Ok(Some(pending))
}
fn validate_request(&self, command: &YankCommand, package: &str) -> Result<()> {
let repository = command
.index_repo
.as_deref()
.context("Missing index repository")?;
let version = command.vers.as_str();
if self.repository != repository
|| self.package != package
|| self.desired.version != version
|| self.desired.yanked == command.undo
|| self.desired.yanked_reason != command.reason
{
bail!("An interrupted yank is pending; retry its original repository, package, version, action and reason");
}
if self.push && !command.push {
bail!("Pending yank requires --push; retry the original command");
}
Ok(())
}
fn restore_and_commit(&self, path: &Path, package: &str, verbose: bool) -> Result<()> {
let repository = &self.repository;
let version = self.desired.version.as_str();
index_writer::verify_origin(path, repository)?;
let file = PackageIndex::package_index_path(package);
let dirty = Self::has_recoverable_changes(path, &file)?;
let current = fs::read(path.join(&file))?;
let hash = digest(¤t);
if hash == self.before_sha256 {
let mut entry: PackageEntry = serde_json::from_slice(¤t)?;
let target = entry
.versions
.iter_mut()
.find(|entry| entry.version == version)
.context("Pending yank version is missing")?;
*target = self.desired.clone();
let after = serde_json::to_vec_pretty(&entry)?;
if digest(&after) != self.after_sha256 {
bail!("Pending yank snapshot mismatch");
}
write_atomic(&path.join(&file), &after)?;
} else if dirty
&& hash != self.after_sha256
&& !index_writer::matches_pending_merge(path, &file.to_string_lossy(), ¤t)?
{
bail!("Pending yank package contains unrelated edits; local changes are preserved");
}
self.verify_target(path)?;
if dirty || hash == self.before_sha256 {
index_writer::update_index_metadata(path, "index")?;
index_writer::commit_changes(
path,
&format!("Resume yank: {package} {version}"),
verbose,
)?;
}
Ok(())
}
fn has_recoverable_changes(path: &Path, file: &Path) -> Result<bool> {
let status = Command::new("git")
.current_dir(path)
.args(["status", "--porcelain", "-z"])
.output()?;
if !status.status.success() {
bail!("Failed to inspect pending yank");
}
for change in status
.stdout
.split(|b| *b == 0)
.filter(|entry| !entry.is_empty())
{
let changed = std::str::from_utf8(change.get(3..).context("Invalid Git status")?)?;
if changed != "index.json" && changed != file.to_string_lossy() {
bail!("Unrelated local changes prevent yank recovery: {changed}; local changes are preserved");
}
}
Ok(!status.stdout.is_empty())
}
pub fn verify_target(&self, path: &Path) -> Result<()> {
let entry: PackageEntry = serde_json::from_slice(&fs::read(
path.join(PackageIndex::package_index_path(&self.package)),
)?)?;
let target = entry
.versions
.iter()
.find(|entry| entry.version == self.desired.version)
.context("Pending yank version is missing")?;
if serde_json::to_value(target)? != serde_json::to_value(&self.desired)? {
bail!("Pending yank differs from the index; refusing to overwrite version history");
}
Ok(())
}
pub fn finish(&self, path: &Path) -> Result<()> {
fs::remove_file(path.join(".git/ccgo-yank.json"))?;
Ok(())
}
}