use std::fmt::Write as _;
use std::io::{self, Write};
use std::path::{Path, PathBuf};
use cap_std::fs::{Dir, OpenOptions};
use super::fs::{
is_consume_staging_name, parse_staging_name, repo_path_display, staging_candidate,
stray_staging_files, write_file_via_rename, StagingKind, CONSUME_MARK,
};
use super::version::CHANGESET_DIR;
use super::write_set::read_text;
use super::CliError;
pub(super) fn is_marker_rewrite(name: &str) -> bool {
parse_staging_name(name).is_some_and(|staging| {
staging.kind == StagingKind::Write && is_consume_marker(staging.target)
})
}
pub(super) fn is_consume_leftover(name: &str) -> bool {
is_consume_staging_name(name) || is_marker_rewrite(name)
}
pub(super) fn mark_rolled_back(dir: &Dir, marker: &Path) -> Result<(), CliError> {
let body = format!("{MARKER_ROLLED_BACK}\n");
if write_file_via_rename(dir, marker, &body).is_ok() {
return Ok(());
}
let overwrite = dir
.open_with(marker, OpenOptions::new().write(true).truncate(true))
.and_then(|mut file| file.write_all(body.as_bytes()));
overwrite.map_err(|err| {
CliError::new(format!(
"failed to mark `{}` as rolled back: {err}",
repo_path_display(marker)
))
})
}
const CONSUME_MARKER_NAME: &str = "version";
pub(super) fn is_consume_marker(name: &str) -> bool {
parse_staging_name(name).is_some_and(|staging| {
let parts: Vec<&str> = staging.tail.split('.').collect();
staging.kind == StagingKind::Consume
&& staging.target == CONSUME_MARKER_NAME
&& parts.len() == 3
&& parts
.iter()
.all(|part| !part.is_empty() && part.bytes().all(|b| b.is_ascii_digit()))
})
}
pub(super) const MARKER_ROLLED_BACK: &str = "rolled-back";
pub(super) fn encode_marker_line(path: &str) -> String {
path.replace('\\', "\\\\").replace('\n', "\\n")
}
pub(super) fn decode_marker_line(line: &str) -> Option<String> {
let mut out = String::with_capacity(line.len());
let mut chars = line.chars();
while let Some(ch) = chars.next() {
if ch == '\\' {
match chars.next()? {
'\\' => out.push('\\'),
'n' => out.push('\n'),
_ => return None,
}
} else {
out.push(ch);
}
}
Some(out)
}
pub(super) fn create_consume_marker(
dir: &Dir,
sub: &Path,
consumes: &[&Path],
) -> Result<PathBuf, CliError> {
let mut body = String::new();
for path in consumes {
body.push_str(&encode_marker_line(&repo_path_display(path)));
body.push('\n');
}
for attempt in 0..16 {
let candidate = staging_candidate(sub, CONSUME_MARKER_NAME, CONSUME_MARK, attempt);
match dir.open_with(&candidate, OpenOptions::new().create_new(true).write(true)) {
Ok(mut file) => {
return match file.write_all(body.as_bytes()) {
Ok(()) => Ok(candidate),
Err(err) => {
drop(file);
let _ = dir.remove_file(&candidate);
Err(CliError::new(format!(
"failed to write `{}`: {err}",
repo_path_display(&candidate)
)))
}
};
}
Err(err) if err.kind() == io::ErrorKind::AlreadyExists => {}
Err(err) => {
return Err(CliError::new(format!(
"failed to create `{}`: {err}",
repo_path_display(&candidate)
)));
}
}
}
Err(CliError::new(format!(
"failed to create a consume marker in `{}`: every name was taken",
repo_path_display(sub)
)))
}
pub(super) const CONSUME_CLAIM: &str = "left by an `oakum version` that did not finish; if no \
oakum run is in progress, run `oakum version` for how to recover";
pub(super) fn refuse_interrupted_consume(dir: &Dir) -> Result<(), Box<dyn std::error::Error>> {
let left: Vec<String> = stray_staging_files(dir, CHANGESET_DIR)?
.into_iter()
.filter(|path| is_consume_leftover(file_name(path)))
.collect();
if left.is_empty() {
return Ok(());
}
let state = classify(&observe(dir, &left)).advice();
let mut message = format!(
"{} file(s) in {CHANGESET_DIR}/ left by an `oakum version` that did not finish; if no \
oakum run is in progress, {state}:",
left.len()
);
for path in left.iter().take(LEFT_SHOWN) {
let _ = write!(message, "\n {path:?}");
}
if let Some(rest) = left.len().checked_sub(LEFT_SHOWN).filter(|rest| *rest > 0) {
let _ = write!(message, "\n … {rest} more");
}
Err(Box::new(CliError::new(message)))
}
const LEFT_SHOWN: usize = 5;
fn file_name(path: &str) -> &str {
path.rsplit('/').next().unwrap_or(path)
}
#[derive(Debug, PartialEq, Eq)]
enum ConsumeState {
Landed,
Finished,
Before,
Unknown { set_aside: bool },
RolledBack,
}
impl ConsumeState {
fn advice(&self) -> &'static str {
match self {
Self::RolledBack => {
"it failed and began rolling back, then stopped partway or could not put everything \
back. Keep none of its writes: rename each set-aside file back to its bump-file \
name, use `git status` and `git diff` to put each manifest and changelog back as \
you meant, keeping any edit you made before the run, then remove these files"
}
Self::Landed => {
"it had written every manifest and changelog and begun consuming bump files, so the \
bump files still beside these were applied too. Keep those writes and remove the \
remaining bump files and these files, or revert the writes and rename each \
set-aside file back to its bump-file name"
}
Self::Finished => {
"it had written every manifest and changelog and consumed every bump file, so \
nothing is owed; remove these files"
}
Self::Before => {
"its manifest and changelog writes may have landed in part or in full, and no bump \
file was consumed. Compare the manifest versions and each changelog's top entry \
with the bump files, revert any write that landed, then remove these files"
}
Self::Unknown { set_aside: false } => {
"what it left does not say how far it got. Compare the manifest \
versions and each changelog's top entry with the bump files to see whether its \
writes landed and which bump files they applied, then remove these files"
}
Self::Unknown { set_aside: true } => {
"what it left does not say how far it got, and it set bump files aside. Compare the \
manifest versions and each changelog's top entry with the bump files; rename each \
set-aside file back to its bump-file name unless the writes you keep applied it, \
remove each one they did apply, and remove the marker only once every bump file \
is accounted for"
}
}
}
}
struct Observed {
rewrite: bool,
set_aside: bool,
markers: Vec<MarkerRead>,
}
enum MarkerRead {
Unreadable,
RolledBack,
Undecodable,
Listing { listed: usize, present: usize },
}
fn observe(dir: &Dir, left: &[String]) -> Observed {
let rewrite = left.iter().any(|path| is_marker_rewrite(file_name(path)));
let set_aside = left.iter().any(|path| !is_consume_marker(file_name(path)));
let markers = left
.iter()
.filter(|path| is_consume_marker(file_name(path)))
.map(|marker| match read_text(dir, Path::new(marker)) {
Ok(Some(body)) => read_marker(dir, &body),
_ => MarkerRead::Unreadable,
})
.collect();
Observed {
rewrite,
set_aside,
markers,
}
}
fn read_marker(dir: &Dir, body: &str) -> MarkerRead {
if body.lines().next() == Some(MARKER_ROLLED_BACK) {
return MarkerRead::RolledBack;
}
let (mut listed, mut present) = (0, 0);
for line in body.lines().filter(|line| !line.is_empty()) {
let Some(path) = decode_marker_line(line) else {
return MarkerRead::Undecodable;
};
listed += 1;
if dir.symlink_metadata(path.as_str()).is_ok() {
present += 1;
}
}
MarkerRead::Listing { listed, present }
}
fn classify(observed: &Observed) -> ConsumeState {
let set_aside = observed.set_aside;
if observed.rewrite {
return ConsumeState::RolledBack;
}
let (mut listed, mut present) = (0, 0);
for marker in &observed.markers {
match marker {
MarkerRead::Unreadable | MarkerRead::Undecodable => {
return ConsumeState::Unknown { set_aside };
}
MarkerRead::RolledBack => return ConsumeState::RolledBack,
MarkerRead::Listing {
listed: these,
present: here,
} => {
listed += these;
present += here;
}
}
}
let empty = !observed.markers.is_empty() && listed == 0;
if set_aside && !empty {
ConsumeState::Landed
} else if listed == 0 {
ConsumeState::Unknown { set_aside }
} else if present == listed {
ConsumeState::Before
} else if present == 0 {
ConsumeState::Finished
} else {
ConsumeState::Unknown { set_aside }
}
}
#[cfg(test)]
mod tests {
use super::{classify, ConsumeState, MarkerRead, Observed};
#[test]
fn a_consume_marker_is_told_apart_from_a_set_aside_file() {
use super::is_consume_marker;
assert!(is_consume_marker(".version.oakum-consume.1.2.0"));
assert!(!is_consume_marker(".version.md.oakum-consume.1.2.0"));
assert!(!is_consume_marker(
".version.oakum-consume.foo.md.oakum-consume.1.2.0"
));
assert!(!is_consume_marker(".version.oakum-consume.1.2"));
}
#[test]
fn a_marker_line_round_trips_and_rejects_what_it_never_writes() {
use super::{decode_marker_line, encode_marker_line};
for path in [
".changeset/a.md",
".changeset/c\nd.md",
".changeset/back\\slash.md",
] {
let line = encode_marker_line(path);
assert!(!line.contains('\n'), "{line:?}");
assert_eq!(decode_marker_line(&line).as_deref(), Some(path));
}
assert_eq!(decode_marker_line(".changeset/bad\\x.md"), None);
assert_eq!(decode_marker_line(".changeset/trailing\\"), None);
}
#[test]
fn a_marker_rewrite_copy_is_told_apart() {
use super::is_marker_rewrite;
assert!(is_marker_rewrite(
"..version.oakum-consume.1.2.0.oakum-write.9.8.0"
));
assert!(!is_marker_rewrite("._config.toml.oakum-write.9.8.0"));
assert!(!is_marker_rewrite(".version.oakum-consume.1.2.0"));
assert!(!is_marker_rewrite(
"..a.md.oakum-consume.1.2.0.oakum-write.9.8.0"
));
assert!(!is_marker_rewrite(
"..version.oakum-consume.1.2.0.oakum-write.4.md.oakum-consume.7.8.0"
));
}
#[cfg(unix)]
#[test]
fn a_marker_is_marked_rolled_back_in_a_read_only_directory() {
use std::os::unix::fs::PermissionsExt;
use std::path::Path;
let root = crate::test_fixture::Fixture::new("consume", "marker-in-place");
let sub = root.join(".changeset");
std::fs::create_dir_all(&sub).unwrap();
let marker = Path::new(".changeset/.version.oakum-consume.1.2.0");
std::fs::write(root.join(marker), ".changeset/a.md\n.changeset/b.md\n").unwrap();
let dir = cap_std::fs::Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let mode = std::fs::metadata(&sub).unwrap().permissions().mode();
std::fs::set_permissions(&sub, std::fs::Permissions::from_mode(0o555)).unwrap();
let outcome = super::mark_rolled_back(&dir, marker);
std::fs::set_permissions(&sub, std::fs::Permissions::from_mode(mode)).unwrap();
outcome.expect("overwritten in place");
let body = std::fs::read_to_string(root.join(marker)).unwrap();
assert_eq!(
body,
format!("{}\n", super::MARKER_ROLLED_BACK),
"nothing of the longer listing it replaced survives"
);
}
#[test]
fn each_leftover_shape_reads_as_its_state() {
use ConsumeState::{Before, Finished, Landed, RolledBack, Unknown};
use MarkerRead::{RolledBack as Rolled, Undecodable, Unreadable};
let listing = |listed, present| MarkerRead::Listing { listed, present };
let reads = |rewrite, set_aside, markers: Vec<MarkerRead>| {
classify(&Observed {
rewrite,
set_aside,
markers,
})
};
let unknown = |set_aside| Unknown { set_aside };
assert_eq!(reads(true, true, vec![Unreadable]), RolledBack, "rewrite");
assert_eq!(
reads(false, true, vec![Unreadable]),
unknown(true),
"unreadable"
);
assert_eq!(
reads(false, false, vec![Unreadable, Rolled]),
unknown(false),
"unreadable first"
);
assert_eq!(reads(false, true, vec![Rolled]), RolledBack, "rolled-back");
assert_eq!(
reads(false, false, vec![Rolled, Undecodable]),
RolledBack,
"rolled-back first"
);
assert_eq!(
reads(false, true, vec![Undecodable]),
unknown(true),
"undecodable"
);
assert_eq!(
reads(false, true, vec![]),
Landed,
"set-aside-without-marker"
);
assert_eq!(reads(false, true, vec![listing(1, 1)]), Landed, "landed");
assert_eq!(
reads(false, false, vec![listing(0, 0)]),
unknown(false),
"empty listing"
);
assert_eq!(
reads(false, true, vec![listing(0, 0)]),
unknown(true),
"an empty marker beside a set-aside file is not a landed consume"
);
assert_eq!(
reads(false, false, vec![listing(2, 2)]),
Before,
"all present"
);
assert_eq!(
reads(false, false, vec![listing(1, 0), listing(1, 1)]),
unknown(false),
"listings add up"
);
assert_eq!(
reads(false, false, vec![listing(1, 0)]),
Finished,
"finished"
);
assert_eq!(
reads(false, false, vec![listing(2, 1)]),
unknown(false),
"partly gone"
);
}
#[test]
fn a_marker_body_parses_once() {
let root = crate::test_fixture::Fixture::new("consume", "marker-parse");
std::fs::create_dir_all(root.join(".changeset")).unwrap();
std::fs::write(root.join(".changeset/one.md"), "").unwrap();
let dir = cap_std::fs::Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let read = |body: &str| super::read_marker(&dir, body);
assert!(matches!(
read(".changeset/one.md\n\n.changeset/gone.md\r\n"),
MarkerRead::Listing {
listed: 2,
present: 1
}
));
assert!(matches!(
read("rolled-back\n.changeset/bad\\x.md\n"),
MarkerRead::RolledBack
));
assert!(matches!(
read(".changeset/one.md\n.changeset/bad\\x.md\n"),
MarkerRead::Undecodable
));
assert!(matches!(
read(""),
MarkerRead::Listing {
listed: 0,
present: 0
}
));
}
#[test]
fn each_state_gives_its_own_advice() {
let says = |state: ConsumeState, phrase: &str| {
let advice = state.advice();
assert!(advice.contains(phrase), "{state:?}: {advice}");
advice
};
let rolled_back = says(ConsumeState::RolledBack, "Keep none of its writes");
assert!(
rolled_back.contains("`git status` and `git diff`"),
"{rolled_back}"
);
assert!(rolled_back.contains("stopped partway"), "{rolled_back}");
assert!(
rolled_back.contains("keeping any edit you made before the run"),
"{rolled_back}"
);
says(ConsumeState::Landed, "remove the remaining bump files");
says(ConsumeState::Finished, "nothing is owed");
says(ConsumeState::Before, "revert any write that landed");
says(
ConsumeState::Unknown { set_aside: false },
"does not say how far it got",
);
let unknown_set_aside = says(
ConsumeState::Unknown { set_aside: true },
"rename each set-aside file back",
);
assert!(
!unknown_set_aside.contains("then remove these files"),
"{unknown_set_aside}"
);
assert!(
unknown_set_aside.contains("remove each one they did apply"),
"{unknown_set_aside}"
);
}
}