fix(workspace): a deleted project asks nothing, prunes and copies clean up only after what ended well

Owner review 2, phase 5a (R8), fix round 4.

A project the library no longer has now reads as Gone with no conflict to
answer. The conflict stays recorded in sync.json, so Save both on a deleted
project says Gone once and offers its copy. It no longer reopens the conflict
dialog. Keep mine and Take the library's first check that the home still has
the project. Neither is merged onto the last version a deleted project had,
so the working state and the unsent versions stay as they were.

Old files in versions/.replaced are pruned only after a push that ended well,
never after one that stopped at a conflict. A file an earlier build set aside
kept the time its version was written. It now counts as set aside no earlier
than when this build first knew the folder (versions/.replaced.since), so an
upgrade does not prune it by an old mtime. The Merge mark goes on the replayed
version whose own change met a setting the conflict listed. A version that
only rides along with a working-state conflict stays a commit.

A first copy cancelled while paused or failed, which no handler runs, now has
its partial media removed under the project's lease, as a running one does
(ICancelledJobHandler). The space estimate counts a proxy held under its
<id>-<sha16>.jpg name. The frames stamp carries a weighted SQL checksum of
the hashes, so a hash replaced in place (a Verify) makes the workspace read
the frames again.

Desktop: a removal that cannot move a file puts back what it moved, so the
copy stays whole and listed, and the failure is said. The Removed toast names
a damaged copy as it is known, never by its folder id. One copy that cannot
be listed no longer hides the others. A Main this Chronos cannot read (newer
or damaged) is refused at once with the reason, and a damaged one offers
Remove local copy. Save version is off on a Gone project, and Send/Delete
there say the project was deleted in the library.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Alby96andClaude Opus 5.5 committed 2026-11-03 14:07:35 +01:00
1 parent c5ed31bced
commit 279ebf437f
14 files changed
+729 -57

No files matched your search

+38 -3
View File
@@ -443,10 +443,12 @@ public sealed class SequenceViewModel : SectionViewModel
try
{
var plan = await workspace.PlanRemovalAsync(projectId);
OpenDialog(new RemoveCopyDialogViewModel(plan, discard => RemoveCopyAsync(projectId, name, discard), async () =>
// A damaged copy is named as it is still known, never by its folder's id (none when nothing knows it).
var shown = plan.Damaged ? plan.KnownName : name;
OpenDialog(new RemoveCopyDialogViewModel(plan, discard => RemoveCopyAsync(projectId, shown, discard), async () =>
{
await workspace.SendAllAsync(projectId);
await RemoveCopyAsync(projectId, name, discard: false);
await RemoveCopyAsync(projectId, shown, discard: false);
}, () => plan.Damaged ? RemoveCopyDialogViewModel.ConfirmDiscard(_workspaceUi, plan) : RemoveCopyDialogViewModel.ConfirmDiscard(_workspaceUi, name),
d => CloseDialog(d)));
}
@@ -456,7 +458,7 @@ public sealed class SequenceViewModel : SectionViewModel
Shell.Notify(Loc.L("Editor.Workspace.RemoveFailed"), WorkspaceText.Failure(ex), isError: true);
}
async Task RemoveCopyAsync(Guid id, string project, bool discard)
async Task RemoveCopyAsync(Guid id, string? project, bool discard)
{
await workspace.RemoveLocalCopyAsync(id, discard);
Shell.Notify(Loc.L("Editor.Workspace.Removed"), project);
@@ -604,6 +606,15 @@ public sealed class SequenceViewModel : SectionViewModel
};
// This Chronos cannot read its working state (damaged, or a newer Chronos's): nothing is checked out over it.
if (entry is { IsReadable: false } unreadable) throw WorkspaceHost.Unreadable(unreadable);
// No project of the sequence here opens, and its Main here is such a copy (never among its projects): said at once,
// with Remove local copy for a damaged one, rather than asking which project and then refusing Main.
if (entry is null && request?.ProjectId is null && await UnreadableMainAsync(workspace, row.Id) is { } main)
{
RefuseUnreadable(main);
_afterOpen = null;
Shell.KeepSequence(OpenSequenceId);
return null;
}
if (entry is { HasMedia: true })
{
workspace.Remember(row.Id, entry.ProjectId);
@@ -647,6 +658,30 @@ public sealed class SequenceViewModel : SectionViewModel
return null;
}
/// <summary>The workspace's copy of the sequence's Main when this Chronos cannot read it (damaged, or a newer Chronos's); null otherwise.</summary>
private static async Task<WorkspaceEntry?> UnreadableMainAsync(WorkspaceHost workspace, Guid sequenceId)
{
if ((await workspace.HomeProjectsAsync(sequenceId)).FirstOrDefault(p => p.IsMain) is not { } main) return null;
return await workspace.FindAsync(main.Id) is { IsReadable: false } copy ? copy : null;
}
/// <summary>
/// Why a copy this Chronos cannot read does not open: a newer Chronos's is left as it is (nothing is offered over it), a
/// damaged one offers Remove local copy, whose Discard keeps its files aside.
/// </summary>
private void RefuseUnreadable(WorkspaceEntry copy)
{
Log.Info("workspace", $"Project {copy.ProjectId} here cannot be read by this Chronos ({(copy.Newer ? "newer" : "damaged")}): it is not opened");
if (copy.Newer)
{
Shell.Notify(Loc.L("Editor.Workspace.OpenFailed"), Loc.L("Errors.Workspace.NewerCopy"), isError: true);
return;
}
var item = new WorkspaceProjectItem(copy, null);
Shell.Notify(Loc.L("Editor.Workspace.OpenFailed"), Loc.L("Errors.Workspace.Damaged"), Loc.L("Editor.Project.RemoveCopy"),
Loc.L("Tooltips.Editor.Workspace.State.DamagedCopy"), () => _ = RemoveProjectCopyAsync(item), isError: true);
}
/// <summary>
/// "Open in workspace": the projects of the sequence's home, the media, what their copy writes and the room the
/// workspace's drive has; null when closed without a choice.
@@ -138,9 +138,11 @@ public sealed class ProjectMenuViewModel : LocalizedViewModel
public string MediaUpdateText => Loc.L(IsUpdatingMedia ? "Editor.Workspace.Updating" : "Editor.Workspace.MediaChanged");
public bool CanSaveVersion => !_session.IsReadOnly && _status is not { Conflict: not null } and not { MediaRemoved: true };
/// <summary>A version can be saved: the settings are this Chronos's, no conflict waits, the media are here and the library still has the project.</summary>
public bool CanSaveVersion => !_session.IsReadOnly && _status is not { Conflict: not null } and not { MediaRemoved: true } and not { State: WorkspaceState.Gone };
public string SaveVersionToolTip => _session.IsReadOnly ? Loc.L("Errors.Workspace.ReadOnly")
: _status?.State == WorkspaceState.Gone ? Loc.L("Errors.Workspace.DeletedAtHome")
: _status?.Conflict is not null ? Loc.L("Errors.Workspace.Conflict")
: Loc.L("Tooltips.Editor.Project.SaveVersion");
@@ -221,7 +223,9 @@ public sealed class ProjectMenuViewModel : LocalizedViewModel
_ui.Notify(Loc.L("Editor.Workspace.Saved", Formatting.Count(result.Version.Number)), Name);
}
if (result.SyncError is { } error) _ui.Notify(Loc.L("Editor.Workspace.NotSent"), WorkspaceText.Failure(error), isError: error is not HomeUnavailableException);
if (result.Status.Conflict is { } conflict) AskConflict(conflict);
// Deleted in the library: said once, and no conflict is asked (nothing can be merged with it); the version stays here.
if (result.Status.State == WorkspaceState.Gone) NotifyGone();
else if (result.Status.Conflict is { } conflict) AskConflict(conflict);
}
/// <summary>
@@ -239,7 +243,7 @@ public sealed class ProjectMenuViewModel : LocalizedViewModel
if (_disposed) return;
Apply(result.Status);
await TakeAsync(result);
if (result.Status.State == WorkspaceState.Gone) _ui.Notify(Loc.L("Editor.Workspace.State.Gone"), Loc.L("Errors.Workspace.DeletedAtHome"));
if (result.Status.State == WorkspaceState.Gone) NotifyGone();
else if (result.Status.Conflict is { } conflict) AskConflict(conflict, background: quiet);
else if (!quiet) _ui.Notify(Loc.L(result.Status.State == WorkspaceState.InSync ? "Editor.Workspace.InSync" : "Editor.Workspace.Synced"), Name);
}
@@ -260,6 +264,8 @@ public sealed class ProjectMenuViewModel : LocalizedViewModel
/// Settles the conflict <paramref name="shown"/> listed (else the one recorded) as chosen, then brings the settled
/// working state into the editor: the library's values taken as one undo step (the toast's Undo, Ctrl+Z), what Save
/// both made offered by its toast. When what differs changed since it was shown, nothing is settled and it is asked again.
/// A project deleted in the library meanwhile is said so once, nothing asked again: its work stays here (the copy Save
/// both made holding it too, offered by its toast).
/// </summary>
public async Task ResolveAsync(ConflictChoice choice, WorkspaceConflict? shown = null)
{
@@ -267,6 +273,12 @@ public sealed class ProjectMenuViewModel : LocalizedViewModel
var result = await _host.ResolveAsync(ProjectId, choice, shown: shown);
if (_disposed) return;
Apply(result.Status);
if (result.Status.State == WorkspaceState.Gone)
{
NotifyGone();
NotifySavedAs(result);
return;
}
if (result.Status.Conflict is { } again)
{
await TakeAsync(result);
@@ -283,14 +295,21 @@ public sealed class ProjectMenuViewModel : LocalizedViewModel
{
await TakeAsync(result, force: true);
}
if (result.SavedAs is { } copy)
{
var sequenceId = SequenceId;
_ui.Notify(Loc.L("Editor.Workspace.SavedAs", copy.Name), Name, Loc.L("Editor.Workspace.OpenCopy"), Loc.L("Tooltips.Editor.Workspace.OpenCopy", copy.Name),
() => _ = _ui.OpenProjectAsync(sequenceId, copy.Id));
}
NotifySavedAs(result);
}
/// <summary>The project Save both made, offered by its toast.</summary>
private void NotifySavedAs(WorkspaceSyncResult result)
{
if (result.SavedAs is not { } copy) return;
var sequenceId = SequenceId;
_ui.Notify(Loc.L("Editor.Workspace.SavedAs", copy.Name), Name, Loc.L("Editor.Workspace.OpenCopy"), Loc.L("Tooltips.Editor.Workspace.OpenCopy", copy.Name),
() => _ = _ui.OpenProjectAsync(sequenceId, copy.Id));
}
/// <summary>The library no longer has the project: nothing more is sent, its work stays here (Remove local copy keeps it aside).</summary>
private void NotifyGone() => _ui.Notify(Loc.L("Editor.Workspace.State.Gone"), Loc.L("Errors.Workspace.DeletedAtHome"));
/// <summary>
/// Restores <paramref name="version"/> as the project, as one undo step (uncommitted changes are saved as a version
/// first, so nothing is lost); the toast's Undo takes it back while it is the last change.
@@ -485,6 +504,8 @@ public sealed class ProjectMenuViewModel : LocalizedViewModel
var result = await _host.SyncAsync(ProjectId);
Apply(result.Status);
await TakeAsync(result);
// Nothing can be sent to a project the library no longer has: only Discard takes the copy, its work kept aside.
if (result.Status.State == WorkspaceState.Gone) throw new WorkspaceException(Loc.L("Errors.Workspace.DeletedAtHome"));
if (result.Status.Conflict is { } conflict)
{
AskConflict(conflict);
@@ -619,7 +640,15 @@ public sealed class ProjectMenuViewModel : LocalizedViewModel
var gone = last.State == WorkspaceState.Gone;
// A base that moved since (a sync) leaves how far the library is ahead unknown until it is asked again.
var behind = last.Base?.VersionId == local.Base?.VersionId ? last.Behind : 0;
var status = local with { Behind = behind, Offline = last.Offline, HomeHead = last.HomeHead, MediaOutdated = last.MediaOutdated };
// A project the library no longer has holds no conflict to answer (the one recorded stays for the record).
var status = local with
{
Behind = behind,
Offline = last.Offline,
HomeHead = last.HomeHead,
MediaOutdated = last.MediaOutdated,
Conflict = gone ? null : local.Conflict,
};
var state = gone ? WorkspaceState.Gone
: status.MediaRemoved ? WorkspaceState.MediaRemoved
: status.Damaged > 0 ? WorkspaceState.Damaged
+73 -13
View File
@@ -211,7 +211,18 @@ public sealed class WorkspaceHost
{
if (!Directory.Exists(Root) && await InsideALibraryAsync(cancellationToken).ConfigureAwait(false)) return [];
var entries = new List<WorkspaceEntry>();
foreach (var project in Store.List()) entries.Add(await EntryOrUnreadableAsync(project, cancellationToken).ConfigureAwait(false));
foreach (var project in Store.List())
{
try
{
entries.Add(await EntryOrUnreadableAsync(project, cancellationToken).ConfigureAwait(false));
}
catch (Exception ex) when (ex is not OperationCanceledException and not OutOfMemoryException)
{
// One copy that cannot be listed never hides the others.
Log.Warning("workspace", $"The project in {project.Folder} could not be listed", ex);
}
}
return (IReadOnlyList<WorkspaceEntry>)entries;
}, cancellationToken);
@@ -377,6 +388,8 @@ public sealed class WorkspaceHost
State = local.State is WorkspaceState.MediaRemoved or WorkspaceState.Damaged or WorkspaceState.Conflict && !gone ? local.State
: gone ? WorkspaceState.Gone
: WorkspaceState.Offline,
// Gone holds no conflict to answer; the one recorded stays in the copy.
Conflict = gone ? null : local.Conflict,
};
}
}, cancellationToken);
@@ -468,6 +481,8 @@ public sealed class WorkspaceHost
Log.Info("workspace", $"Conflict of project {projectId} not settled ({choice}): what differs changed since it was shown");
return resolved;
}
// Deleted in the library: nothing more to send (a Save both's copy holds the versions already).
if (resolved.Status.State == WorkspaceState.Gone) return resolved;
Log.Info("workspace", $"Conflict of project {projectId} settled: {choice}{(resolved.SavedAs is { } copy ? $", saved as '{copy.Name}'" : string.Empty)}");
var pushed = await Sync.PushAsync(projectId, home, cancellationToken).ConfigureAwait(false);
return new WorkspaceSyncResult(pushed.Status, [.. resolved.Pushed, .. pushed.Pushed], [.. resolved.Pulled, .. pushed.Pulled], resolved.SavedAs)
@@ -575,6 +590,7 @@ public sealed class WorkspaceHost
if (local.Conflict is not null) throw new WorkspaceException(Loc.L("Errors.Workspace.Conflict"));
if (!local.ReadOnly) await Sync.CommitAsync(projectId, null, null, cancellationToken).ConfigureAwait(false);
var status = (await SendAsync(projectId, home, cancellationToken).ConfigureAwait(false)).Status;
if (status.State == WorkspaceState.Gone) throw new WorkspaceException(Loc.L("Errors.Workspace.DeletedAtHome"));
if (status.Conflict is not null) throw new WorkspaceException(Loc.L("Errors.Workspace.Conflict"));
if (status.Ahead > 0 || (status.Modified && !status.ReadOnly)) throw new WorkspaceException(Loc.L("Errors.Workspace.Unsent"));
await ArchiveProjects(project).DeleteAsync(projectId, cancellationToken).ConfigureAwait(false);
@@ -586,9 +602,10 @@ public sealed class WorkspaceHost
}
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or LeaseUnavailableException)
{
// The home's delete stands (its trash holds every version); the copy, all of it sent, waits for Remove local copy.
// The home's delete stands (its trash holds every version); the copy, all of it sent and put back whole, waits
// for Remove local copy. One whose working state could not go back is no longer listed: nothing waits for it.
Log.Warning("workspace", $"Project {projectId} was deleted at its home, but its local copy stays", ex);
return (workspace.Home.SequenceId, false);
return (workspace.Home.SequenceId, !project.Exists);
}
}, cancellationToken);
Forget(sequenceId, projectId);
@@ -605,6 +622,7 @@ public sealed class WorkspaceHost
var local = await Task.Run(() => Sync.StatusAsync(projectId, null, cancellationToken), cancellationToken).ConfigureAwait(false);
if (local is { Conflict: null, ReadOnly: false, MediaRemoved: false }) await CommitAsync(projectId, cancellationToken).ConfigureAwait(false);
var status = (await SyncAsync(projectId, cancellationToken).ConfigureAwait(false)).Status;
if (status.State == WorkspaceState.Gone) throw new WorkspaceException(Loc.L("Errors.Workspace.DeletedAtHome"));
if (status.Conflict is not null) throw new WorkspaceException(Loc.L("Errors.Workspace.Conflict"));
if (status.Ahead > 0 || (status.Modified && !status.ReadOnly)) throw new WorkspaceException(Loc.L("Errors.Workspace.Unsent"));
}
@@ -626,7 +644,9 @@ public sealed class WorkspaceHost
var name = project.ReadBundle().Workspace!.Name;
var status = await StatusAsync(projectId, cancellationToken: cancellationToken).ConfigureAwait(false);
var (files, bytes) = Measure(project.Folder);
return new WorkspaceRemovalPlan(projectId, name, files, bytes, status.Ahead + status.Damaged, status.Modified, status.Conflict is not null, status.Offline,
// A conflict recorded counts as work not at the home, also once the library no longer has the project (Gone asks none).
var conflict = status.Conflict is not null || project.ReadSync().Conflict is not null;
return new WorkspaceRemovalPlan(projectId, name, files, bytes, status.Ahead + status.Damaged, status.Modified, conflict, status.Offline,
status.State == WorkspaceState.Gone);
}, cancellationToken);
@@ -751,8 +771,10 @@ public sealed class WorkspaceHost
/// The project's folder taken out of the workspace under its lease: every file and folder in it but the media and the
/// lease (the working state, the versions, the sync state, the exports, and whatever else a Chronos keeps there) moved
/// to <c>.trash/&lt;id&gt;-&lt;time&gt;</c> as it is (kept: nothing a user made is erased), the media deleted; the emptied
/// folder goes once the lease is released, only when nothing else came into it meanwhile.
/// folder goes once the lease is released, only when nothing else came into it meanwhile. A file that cannot be moved
/// (held open) puts back what was moved, so the copy stays whole and listed, and the failure is thrown.
/// </summary>
/// <exception cref="IOException">A file of the copy could not be moved; the copy is as it was.</exception>
private async Task RemoveFolderAsync(WorkspaceProject project, CancellationToken cancellationToken)
{
// A copy of its media still under way would write them again behind the removal.
@@ -765,16 +787,53 @@ public sealed class WorkspaceHost
using (await project.LockAsync(LockWait, cancellationToken).ConfigureAwait(false))
{
Directory.CreateDirectory(aside);
// The working state first: without it the folder is no project any more, whatever happens after.
File.Move(project.BundlePath, Path.Combine(aside, WorkspaceProject.BundleFile));
foreach (var entry in Directory.EnumerateFileSystemEntries(project.Folder).ToList())
var moved = new List<(string From, string To)>();
try
{
var name = Path.GetFileName(entry);
if (IsLease(name) || string.Equals(name, WorkspaceProject.MediaFolder, StringComparison.OrdinalIgnoreCase)) continue;
if (Directory.Exists(entry)) Directory.Move(entry, Path.Combine(aside, name));
else File.Move(entry, Path.Combine(aside, name));
// The working state first: without it the folder is no project any more, whatever happens after.
Move(project.BundlePath, Path.Combine(aside, WorkspaceProject.BundleFile));
foreach (var entry in Directory.EnumerateFileSystemEntries(project.Folder).ToList())
{
var name = Path.GetFileName(entry);
if (IsLease(name) || string.Equals(name, WorkspaceProject.MediaFolder, StringComparison.OrdinalIgnoreCase)) continue;
Move(entry, Path.Combine(aside, name));
}
}
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
{
// A file held open (another program's): everything moved goes back, the working state last, so the copy stays
// whole and listed, and Remove local copy can be asked again.
Log.Warning("workspace", $"The copy in {project.Folder} could not be moved aside: what was moved goes back", ex);
for (var i = moved.Count - 1; i >= 0; i--)
{
try
{
if (Directory.Exists(moved[i].To)) Directory.Move(moved[i].To, moved[i].From);
else File.Move(moved[i].To, moved[i].From);
}
catch (Exception back) when (back is IOException or UnauthorizedAccessException)
{
Log.Error("workspace", $"{moved[i].To} could not go back to {moved[i].From}: it is kept there", back);
}
}
try
{
if (!Directory.EnumerateFileSystemEntries(aside).Any()) Directory.Delete(aside);
}
catch (Exception left) when (left is IOException or UnauthorizedAccessException)
{
Log.Debug("workspace", $"{aside} stays: {left.Message}");
}
throw;
}
if (Directory.Exists(project.MediaDirectory)) Directory.Delete(project.MediaDirectory, recursive: true);
void Move(string from, string to)
{
if (Directory.Exists(from)) Directory.Move(from, to);
else File.Move(from, to);
moved.Add((from, to));
}
}
try
{
@@ -885,8 +944,9 @@ public sealed class WorkspaceHost
title ??= (await db.Sequences.GetAsync(known.SequenceId, cancellationToken).ConfigureAwait(false))?.DisplayTitle;
}
}
catch (DatabaseException dbx)
catch (Exception dbx) when (dbx is not OperationCanceledException and not OutOfMemoryException)
{
// The index closing (the program ending), or any other failure: the copy is listed by what is known.
Log.Info("workspace", $"The index could not name the project in {project.Folder}: {dbx.Message}");
}
}
+21 -2
View File
@@ -128,8 +128,27 @@ public sealed class JobEngine : IAsyncDisposable
/// </summary>
public bool CanRun(JobKind kind) => _handlers.ContainsKey(kind) && (Options.Kinds is null || Options.Kinds.Contains(kind));
/// <summary>Cancels a queued or running job; a running handler observes its token.</summary>
public Task CancelAsync(Guid id, CancellationToken cancellationToken = default) => TransitionAsync(id, JobState.Cancelled, cancellationToken);
/// <summary>
/// Cancels a queued or running job; a running handler observes its token. A paused or failed one, which no handler runs,
/// leaves what it wrote to its handler to clear (<see cref="ICancelledJobHandler"/>).
/// </summary>
public async Task CancelAsync(Guid id, CancellationToken cancellationToken = default)
{
var before = await _db.Jobs.GetAsync(id, cancellationToken).ConfigureAwait(false);
await TransitionAsync(id, JobState.Cancelled, cancellationToken).ConfigureAwait(false);
// Neither claimable nor running here: no handler cleans up after it itself.
if (before is not { State: JobState.Paused or JobState.Failed } || _running.ContainsKey(id)
|| !_handlers.TryGetValue(before.Kind, out var handler) || handler is not ICancelledJobHandler cancelled)
return;
try
{
await cancelled.CancelledAsync(before with { State = JobState.Cancelled }, cancellationToken).ConfigureAwait(false);
}
catch (Exception ex) when (!(ex is OperationCanceledException && cancellationToken.IsCancellationRequested))
{
Log.Warning("jobs", $"{before.Kind} job {id} was cancelled, but what it left could not be cleared", ex);
}
}
/// <summary>Pauses a job: a running one stops at its next check and keeps its checkpoint, and the next queued job starts.</summary>
public Task PauseAsync(Guid id, CancellationToken cancellationToken = default) => TransitionAsync(id, JobState.Paused, cancellationToken);
+14
View File
@@ -23,6 +23,20 @@ public interface ISelectiveJobHandler : IJobHandler
ValueTask<bool> AcceptsAsync(Job job, CancellationToken cancellationToken);
}
/// <summary>
/// A handler whose jobs leave something behind that a cancel removes (a first copy's partial files). A running job sees the
/// cancel through its token and cleans up itself; for a job no handler runs when it is cancelled (paused, failed), the
/// engine tells the handler instead (<see cref="JobEngine.CancelAsync"/>).
/// </summary>
public interface ICancelledJobHandler : IJobHandler
{
/// <summary>
/// <paramref name="job"/>, of this handler's kind and run by no handler now, was cancelled. Returns once the clean-up is
/// under way (it may wait for what it removes, so it should not keep the caller); a failure is the handler's to log.
/// </summary>
Task CancelledAsync(Job job, CancellationToken cancellationToken);
}
/// <summary>A component that brings several handlers (the archive engine: scan, rebuild, verify, import, images, maintenance).</summary>
public interface IJobHandlerProvider
{
+4 -3
View File
@@ -148,14 +148,15 @@ public sealed class ArchiveProjectHome(ChronosDatabase db, ProjectService projec
/// <summary>
/// The sequence's frames version (frames added, removed, converted or renamed), with how many of its photos the index has
/// hashed (a Verify hashes them without another frames version) and how many removals it keeps (a conversion's links).
/// hashed and a checksum of those hashes (a Verify hashes them, or finds other bytes, without another frames version)
/// and how many removals it keeps (a conversion's links).
/// </summary>
public async Task<string?> FramesStampAsync(CancellationToken cancellationToken)
{
var row = await db.Sequences.GetAsync(sequenceId, cancellationToken).ConfigureAwait(false)
?? throw new ProjectException(ProjectError.SequenceNotFound, $"Sequence {sequenceId} is not in the index.");
var (hashed, removals) = await db.Frames.CountNamedAsync(sequenceId, cancellationToken).ConfigureAwait(false);
return string.Create(System.Globalization.CultureInfo.InvariantCulture, $"{row.FramesVersion}:{hashed}:{removals}");
var (hashed, checksum, removals) = await db.Frames.CountNamedAsync(sequenceId, cancellationToken).ConfigureAwait(false);
return string.Create(System.Globalization.CultureInfo.InvariantCulture, $"{row.FramesVersion}:{hashed}:{checksum}:{removals}");
}
/// <summary>
@@ -239,16 +239,23 @@ public sealed class FrameRepository
}, cancellationToken);
/// <summary>
/// How many photos of a sequence the index has hashed, and how many removals (tombstones) it keeps for it: with the
/// frames version, what decides how project positions name its photos (<see cref="Projects.IProjectHome.FramesStampAsync"/>).
/// How many photos of a sequence the index has hashed, a checksum of those hashes (it moves when one is replaced in
/// place, as a Verify that finds other bytes does), and how many removals (tombstones) it keeps for it: with the frames
/// version, what decides how project positions name its photos (<see cref="Projects.IProjectHome.FramesStampAsync"/>).
/// The checksum sums the first five hex digits of each hash weighted by the frame's place, in SQL both dialects read.
/// </summary>
public Task<(long Hashed, long Removals)> CountNamedAsync(Guid sequenceId, CancellationToken cancellationToken = default) =>
public Task<(long Hashed, long Checksum, long Removals)> CountNamedAsync(Guid sequenceId, CancellationToken cancellationToken = default) =>
_db.RunAsync(async session =>
{
var find = _db.Sql.IsPostgres ? "strpos" : "instr";
string Digit(int at) => $"{find}('0123456789abcdef', lower(substr(sha256, {at}, 1)))";
var row = await session.QuerySingleAsync(
"SELECT (SELECT count(sha256) FROM frames WHERE sequence_id = $1), (SELECT count(*) FROM frame_removals WHERE sequence_id = $1)",
"SELECT (SELECT count(sha256) FROM frames WHERE sequence_id = $1), " +
$"(SELECT CAST(COALESCE(SUM(CAST(idx % 1000 + 1 AS bigint) * ({Digit(1)} * 65536 + {Digit(2)} * 4096 + {Digit(3)} * 256 + {Digit(4)} * 16 + {Digit(5)})), 0) AS bigint) " +
"FROM frames WHERE sequence_id = $1), " +
"(SELECT count(*) FROM frame_removals WHERE sequence_id = $1)",
[sequenceId], cancellationToken).ConfigureAwait(false);
return (row.GetInt64(0), row.GetInt64(1));
return (row.GetInt64(0), row.GetInt64(1), row.GetInt64(2));
}, cancellationToken);
/// <summary>Number of frames of a sequence.</summary>
@@ -66,10 +66,11 @@ public static class WorkspaceJobs
/// job stops saying how much is missing (the workspace shares this PC's drive with the index and the logs).
/// Checkpoint: <c>copy:&lt;frame&gt;:&lt;frames version&gt;:&lt;folder&gt;</c>; a run resumed on other frames or in another folder
/// checks every file again, and a pass started again stores that before it reads anything. A first copy the user cancels
/// removes the media it wrote itself, once it has stopped writing and under the project's lease (<see cref="RemovePartialMediaAsync"/>).
/// removes the media it wrote itself, once it has stopped writing and under the project's lease (<see cref="RemovePartialMediaAsync"/>);
/// one cancelled while paused or failed, which no handler runs, has them removed the same way (<see cref="CancelledAsync"/>).
/// Originals come in phase 5c: asked for, the job fails saying so.
/// </summary>
internal sealed class WorkspaceCopyJobHandler(ChronosDatabase db, ArchiveService archives) : IJobHandler
internal sealed class WorkspaceCopyJobHandler(ChronosDatabase db, ArchiveService archives) : ICancelledJobHandler
{
private const int PageSize = 1000;
private const int Passes = 3;
@@ -119,6 +120,40 @@ internal sealed class WorkspaceCopyJobHandler(ChronosDatabase db, ArchiveService
}
}
/// <summary>
/// A copy cancelled while no handler ran it (paused, failed): what a first copy wrote goes as after a cancel while it ran,
/// under the project's lease, in the background (the lease may be held for a while: the cancel does not wait for it).
/// A workspace folder or a project no longer there has nothing to clear, and nothing is made for it.
/// </summary>
public Task CancelledAsync(Job job, CancellationToken cancellationToken)
{
ArgumentNullException.ThrowIfNull(job);
WorkspaceCopyParameters parameters;
try
{
parameters = Parameters(job);
}
catch (InvalidDataException)
{
return Task.CompletedTask;
}
// Opening a store makes its folder: one gone stays gone.
if (!Directory.Exists(Path.Combine(parameters.WorkspaceRoot, parameters.ProjectId.ToString("N")))) return Task.CompletedTask;
_ = Task.Run(async () =>
{
try
{
if (new WorkspaceStore(parameters.WorkspaceRoot).Find(parameters.ProjectId) is { } project) await RemovePartialMediaAsync(job, project).ConfigureAwait(false);
}
catch (Exception ex) when (ex is not OutOfMemoryException)
{
// Nobody waits for this task: whatever stopped it is logged; the next copy checks every file it finds.
Log.Warning("workspace", $"The media of cancelled copy {job.Id} could not be cleared", ex);
}
}, CancellationToken.None);
return Task.CompletedTask;
}
/// <summary>
/// A first copy of the project's media the user cancelled (the job reads <see cref="JobState.Cancelled"/>), once it has
/// stopped writing: the photos it wrote (copies the home can make again) are removed under the project's lease, so the
@@ -131,6 +166,8 @@ internal sealed class WorkspaceCopyJobHandler(ChronosDatabase db, ArchiveService
try
{
if (await db.Jobs.GetAsync(job.Id, CancellationToken.None).ConfigureAwait(false) is not { State: JobState.Cancelled }) return;
// Nothing half written (or the copy removed meanwhile): the lease, which makes the folder, is not taken.
if (File.Exists(project.MediaIndexPath) || !Directory.Exists(project.MediaDirectory)) return;
using (await project.LockAsync(LockWait, CancellationToken.None).ConfigureAwait(false))
{
if (File.Exists(project.MediaIndexPath) || !Directory.Exists(project.MediaDirectory)) return;
@@ -441,15 +478,26 @@ internal sealed class WorkspaceCopyJobHandler(ChronosDatabase db, ArchiveService
/// <summary>
/// The bytes the copy still writes from each frame on (index <c>i</c>: frames <c>i</c> to the last; one more entry, 0):
/// nothing for a frame the workspace holds a file of already (kept, or replaced by one of about its size), the archive's
/// nothing for a frame the workspace holds a file of already (kept, or replaced by one of about its size; under its own
/// name or the one other bytes of it take, <see cref="WorkspaceProject.ProxyName(Guid, string)"/>), the archive's
/// proxy's size where it has one, else an estimate at the proxy size the copy makes (<see cref="Estimate"/>).
/// </summary>
private static long[] Remaining(WorkspaceProject project, SequencePaths folder, List<Frame> frames, ProxyPolicy policy) =>
Remaining(Directory.Exists(project.ProxiesDirectory)
? Directory.EnumerateFiles(project.ProxiesDirectory).Select(Path.GetFileName).ToHashSet(StringComparer.OrdinalIgnoreCase)
: [], folder, frames, policy);
Remaining(Directory.Exists(project.ProxiesDirectory) ? HeldFrames(Directory.EnumerateFiles(project.ProxiesDirectory, "*.jpg")) : [], folder, frames, policy);
private static long[] Remaining(HashSet<string?> held, SequencePaths folder, List<Frame> frames, ProxyPolicy policy)
/// <summary>The frames the files at <paramref name="paths"/> are proxies of: "&lt;frame id&gt;.jpg" and "&lt;frame id&gt;-&lt;sha16&gt;.jpg".</summary>
internal static HashSet<Guid> HeldFrames(IEnumerable<string> paths)
{
var held = new HashSet<Guid>();
foreach (var path in paths)
{
var name = Path.GetFileNameWithoutExtension(path);
if (name.Length >= 32 && (name.Length == 32 || name[32] == '-') && Guid.TryParseExact(name[..32], "N", out var id)) held.Add(id);
}
return held;
}
private static long[] Remaining(HashSet<Guid> held, SequencePaths folder, List<Frame> frames, ProxyPolicy policy)
{
var proxies = Directory.Exists(folder.Proxies)
? new DirectoryInfo(folder.Proxies).EnumerateFiles().ToDictionary(f => f.Name, f => f.Length, StringComparer.OrdinalIgnoreCase)
@@ -458,7 +506,7 @@ internal sealed class WorkspaceCopyJobHandler(ChronosDatabase db, ArchiveService
for (var i = frames.Count - 1; i >= 0; i--)
{
var frame = frames[i];
var bytes = held.Contains(ProxyCache.FileName(frame.Id)) ? 0
var bytes = held.Contains(frame.Id) ? 0
: proxies.TryGetValue(ArchiveLayout.ProxyFileName(frame.Index), out var length) ? length
: (frame.Flags & FrameFlags.Missing) != 0 ? 0
: Estimate(frame, policy);
+43 -4
View File
@@ -288,6 +288,13 @@ public sealed class WorkspaceProject
/// </summary>
public const string ReplacedFolder = ".replaced";
/// <summary>
/// Beside <see cref="ReplacedFolder"/> in <c>versions/</c>: when this Chronos first set a file aside there or pruned it
/// (an ISO-8601 time). A file dated before it was set aside by an earlier build, which kept the time it was written: it
/// counts as set aside then, at the earliest (<see cref="PruneReplaced"/>).
/// </summary>
public const string ReplacedSinceFile = ".replaced.since";
private const string LeaseName = ".lock";
internal WorkspaceProject(WorkspaceStore store, Guid projectId)
@@ -443,6 +450,7 @@ public sealed class WorkspaceProject
if (!File.Exists(path)) return;
var aside = Path.Combine(VersionsDirectory, ReplacedFolder);
Directory.CreateDirectory(aside);
ReplacedSince(DateTime.UtcNow);
var target = Path.Combine(aside, Path.GetFileName(path));
if (File.Exists(target)) target += "." + DateTime.UtcNow.Ticks.ToString(System.Globalization.CultureInfo.InvariantCulture);
for (var attempt = 1; ; attempt++)
@@ -469,6 +477,7 @@ public sealed class WorkspaceProject
{
ArgumentNullException.ThrowIfNull(version);
ProjectSidecars.WriteVersion(Path.Combine(VersionsDirectory, ReplacedFolder, Path.GetFileName(VersionPath(version))), version);
ReplacedSince(DateTime.UtcNow);
}
/// <summary>Files <see cref="PruneReplaced"/> keeps in <c>versions/.replaced</c> whatever their age.</summary>
@@ -481,19 +490,24 @@ public sealed class WorkspaceProject
/// Removes from <c>versions/.replaced</c> the files set aside more than <see cref="ReplacedMaxAge"/> ago and those past
/// the newest <see cref="ReplacedKept"/>, never one of a version in <paramref name="referenced"/> (a journal's). Every
/// file there is a copy of what the chain or the home holds, or what a take of the server's values replaced (its undo):
/// called only after a sync that ended well. How many went.
/// called only after a sync that ended well. A file is set aside when this Chronos dated it (it touches what it sets
/// aside), and no earlier than this Chronos first knew the folder (<see cref="ReplacedSinceFile"/>): one an earlier build
/// set aside keeps the time its version was written, which says nothing of when it went aside. How many went.
/// </summary>
internal int PruneReplaced(IReadOnlySet<Guid> referenced, DateTime nowUtc)
{
ArgumentNullException.ThrowIfNull(referenced);
var aside = Path.Combine(VersionsDirectory, ReplacedFolder);
if (!Directory.Exists(aside)) return 0;
var files = new DirectoryInfo(aside).EnumerateFiles().OrderByDescending(f => f.LastWriteTimeUtc).ThenByDescending(f => f.Name, StringComparer.Ordinal).ToList();
var since = ReplacedSince(nowUtc);
var files = new DirectoryInfo(aside).EnumerateFiles()
.Select(f => (File: f, Aside: f.LastWriteTimeUtc > since ? f.LastWriteTimeUtc : since))
.OrderByDescending(f => f.Aside).ThenByDescending(f => f.File.LastWriteTimeUtc).ThenByDescending(f => f.File.Name, StringComparer.Ordinal).ToList();
var removed = 0;
for (var i = 0; i < files.Count; i++)
{
var file = files[i];
if (i < ReplacedKept && nowUtc - file.LastWriteTimeUtc <= ReplacedMaxAge) continue;
var (file, set) = files[i];
if (i < ReplacedKept && nowUtc - set <= ReplacedMaxAge) continue;
if (VersionIdOf(file.Name) is { } id && referenced.Contains(id)) continue;
try
{
@@ -515,6 +529,31 @@ public sealed class WorkspaceProject
}
}
/// <summary>
/// When this Chronos first knew <c>versions/.replaced</c> (<see cref="ReplacedSinceFile"/>): read, else written as
/// <paramref name="nowUtc"/> (also over a file that cannot be read). One that cannot be written counts as now: nothing
/// set aside by an earlier build goes by its age then.
/// </summary>
private DateTime ReplacedSince(DateTime nowUtc)
{
var path = Path.Combine(VersionsDirectory, ReplacedSinceFile);
try
{
if (File.Exists(path)
&& DateTime.TryParse(File.ReadAllText(path).Trim(), System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.RoundtripKind,
out var known)
&& known.Kind == DateTimeKind.Utc && known <= nowUtc)
return known;
Directory.CreateDirectory(VersionsDirectory);
AtomicFile.WriteAllText(path, nowUtc.ToString("O", System.Globalization.CultureInfo.InvariantCulture));
}
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
{
Log.Debug("workspace", $"{path} could not be kept: {ex.Message}");
}
return nowUtc;
}
private static void TryTouch(string path)
{
try
+33 -6
View File
@@ -273,6 +273,8 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
{
var pushed = new List<ProjectVersion>();
var pulled = new List<ProjectVersion>();
// Ended well: every local version sent, no conflict met, no attempt left over.
var sent = false;
try
{
await SettleAsync(project, home, cancellationToken).ConfigureAwait(false);
@@ -307,7 +309,11 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
}
break;
}
if (!diverged) break;
if (!diverged)
{
sent = true;
break;
}
var (_, conflict, taken) = await ReplayAsync(project, bundle, home, null, cancellationToken).ConfigureAwait(false);
pulled.AddRange(taken);
if (conflict is not null) break;
@@ -319,7 +325,8 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
if (!await GoneAsync(project, home, ex, cancellationToken).ConfigureAwait(false)) throw;
return new WorkspaceSyncResult(await StatusLockedAsync(project, home, cancellationToken).ConfigureAwait(false), pushed, pulled);
}
PruneReplaced(project);
// A push stopped at a conflict, or by a home that kept moving, leaves versions/.replaced as it is.
if (sent && project.ReadSync().Conflict is null) PruneReplaced(project);
return new WorkspaceSyncResult(await StatusLockedAsync(project, home, cancellationToken).ConfigureAwait(false), pushed, pulled);
}
}
@@ -346,6 +353,7 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
EnsureChained(project, bundle, Unpushed(project, bundle));
if (project.ReadSync().Conflict is not null)
{
await EnsureAtHomeAsync(project, home, cancellationToken).ConfigureAwait(false);
(_, var conflict, pulled) = await ReplayAsync(project, bundle, home, null, cancellationToken).ConfigureAwait(false);
if (conflict is null) project.WriteSync(project.ReadSync() with { Conflict = null });
}
@@ -381,7 +389,8 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
/// <see cref="ConflictChoice.SaveBoth"/> saves the working state as a version, sends this workspace's versions to a new
/// project at the home (<paramref name="saveBothName"/>, else this project's name with a number) made from the base,
/// and moves this project onto the home's head; a project deleted at the home meanwhile keeps its versions here, the
/// copy holding them too (<see cref="WorkspaceState.Gone"/>).
/// copy holding them too (<see cref="WorkspaceState.Gone"/>). Keep mine and Take the server's on a project deleted at the
/// home change nothing here (it reads as Gone): nothing is merged onto the last version it had there.
/// </summary>
/// <exception cref="HomeUnavailableException">The home cannot be reached; the conflict stays.</exception>
public async Task<WorkspaceSyncResult> ResolveAsync(Guid projectId, IProjectHome home, ConflictChoice choice, IReadOnlySet<string>? takeServer = null,
@@ -400,6 +409,8 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
EnsureChained(project, bundle, Unpushed(project, bundle));
if (choice == ConflictChoice.SaveBoth)
return await SaveBothAsync(project, bundle, home, saveBothName, cancellationToken).ConfigureAwait(false);
// Never merged onto the last version of a project deleted at the home: it reads as Gone, everything here kept.
await EnsureAtHomeAsync(project, home, cancellationToken).ConfigureAwait(false);
// Nothing is committed first: a version of the working state would be replayed into one that only repeats the
// head, and sent. What the take replaces of the working state is kept aside by the replay instead.
IReadOnlySet<string> takeTheirs = choice == ConflictChoice.TakeServer ? AllPaths : takeServer ?? new HashSet<string>();
@@ -563,6 +574,9 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
}
var rebased = new List<ProjectVersion>(locals.Count);
ProjectVersion parent = head;
// The last replayed version that carries the merge: its own commit met a setting the conflict listed.
var merged = -1;
var listed = Paths(differences);
for (var i = 0; i < locals.Count; i++)
{
var local = locals[i];
@@ -574,6 +588,7 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
Log.Info("workspace", $"Version {local.Number} of project {project.ProjectId} changes nothing once replayed on version {head.Number}: it is not sent");
continue;
}
if (listed.Count > 0 && ProjectMerge.Conflicts(basisSettings, mine[i], headSettings).Any(d => listed.Contains(d.Path))) merged = rebased.Count;
parent = local with
{
Id = Guid.CreateVersion7(),
@@ -586,7 +601,8 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
};
rebased.Add(parent);
}
if (differences.Count > 0 && rebased.Count > 0) rebased[^1] = rebased[^1] with { Kind = ProjectVersionKind.Merge };
// Marked on the version that holds the choice made, never on an earlier one a skipped version leaves last.
if (merged >= 0) rebased[merged] = rebased[merged] with { Kind = ProjectVersionKind.Merge };
var placed = ProjectSettings.FromJson(ProjectContent.Place(ProjectContent.Canonical(merge.Merged.ToJson()), photos), allowNewer: true);
var moved = WithBase(bundle, head) with { Project = placed, Saved = DateTimeOffset.UtcNow };
await FinishCopyAsync(project, home, chain, cancellationToken).ConfigureAwait(false);
@@ -1095,7 +1111,8 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
/// when it cannot). The home's frames are read again only when its stamp of them moved (<see cref="IProjectHome.FramesStampAsync"/>).
/// Without the lease, a version file that reads as damaged is read again under it before the state says so: another
/// operation between two of its writes is no damage; while that one holds the project, it is not reported (that
/// operation stops at it itself). A home that answers it no longer has the project reads as <see cref="WorkspaceState.Gone"/>.
/// operation stops at it itself). A home that answers it no longer has the project reads as <see cref="WorkspaceState.Gone"/>,
/// with no conflict to answer (<see cref="WorkspaceStatus.Conflict"/> null; the one recorded stays in <c>sync.json</c>).
/// </summary>
private async Task<WorkspaceStatus> StatusLockedAsync(WorkspaceProject project, IProjectHome? home, CancellationToken cancellationToken, bool leased = true)
{
@@ -1150,7 +1167,9 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
: locals.Count > 0 ? WorkspaceState.Ahead
: modified ? WorkspaceState.Modified
: WorkspaceState.InSync;
return new WorkspaceStatus(state, modified, locals.Count, behind, offline, media is null, bundle.IsReadOnly, conflict, workspace.Base, head)
// A project the home no longer has holds no conflict to answer (nothing can be merged with it): the one recorded stays
// in sync.json, for the record and for a project the home holds again.
return new WorkspaceStatus(state, modified, locals.Count, behind, offline, media is null, bundle.IsReadOnly, gone ? null : conflict, workspace.Base, head)
{
MediaOutdated = outdated,
Damaged = damaged,
@@ -1263,6 +1282,14 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
if (removed > 0) Log.Info("workspace", $"{removed} old file(s) of project {project.ProjectId} left versions/.replaced");
}
/// <summary>
/// The home still has the project: asked before a choice or a recorded conflict is replayed, so nothing is merged onto
/// the last version of a project deleted there (whose history the home may still read back).
/// </summary>
/// <exception cref="ProjectException">The home no longer has the project or its sequence (<see cref="GoneAsync"/>).</exception>
private static async Task EnsureAtHomeAsync(WorkspaceProject project, IProjectHome home, CancellationToken cancellationToken) =>
await home.HeadAsync(project.ProjectId, cancellationToken).ConfigureAwait(false);
/// <summary>Whether a sync stopped because the home does not know a project or a version (<see cref="GoneAsync"/> tells which).</summary>
private static bool NotFoundAtHome(ProjectException ex) => ex.Reason is ProjectError.NotFound or ProjectError.SequenceNotFound;
@@ -327,6 +327,32 @@ public sealed class WorkspaceHostTests(TestContext context)
Assert.Null(host.Store.Find(vertical));
}
[Test]
public async Task ARemovalThatCannotMoveAFilePutsTheCopyBackWholeAndSaysSo()
{
await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 4);
var host = bed.Host(new AppSettings { WorkspaceAutoSync = false });
var vertical = await bed.CheckoutAsync(host, newName: "Vertical");
var project = host.Store.Find(vertical)!;
var bundle = File.ReadAllBytes(project.BundlePath);
var held = Path.Combine(project.Folder, "notes.txt");
File.WriteAllText(held, "mine");
// Another program holds a file of the copy: what was moved aside goes back, the working state with it.
using (new FileStream(held, FileMode.Open, FileAccess.Read, FileShare.None))
await Assert.ThrowsAsync<IOException>(() => host.RemoveLocalCopyAsync(vertical, discard: true));
Assert.SequenceEqual(bundle, File.ReadAllBytes(project.BundlePath), "the working state is back");
Assert.Contains(await host.ListAsync(), e => e.ProjectId == vertical && e.IsReadable);
Assert.True(Directory.Exists(project.MediaDirectory) && Directory.Exists(project.VersionsDirectory), "the copy is whole");
var trash = Path.Combine(host.Root, WorkspaceHost.TrashFolder);
Assert.False(Directory.Exists(trash) && Directory.EnumerateDirectories(trash).Any(d => Path.GetFileName(d).StartsWith(vertical.ToString("N"), StringComparison.Ordinal)),
"nothing is left aside");
// The file let go: removed.
await host.RemoveLocalCopyAsync(vertical, discard: true);
Assert.Null(host.Store.Find(vertical));
}
[Test]
public async Task OlderVersionsArePrunedPastKeptVersionsOnlyOnceTheLibraryHoldsThem()
{
@@ -176,6 +176,45 @@ public sealed class WorkspaceMenuTests(TestContext context)
}
}
[Test]
public async Task SaveBothOfAProjectDeletedInTheLibrarySaysItIsGoneOnceAndOffersTheCopy()
{
await using var bed = await WorkspaceTestBed.CreateAsync(context);
var here = bed.Host();
var there = bed.Host(name: "other-pc");
var sideId = await bed.CheckoutAsync(here, newName: "Side");
await bed.CheckoutAsync(there, sideId);
var (sourceA, sessionA) = await bed.OpenAsync(there, sideId);
var (sourceB, sessionB) = await bed.OpenAsync(here, sideId);
var (uiA, uiB) = (new RecordingUi(), new RecordingUi());
await using (sessionA)
await using (sessionB)
using (var a = new ProjectMenuViewModel(there, sourceA, sessionA, uiA))
using (var b = new ProjectMenuViewModel(here, sourceB, sessionB, uiB))
{
sessionA.Edit(p => Exposure(p, 0.1));
await a.SaveVersionAsync(null);
sessionB.Edit(p => Exposure(p, 0.7));
await b.SyncAsync();
uiB.CloseDialog(Assert.NotNull(uiB.Open as ConflictDialogViewModel));
// Another PC deletes the project in the library while the choice is made here.
await bed.Archives.Projects.DeleteAsync(sideId, bed.Ct);
var before = uiB.Toasts.Count;
await b.ResolveAsync(ConflictChoice.SaveBoth);
Assert.Equal(WorkspaceState.Gone, b.Status!.State);
Assert.Null(b.Status.Conflict, "nothing is left to answer");
Assert.Null(uiB.Open, "the conflict is not asked again");
var said = uiB.Toasts.Skip(before).ToList();
Assert.Count(1, said.Where(t => t.Message == Loc.L("Errors.Workspace.DeletedAtHome")).ToList());
var copy = Assert.Contains(said, t => t.Action is not null);
Assert.Equal(b.Name, copy.Message, "the copy Save both made is offered");
Assert.False(b.SaveVersionCommand.CanExecute(null), "nothing can be sent to it");
Assert.Equal(0.7, sessionB.Project.Exposure.ExposureOffsetEv, "the work stays in the editor");
Assert.Equal(0.7, here.Store.Find(sideId)!.ReadBundle().Project.Exposure.ExposureOffsetEv);
}
}
[Test]
public async Task OpenProjectOffersTheLibrarysOtherProjects()
{
@@ -256,6 +295,10 @@ public sealed class WorkspaceMenuTests(TestContext context)
var gone = new WorkspaceStatus(WorkspaceState.Gone, false, 0, 0, true, false, false, null, basis, null);
var edited = new WorkspaceStatus(WorkspaceState.Modified, true, 0, 0, false, false, false, null, basis, null);
Assert.Equal(WorkspaceState.Gone, ProjectMenuViewModel.WithLocal(gone, edited).State);
// A conflict recorded here asks nothing of a project the library no longer has.
var recorded = new WorkspaceConflict(Guid.NewGuid(), 3, basis.VersionId, [], [], DateTimeOffset.UtcNow);
var stillGone = ProjectMenuViewModel.WithLocal(gone, edited with { State = WorkspaceState.Conflict, Conflict = recorded });
Assert.Equal((WorkspaceState.Gone, (WorkspaceConflict?)null), (stillGone.State, stillGone.Conflict));
var behind = gone with { State = WorkspaceState.Behind, Behind = 2, Offline = false };
Assert.Equal((WorkspaceState.Behind, 2), (ProjectMenuViewModel.WithLocal(behind, edited).State, ProjectMenuViewModel.WithLocal(behind, edited).Behind));
Assert.Equal(WorkspaceState.Modified, ProjectMenuViewModel.WithLocal(behind, edited with { Base = basis with { VersionId = Guid.NewGuid() } }).State,
@@ -192,6 +192,9 @@ public sealed class WorkspaceSectionTests(TestContext context)
var aside = Assert.Contains(Directory.EnumerateDirectories(Path.Combine(outside, WorkspaceHost.TrashFolder)),
d => Path.GetFileName(d).StartsWith(damagedId.ToString("N"), StringComparison.Ordinal));
Assert.Equal("kept", await File.ReadAllTextAsync(Path.Combine(aside, "notes.txt")));
// Nothing knows its name: the toast names no folder id.
await WorkspaceTestBed.UntilAsync(() => toasts.Any(t => t.Title == Loc.L("Editor.Workspace.Removed")), "the removal is said");
Assert.Null(toasts.Single(t => t.Title == Loc.L("Editor.Workspace.Removed")).Message);
}
finally
{
@@ -201,6 +204,91 @@ public sealed class WorkspaceSectionTests(TestContext context)
}
});
[Test]
public Task AMainThisChronosCannotReadSaysWhyAtOnceAndADamagedOneOffersItsRemoval() => ScreenHost.RunAsync(async () =>
{
var directory = context.CreateTempDirectory("workspace-unreadable-main");
var environment = AppEnvironment.From(AppPaths.Resolve(Directory.CreateDirectory(Path.Combine(directory, "app")).FullName,
Directory.CreateDirectory(Path.Combine(directory, "local")).FullName, []));
UiLanguage.Apply("en");
var settings = new AppSettings { Language = "en", FirstRunCompleted = true, CheckForUpdates = false };
var dialogs = new ScriptedDialogs();
var services = new AppServices(environment, settings, () => { }, dialogs);
await services.AttachAsync(await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(environment.DatabasePath)), startEngine: true);
var shell = new ShellViewModel(services);
var toasts = new List<Toast>();
shell.PendingToasts.CollectionChanged += (_, e) => toasts.AddRange(e.NewItems?.OfType<Toast>() ?? []);
try
{
var sequenceId = await SequenceAsync(services, Path.Combine(directory, "archive"));
var section = shell.Sequence;
shell.OpenSequence(sequenceId);
await WorkspaceTestBed.UntilAsync(() => section.Dialog is OpenInWorkspaceDialogViewModel, "Open in workspace asks the first time");
((OpenInWorkspaceDialogViewModel)section.Dialog!).OpenCommand.Execute(null);
await WorkspaceTestBed.UntilAsync(() => section.Editor is not null, "Main opens");
var mainId = section.OpenProjectId!.Value;
Assert.True(await section.ConfirmCloseAsync());
await section.CloseAsync();
shell.KeepSequence(null);
var folder = Path.Combine(services.Workspace.Root, mainId.ToString("N"));
var bundle = Path.Combine(folder, WorkspaceProject.BundleFile);
// Saved by a newer Chronos: said at once, nothing offered over it, nothing asked.
await WriteWhenFreeAsync(bundle,
$$"""{ "format": "chronos-project", "formatVersion": 9, "sequence": { "title": "Synthetic" }, "workspace": { "projectId": "{{mainId}}", "name": "Main", "isMain": true } }""");
shell.OpenSequence(sequenceId);
await WorkspaceTestBed.UntilAsync(() => toasts.Any(t => t.Message == Loc.L("Errors.Workspace.NewerCopy")), "a newer Main is refused");
var newer = toasts.Single(t => t.Message == Loc.L("Errors.Workspace.NewerCopy"));
Assert.True(newer is { Title: var title, IsError: true, ActionCommand: null } && title == Loc.L("Editor.Workspace.OpenFailed"));
Assert.True(section.Dialog is null && section.Editor is null, "nothing asked, nothing opened");
Assert.FileExists(bundle);
shell.KeepSequence(null);
// Damaged: said at once, with Remove local copy; its Discard keeps the files aside, named as the copy is known.
await WriteWhenFreeAsync(bundle, "{ not a project");
shell.OpenSequence(sequenceId);
await WorkspaceTestBed.UntilAsync(() => toasts.Any(t => t.Message == Loc.L("Errors.Workspace.Damaged")), "a damaged Main is refused");
var damaged = toasts.Single(t => t.Message == Loc.L("Errors.Workspace.Damaged"));
Assert.Equal((Loc.L("Editor.Workspace.OpenFailed"), true, Loc.L("Editor.Project.RemoveCopy"), Loc.L("Tooltips.Editor.Workspace.State.DamagedCopy")),
(damaged.Title, damaged.IsError, damaged.ActionText, damaged.ActionToolTip));
Assert.True(section.Dialog is null && section.Editor is null, "nothing asked, nothing opened");
damaged.ActionCommand!.Execute(null);
await WorkspaceTestBed.UntilAsync(() => section.Dialog is RemoveCopyDialogViewModel, "its removal is offered");
var remove = (RemoveCopyDialogViewModel)section.Dialog!;
Assert.True(remove.Plan.Damaged, "removed as a damaged copy");
Assert.Equal(Loc.L("Editor.RemoveCopy.Title", Loc.L("Editor.Project.Main")), remove.Heading);
remove.DiscardCommand.Execute(null);
await WorkspaceTestBed.UntilAsync(() => toasts.Any(t => t.Title == Loc.L("Editor.Workspace.Removed")), "the copy goes");
Assert.False(Directory.Exists(folder));
var removed = toasts.Single(t => t.Title == Loc.L("Editor.Workspace.Removed"));
Assert.Equal(Loc.L("Editor.Project.Main"), removed.Message, "named as the index knows it, never by its folder");
}
finally
{
await shell.Sequence.CloseAsync();
shell.Dispose();
await services.DisposeAsync();
}
});
/// <summary>Writes <paramref name="path"/> once the project's last background read (its state, after the close) lets go of it.</summary>
private static async Task WriteWhenFreeAsync(string path, string text)
{
var until = DateTime.UtcNow + TimeSpan.FromSeconds(TestTiming.Budget(20));
while (true)
{
try
{
await File.WriteAllTextAsync(path, text);
return;
}
catch (IOException) when (DateTime.UtcNow < until)
{
await Task.Delay(50);
}
}
}
/// <summary>An archive with one sequence of six synthetic photos, indexed.</summary>
private async Task<Guid> SequenceAsync(AppServices services, string root)
{
@@ -2,6 +2,7 @@ using Chronos.Core.Model;
using Chronos.Core.Project;
using Chronos.Data.Jobs;
using Chronos.Data.Projects;
using Chronos.Data.Repositories;
using Chronos.Data.Tests.Archiving;
using Chronos.Data.Tests.Infrastructure;
using Chronos.Data.Tests.Projects;
@@ -268,10 +269,17 @@ public abstract class WorkspaceSafetyTests(TestContext context) : DatabaseTest(c
var both = await three.ResolveAsync(id, fx.Home, ConflictChoice.SaveBoth, cancellationToken: fx.Ct);
Assert.Equal(WorkspaceState.Gone, both.Status.State);
// Gone holds no conflict to answer: the editor says the project is gone, never asks the conflict again.
Assert.Null(both.Status.Conflict, "a project the home no longer has asks nothing");
var copy = Assert.NotNull(both.SavedAs, "the copy holds this side's work at the home");
Assert.NotNull(project.ReadSync().Conflict, "the conflict stays recorded");
Assert.Null((await three.StatusAsync(id, fx.Home, fx.Ct)).Conflict);
var listed = (await fx.Home.ListAsync(fx.Ct)).Count;
var again = await three.ResolveAsync(id, fx.Home, ConflictChoice.SaveBoth, cancellationToken: fx.Ct);
Assert.Equal(WorkspaceState.Gone, again.Status.State);
Assert.Null(again.Status.Conflict);
Assert.Equal(listed, (await fx.Home.ListAsync(fx.Ct)).Count);
Assert.Contains(await fx.Home.ListAsync(fx.Ct), p => p.Id == copy.Id);
Assert.Equal(WorkspaceState.Gone, (await three.PushAsync(id, fx.Home, fx.Ct)).Status.State);
// Nothing of this side's is lost: its versions wait here, the working state as it was.
@@ -280,6 +288,116 @@ public abstract class WorkspaceSafetyTests(TestContext context) : DatabaseTest(c
Assert.Contains(project.Versions(), v => v.Note == "bright");
}
[Test]
public async Task KeepMineOrTakeTheLibrarysOnAProjectDeletedAtTheHomeIsGoneAndChangesNothing()
{
var fx = await FixtureAsync();
var side = await ProjectAsync(fx, "Side");
var (_, three, project, id) = await SavedConflictAsync(fx, side);
await EditAsync(three, id, s => s with { Stack = new StackSettings { Mode = StackSetting.Mean } }, fx.Ct);
var shown = Assert.NotNull(project.ReadSync().Conflict);
var versions = project.Versions().Select(v => (v.Id, v.ContentHash)).ToList();
await fx.Archive.Service.Projects.DeleteAsync(id, fx.Ct);
// Neither choice is merged onto the last version the home had: Gone, the working state and the unsent version as they were.
foreach (var choice in new[] { ConflictChoice.KeepMine, ConflictChoice.TakeServer })
{
var result = await three.ResolveAsync(id, fx.Home, choice, shown: shown, cancellationToken: fx.Ct);
Assert.Equal(WorkspaceState.Gone, result.Status.State, $"{choice}");
Assert.Null(result.Status.Conflict);
Assert.Null(result.Kept, "nothing was taken over");
Assert.Empty(result.Pulled);
var working = (await three.OpenAsync(id, fx.Ct)).Working;
Assert.Equal((2.0, StackSetting.Mean), (working.Exposure.ExposureOffsetEv, working.Stack.Mode));
Assert.Equal("bright", three.Unpushed(id).Single().Note);
Assert.SequenceEqual(versions, project.Versions().Select(v => (v.Id, v.ContentHash)));
Assert.Empty(Replaced(project));
Assert.Equal(shown.TheirsVersionId, Assert.NotNull(project.ReadSync().Conflict).TheirsVersionId, "the conflict stays recorded");
}
Assert.Equal(WorkspaceState.Gone, (await three.PullAsync(id, fx.Home, fx.Ct)).Status.State);
Assert.Equal("bright", three.Unpushed(id).Single().Note);
}
[Test]
public async Task APushStoppedAtAConflictLeavesTheReplacedVersionsAndOneThatEndsWellPrunesThem()
{
var fx = await FixtureAsync();
var (_, one) = fx.Workspace("one");
var (_, three) = fx.Workspace("three");
var id = (await fx.CheckoutAsync(one)).ProjectId;
var project = await fx.CheckoutAsync(three, id);
await EditAsync(one, id, s => Offset(s, 0.5), fx.Ct);
await one.CommitAsync(id, cancellationToken: fx.Ct);
await one.PushAsync(id, fx.Home, fx.Ct);
await EditAsync(three, id, s => Offset(s, 2), fx.Ct);
await three.CommitAsync(id, "bright", cancellationToken: fx.Ct);
var old = OldReplaced(project, 40);
var stopped = await three.PushAsync(id, fx.Home, fx.Ct);
Assert.Equal(WorkspaceState.Conflict, stopped.Status.State);
Assert.FileExists(old);
await three.ResolveAsync(id, fx.Home, ConflictChoice.KeepMine, shown: stopped.Status.Conflict, cancellationToken: fx.Ct);
Assert.Count(1, (await three.PushAsync(id, fx.Home, fx.Ct)).Pushed);
Assert.False(File.Exists(old), "a push that ended well prunes");
}
/// <summary>A file in <c>versions/.replaced</c> set aside <paramref name="days"/> days ago, by this Chronos (the folder known since then).</summary>
private static string OldReplaced(WorkspaceProject project, int days)
{
var aside = Path.Combine(project.VersionsDirectory, WorkspaceProject.ReplacedFolder);
Directory.CreateDirectory(aside);
var then = DateTime.UtcNow - TimeSpan.FromDays(days);
File.WriteAllText(Path.Combine(project.VersionsDirectory, WorkspaceProject.ReplacedSinceFile), then.ToString("O", System.Globalization.CultureInfo.InvariantCulture));
var old = Path.Combine(aside, $"1-{Guid.CreateVersion7():N}.json");
File.WriteAllText(old, "{}");
File.SetLastWriteTimeUtc(old, then);
return old;
}
[Test]
public async Task AMergeIsMarkedOnTheVersionThatCarriesItNeverOnOneTheWorkingStateAloneConflicted()
{
var fx = await FixtureAsync();
var (_, one) = fx.Workspace("one");
var (_, two) = fx.Workspace("two");
var id = (await fx.CheckoutAsync(one)).ProjectId;
await fx.CheckoutAsync(two, id);
await EditAsync(one, id, s => Offset(s, 0.5), fx.Ct);
await one.CommitAsync(id, cancellationToken: fx.Ct);
await one.PushAsync(id, fx.Home, fx.Ct);
// Saved here: a stack the library never touched; then, not saved, the offset the library changed too.
await EditAsync(two, id, s => s with { Stack = new StackSettings { Mode = StackSetting.Mean } }, fx.Ct);
await two.CommitAsync(id, "stacked", cancellationToken: fx.Ct);
await EditAsync(two, id, s => Offset(s, 1.0), fx.Ct);
var shown = Assert.NotNull((await two.PullAsync(id, fx.Home, fx.Ct)).Status.Conflict);
Assert.Equal("exposure.exposureOffsetEv", shown.Differences.Single().Path);
// Keep mine: the choice lives in the working state; "stacked" replayed merges nothing and stays a commit.
var kept = await two.ResolveAsync(id, fx.Home, ConflictChoice.KeepMine, shown: shown, cancellationToken: fx.Ct);
Assert.Null(kept.Status.Conflict);
var stacked = two.Unpushed(id).Single();
Assert.Equal(("stacked", ProjectVersionKind.Commit), (stacked.Note, stacked.Kind));
Assert.Equal(1.0, await WorkingOffsetAsync(two, id, fx.Ct));
// A version whose own change met the library's: marked as the merge.
var (_, three) = fx.Workspace("three");
await fx.CheckoutAsync(three, id);
await two.PushAsync(id, fx.Home, fx.Ct);
await EditAsync(three, id, s => Offset(s, 2.0), fx.Ct);
await three.CommitAsync(id, "bright", cancellationToken: fx.Ct);
await EditAsync(three, id, s => s with { Stack = new StackSettings { Mode = StackSetting.Median } }, fx.Ct);
await three.CommitAsync(id, "median", cancellationToken: fx.Ct);
await two.CommitAsync(id, "sent", cancellationToken: fx.Ct);
await two.PushAsync(id, fx.Home, fx.Ct);
var asked = Assert.NotNull((await three.PushAsync(id, fx.Home, fx.Ct)).Status.Conflict);
await three.ResolveAsync(id, fx.Home, ConflictChoice.KeepMine, shown: asked, cancellationToken: fx.Ct);
var replayed = three.Unpushed(id);
Assert.SequenceEqual(["bright", "median"], replayed.Select(v => v.Note));
Assert.Equal(ProjectVersionKind.Merge, replayed[^1].Kind, "the last version carrying the choice");
Assert.Equal(ProjectVersionKind.Commit, replayed[0].Kind);
}
[Test]
public async Task ACopyWritesAConvertedPhotoUnderANameOfItsOwnAndSwitchesAtItsCommit()
{
@@ -375,6 +493,70 @@ public abstract class WorkspaceSafetyTests(TestContext context) : DatabaseTest(c
Assert.Equal(fx.Frames.Count, Directory.GetFiles(project.ProxiesDirectory, "*.jpg").Length);
}
[Test]
public async Task AFirstCopyCancelledWhilePausedRemovesTheMediaItWroteUnderTheLease()
{
var fx = await FixtureAsync();
var (store, sync) = fx.Workspace();
var id = (await fx.Archive.Service.Projects.MainAsync(fx.Sequence.Id, fx.Ct)).Id;
var project = await sync.CheckoutAsync(fx.Home, id, cancellationToken: fx.Ct);
Job job;
using (await project.LockAsync(Wait, fx.Ct))
{
job = await fx.StartCopyAsync(store, id);
await UntilAsync(() => Directory.Exists(project.ProxiesDirectory) && Directory.GetFiles(project.ProxiesDirectory, "*.jpg").Length == fx.Frames.Count,
"the copy's files", fx.Ct);
await fx.PauseAsync(job.Id);
await fx.Archive.WaitForAsync(job.Id, JobState.Paused, (int)TestTiming.Budget(30));
}
// Cancelled while paused (no handler runs it) and while another holds the project: removed once that one let go.
var lease = await project.LockAsync(Wait, fx.Ct);
try
{
await fx.CancelAsync(job.Id);
await fx.Archive.WaitForAsync(job.Id, JobState.Cancelled, (int)TestTiming.Budget(30));
await Task.Delay(200, fx.Ct);
Assert.True(Directory.Exists(project.MediaDirectory), "nothing is removed while another holds the project");
}
finally
{
lease.Dispose();
}
await UntilAsync(() => !Directory.Exists(project.MediaDirectory), "the cancelled copy's media removed", fx.Ct);
Assert.Equal(id, project.ReadBundle().Workspace!.ProjectId);
// Copied again, then a copy paused and cancelled: media a copy finished stay.
await fx.CopyAsync(store, id);
var media = project.ReadMedia()!;
using (await project.LockAsync(Wait, fx.Ct))
{
job = await fx.StartCopyAsync(store, id);
await fx.Archive.WaitForAsync(job.Id, JobState.Running, (int)TestTiming.Budget(30));
await fx.PauseAsync(job.Id);
await fx.Archive.WaitForAsync(job.Id, JobState.Paused, (int)TestTiming.Budget(30));
await fx.CancelAsync(job.Id);
}
await Task.Delay(200, fx.Ct);
using (await project.LockAsync(Wait, fx.Ct))
Assert.Equal(media.Frames.Count, project.ReadMedia()!.Frames.Count);
foreach (var frame in media.Frames) Assert.FileExists(project.MediaFile(frame.File!));
}
[Test]
public void TheSpaceACopyNeedsCountsAPhotoHeldUnderEitherName()
{
var a = Guid.CreateVersion7();
var b = Guid.CreateVersion7();
var held = WorkspaceCopyJobHandler.HeldFrames([
Path.Combine("p", $"{a:N}.jpg"),
Path.Combine("p", $"{b:N}-0123456789abcdef.jpg"),
Path.Combine("p", $"{Guid.CreateVersion7():N}x.jpg"),
Path.Combine("p", "notes.jpg"),
]);
Assert.SequenceEqual(new[] { a, b }.Order(), held.Order());
}
[Test]
public async Task AVersionReadAsDamagedWhileAnotherHoldsTheProjectIsReportedOnlyOnceConfirmed()
{
@@ -404,6 +586,9 @@ public abstract class WorkspaceSafetyTests(TestContext context) : DatabaseTest(c
var aside = Path.Combine(project.VersionsDirectory, WorkspaceProject.ReplacedFolder);
Directory.CreateDirectory(aside);
var now = DateTime.UtcNow;
// This Chronos has known the folder for longer than any of its files.
File.WriteAllText(Path.Combine(project.VersionsDirectory, WorkspaceProject.ReplacedSinceFile),
(now - TimeSpan.FromDays(400)).ToString("O", System.Globalization.CultureInfo.InvariantCulture));
var files = new List<(string Path, Guid Id)>();
for (var i = 0; i < 25; i++)
{
@@ -426,6 +611,37 @@ public abstract class WorkspaceSafetyTests(TestContext context) : DatabaseTest(c
Assert.DoesNotContain(files[23].Path, left);
}
[Test]
public void AFileAnEarlierBuildSetAsideIsKeptAMonthFromWhenThisOneFirstKnewTheFolder()
{
var store = new WorkspaceStore(Path.Combine(Context.CreateTempDirectory("prune-old"), "workspace"));
var project = store.Project(Guid.CreateVersion7());
var aside = Path.Combine(project.VersionsDirectory, WorkspaceProject.ReplacedFolder);
Directory.CreateDirectory(aside);
var now = DateTime.UtcNow;
// Set aside by an earlier build, which kept the time its version was written: a year ago.
var old = Path.Combine(aside, $"1-{Guid.CreateVersion7():N}.json");
File.WriteAllText(old, "{}");
File.SetLastWriteTimeUtc(old, now - TimeSpan.FromDays(365));
Assert.Equal(0, project.PruneReplaced(new HashSet<Guid>(), now));
Assert.FileExists(old);
var since = Path.Combine(project.VersionsDirectory, WorkspaceProject.ReplacedSinceFile);
Assert.FileExists(since);
Assert.Equal(0, project.PruneReplaced(new HashSet<Guid>(), now + TimeSpan.FromDays(29)));
Assert.FileExists(old);
Assert.Equal(1, project.PruneReplaced(new HashSet<Guid>(), now + TimeSpan.FromDays(31)));
Assert.False(File.Exists(old), "a month after this Chronos first knew it");
// A marker that cannot be read is written again as now: nothing goes by an age it cannot tell.
var older = Path.Combine(aside, $"2-{Guid.CreateVersion7():N}.json");
File.WriteAllText(older, "{}");
File.SetLastWriteTimeUtc(older, now - TimeSpan.FromDays(365));
File.WriteAllText(since, "not a time");
Assert.Equal(0, project.PruneReplaced(new HashSet<Guid>(), now));
Assert.FileExists(older);
}
[Test]
public async Task ASyncThatEndsWellPrunesTheReplacedVersions()
{
@@ -438,9 +654,7 @@ public abstract class WorkspaceSafetyTests(TestContext context) : DatabaseTest(c
Assert.Count(1, files);
var taken = files[0];
Assert.True(DateTime.UtcNow - File.GetLastWriteTimeUtc(taken) < TimeSpan.FromHours(1), "a file set aside is dated then");
var old = Path.Combine(aside, $"1-{Guid.CreateVersion7():N}.json");
File.WriteAllText(old, "{}");
File.SetLastWriteTimeUtc(old, DateTime.UtcNow - TimeSpan.FromDays(40));
var old = OldReplaced(project, 40);
await two.PushAsync(id, fx.Home, fx.Ct);
Assert.False(File.Exists(old));
@@ -465,6 +679,28 @@ public abstract class WorkspaceSafetyTests(TestContext context) : DatabaseTest(c
Assert.Equal(read + 1, home.FramesReads);
Assert.True((await sync.StatusAsync(id, home, fx.Ct)).MediaOutdated);
Assert.Equal(read + 1, home.FramesReads);
// A hash replaced in place (a Verify that found other bytes) moves the stamp, with no other frames version.
var frame = (await fx.Db.Frames.ListBySequenceAsync(fx.Sequence.Id, cancellationToken: fx.Ct))[2];
var before = await fx.Home.FramesStampAsync(fx.Ct);
var sha = frame.Sha256 ?? new string('0', 64);
var other = (sha[0] == 'f' ? "e" : "f") + sha[1..];
Assert.Equal(1, await fx.Db.Frames.UpdateIntegrityAsync([new FrameIntegrity(frame.Id, frame.Flags, other)], fx.Ct));
Assert.NotEqual(before, await fx.Home.FramesStampAsync(fx.Ct));
await sync.StatusAsync(id, home, fx.Ct);
Assert.Equal(read + 2, home.FramesReads, "the frames read again");
}
[Test]
public async Task TheFramesStampMovesWhenTwoPhotosSwapTheirHashes()
{
var fx = await FixtureAsync(4);
var frames = await fx.Db.Frames.ListBySequenceAsync(fx.Sequence.Id, cancellationToken: fx.Ct);
var (a, b) = (new string('a', 64), new string('b', 64));
await fx.Db.Frames.UpdateIntegrityAsync([new FrameIntegrity(frames[0].Id, frames[0].Flags, a), new FrameIntegrity(frames[1].Id, frames[1].Flags, b)], fx.Ct);
var before = await fx.Home.FramesStampAsync(fx.Ct);
await fx.Db.Frames.UpdateIntegrityAsync([new FrameIntegrity(frames[0].Id, frames[0].Flags, b), new FrameIntegrity(frames[1].Id, frames[1].Flags, a)], fx.Ct);
Assert.NotEqual(before, await fx.Home.FramesStampAsync(fx.Ct));
}
}