diff --git a/src/Chronos.App/Sections/SequenceViewModel.cs b/src/Chronos.App/Sections/SequenceViewModel.cs
index 0fe5e8a7..db28899a 100644
--- a/src/Chronos.App/Sections/SequenceViewModel.cs
+++ b/src/Chronos.App/Sections/SequenceViewModel.cs
@@ -703,6 +703,7 @@ public sealed class SequenceViewModel : SectionViewModel
{
if (!ReferenceEquals(fetch, _fetch) || job.Id != fetch.JobId || job.State is not (JobState.Done or JobState.Failed or JobState.Cancelled)) return;
StopFetch();
+ // A first copy of a project's media the user cancelled removes what it wrote itself, once it has stopped (the job).
switch (job.State)
{
// Opened only when it is still the sequence asked for; otherwise the next visit opens it (from the cache, from the workspace).
@@ -714,23 +715,6 @@ public sealed class SequenceViewModel : SectionViewModel
Shell.Notify(Loc.L(fetch.ProjectId is null ? "Editor.Proxies.Failed" : "Editor.Workspace.CopyFailed"), job.Error ?? fetch.Title, Loc.L("Shell.Nav.Jobs"),
Loc.L("Tooltips.Nav.Jobs"), () => Shell.Navigate(SectionKey.Jobs), isError: true);
break;
- // The user cancelled the first copy of a project's media: the photos it wrote go (a failed one keeps them for its retry).
- case JobState.Cancelled when fetch.ProjectId is { } cancelled:
- _ = RemovePartialMediaAsync(cancelled);
- break;
- }
- }
-
- private async Task RemovePartialMediaAsync(Guid projectId)
- {
- try
- {
- await Shell.Services.Workspace.RemovePartialMediaAsync(projectId);
- }
- catch (Exception ex) when (ex is not OutOfMemoryException)
- {
- // Copies the library can make again: they wait for the next copy, which checks each.
- Log.Warning("workspace", $"The media of a cancelled copy of project {projectId} could not be removed", ex);
}
}
diff --git a/src/Chronos.App/Workspace/ProjectMenuViewModel.cs b/src/Chronos.App/Workspace/ProjectMenuViewModel.cs
index c202c383..d98edfb8 100644
--- a/src/Chronos.App/Workspace/ProjectMenuViewModel.cs
+++ b/src/Chronos.App/Workspace/ProjectMenuViewModel.cs
@@ -126,8 +126,12 @@ public sealed class ProjectMenuViewModel : LocalizedViewModel
/// The button's accessible name: the project and its state.
public string MenuName => string.Join(Loc.Separator, Name, StateText);
- /// The home's frames moved past those the workspace holds: the banner offers Update media.
- public bool HasMediaUpdate => _homeFramesChanged;
+ ///
+ /// The home's frames moved past those the workspace holds, or the library names photos otherwise since the copy (hashed,
+ /// converted) and the media could not learn it yet (the last read of the library says so; a later one that taught them
+ /// clears it): the banner offers Update media.
+ ///
+ public bool HasMediaUpdate => _homeFramesChanged || _status is { MediaOutdated: true };
/// A copy of the media runs (Update media): the banner says so.
public bool IsUpdatingMedia => _copyJob != Guid.Empty;
@@ -170,8 +174,7 @@ public sealed class ProjectMenuViewModel : LocalizedViewModel
var status = await _host.StatusAsync(ProjectId);
var moved = await _source.HomeFramesChangedAsync(CancellationToken.None);
if (_disposed) return;
- // Also photos the library named otherwise since the copy (hashed, converted) while the media could not learn it.
- _homeFramesChanged = moved || status.MediaOutdated;
+ _homeFramesChanged = moved;
Apply(status);
}
catch (Exception ex) when (ex is not OutOfMemoryException)
@@ -236,7 +239,8 @@ public sealed class ProjectMenuViewModel : LocalizedViewModel
if (_disposed) return;
Apply(result.Status);
await TakeAsync(result);
- if (result.Status.Conflict is { } conflict) AskConflict(conflict, background: quiet);
+ if (result.Status.State == WorkspaceState.Gone) _ui.Notify(Loc.L("Editor.Workspace.State.Gone"), Loc.L("Errors.Workspace.DeletedAtHome"));
+ 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);
}
catch (Exception ex) when (ex is not OutOfMemoryException)
@@ -615,7 +619,7 @@ 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 };
+ var status = local with { Behind = behind, Offline = last.Offline, HomeHead = last.HomeHead, MediaOutdated = last.MediaOutdated };
var state = gone ? WorkspaceState.Gone
: status.MediaRemoved ? WorkspaceState.MediaRemoved
: status.Damaged > 0 ? WorkspaceState.Damaged
diff --git a/src/Chronos.App/Workspace/WorkspaceHost.cs b/src/Chronos.App/Workspace/WorkspaceHost.cs
index 6c6b236d..0d1dc977 100644
--- a/src/Chronos.App/Workspace/WorkspaceHost.cs
+++ b/src/Chronos.App/Workspace/WorkspaceHost.cs
@@ -241,23 +241,6 @@ public sealed class WorkspaceHost
}, cancellationToken);
}
- ///
- /// A first copy of a project's media cancelled before it ended: the photos it wrote (copies the home can make again)
- /// are removed, so the workspace holds no half media. A project whose copy ended once keeps its media (Update media
- /// cancelled leaves the earlier ones in use). False when there was nothing to remove.
- ///
- public Task RemovePartialMediaAsync(Guid projectId, CancellationToken cancellationToken = default) => Task.Run(async () =>
- {
- if (Store.Find(projectId) is not { } project) return false;
- using (await project.LockAsync(LockWait, cancellationToken).ConfigureAwait(false))
- {
- if (File.Exists(project.MediaIndexPath) || !Directory.Exists(project.MediaDirectory)) return false;
- Directory.Delete(project.MediaDirectory, recursive: true);
- }
- Log.Info("workspace", $"The media a cancelled first copy of project {projectId} wrote were removed");
- return true;
- }, cancellationToken);
-
/// The project of opened last here, else the one saved last; null when the workspace has none.
public async Task LastUsedAsync(Guid sequenceId, CancellationToken cancellationToken = default)
{
@@ -404,7 +387,8 @@ public sealed class WorkspaceHost
{
var home = HomeOfProject(projectId);
var pulled = await Sync.PullAsync(projectId, home, cancellationToken).ConfigureAwait(false);
- if (pulled.Status.State == WorkspaceState.Conflict) return pulled;
+ // Deleted at the library: nothing to send, nothing to prune; the copy stays as it is.
+ if (pulled.Status.State is WorkspaceState.Conflict or WorkspaceState.Gone) return pulled;
var pushed = await Sync.PushAsync(projectId, home, cancellationToken).ConfigureAwait(false);
await PruneQuietlyAsync(projectId, home, cancellationToken).ConfigureAwait(false);
Log.Info("workspace", $"Project {projectId} synced: {pushed.Pushed.Count} sent, {pulled.Pulled.Count + pushed.Pulled.Count} taken, {pushed.Status.State}");
@@ -682,7 +666,7 @@ public sealed class WorkspaceHost
private async Task SendAsync(Guid projectId, IProjectHome home, CancellationToken cancellationToken)
{
var pulled = await Sync.PullAsync(projectId, home, cancellationToken).ConfigureAwait(false);
- return pulled.Status.State == WorkspaceState.Conflict ? pulled : await Sync.PushAsync(projectId, home, cancellationToken).ConfigureAwait(false);
+ return pulled.Status.State is WorkspaceState.Conflict or WorkspaceState.Gone ? pulled : await Sync.PushAsync(projectId, home, cancellationToken).ConfigureAwait(false);
}
/// The home holds this copy's work: its head and the base this copy was last in step with read back, each matching its hash.
diff --git a/src/Chronos.Data/Projects/IProjectHome.cs b/src/Chronos.Data/Projects/IProjectHome.cs
index d34d1222..14d2732b 100644
--- a/src/Chronos.Data/Projects/IProjectHome.cs
+++ b/src/Chronos.Data/Projects/IProjectHome.cs
@@ -59,6 +59,13 @@ public interface IProjectHome
/// The sequence's frames as the home holds them now.
Task FramesAsync(CancellationToken cancellationToken);
+
+ ///
+ /// A cheap stamp of what answers: another value whenever the frames, how their photos are
+ /// named (a hash learnt) or the encodings conversions joined may have changed, so a workspace reads the frames again only
+ /// then. Null from a home that keeps none: the frames are read every time.
+ ///
+ Task FramesStampAsync(CancellationToken cancellationToken) => Task.FromResult(null);
}
/// A sequence of this PC's archive as its projects' home: the archive's .
@@ -139,6 +146,18 @@ public sealed class ArchiveProjectHome(ChronosDatabase db, ProjectService projec
public Task FramesAsync(CancellationToken cancellationToken) => projects.FramesAsync(sequenceId, cancellationToken);
+ ///
+ /// 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).
+ ///
+ public async Task 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}");
+ }
+
///
/// The project is one of this sequence's. One the index does not know yet (an index taken back from an older backup, a
/// sequence back from the trash, a project another program sharing the archive made) is looked for in the sequence's
diff --git a/src/Chronos.Data/Repositories/FrameRepository.cs b/src/Chronos.Data/Repositories/FrameRepository.cs
index 9be83374..d069bad6 100644
--- a/src/Chronos.Data/Repositories/FrameRepository.cs
+++ b/src/Chronos.Data/Repositories/FrameRepository.cs
@@ -238,6 +238,19 @@ public sealed class FrameRepository
return await session.ExecuteAsync("DELETE FROM frames WHERE sequence_id = $1 AND idx < 0", [sequenceId], cancellationToken).ConfigureAwait(false);
}, cancellationToken);
+ ///
+ /// 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 ().
+ ///
+ public Task<(long Hashed, long Removals)> CountNamedAsync(Guid sequenceId, CancellationToken cancellationToken = default) =>
+ _db.RunAsync(async session =>
+ {
+ var row = await session.QuerySingleAsync(
+ "SELECT (SELECT count(sha256) 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));
+ }, cancellationToken);
+
/// Number of frames of a sequence.
public async Task CountBySequenceAsync(Guid sequenceId, CancellationToken cancellationToken = default) =>
(int)await _db.ScalarAsync("SELECT count(*) FROM frames WHERE sequence_id = $1", [sequenceId], cancellationToken).ConfigureAwait(false);
diff --git a/src/Chronos.Data/Workspaces/WorkspaceCopyJobHandler.cs b/src/Chronos.Data/Workspaces/WorkspaceCopyJobHandler.cs
index c1994c8f..f8d55662 100644
--- a/src/Chronos.Data/Workspaces/WorkspaceCopyJobHandler.cs
+++ b/src/Chronos.Data/Workspaces/WorkspaceCopyJobHandler.cs
@@ -65,7 +65,8 @@ public static class WorkspaceJobs
/// Before each pass and at each checkpoint the workspace's drive must hold what is still to copy plus a reserve, else the
/// job stops saying how much is missing (the workspace shares this PC's drive with the index and the logs).
/// Checkpoint: copy:<frame>:<frames version>:<folder>; 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.
+/// 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 ().
/// Originals come in phase 5c: asked for, the job fails saying so.
///
internal sealed class WorkspaceCopyJobHandler(ChronosDatabase db, ArchiveService archives) : IJobHandler
@@ -106,6 +107,46 @@ internal sealed class WorkspaceCopyJobHandler(ChronosDatabase db, ArchiveService
if (project.ReadBundle().Workspace is not { Home: { IsArchive: true } home } || home.SequenceId != sequenceId)
throw new InvalidOperationException(Loc.L("Errors.Workspace.OtherHome"));
+ try
+ {
+ await CopyAsync(context, project, sequenceId, archive, parameters, ct).ConfigureAwait(false);
+ }
+ catch (OperationCanceledException) when (ct.IsCancellationRequested)
+ {
+ // Stopped writing: what a first copy the user cancelled wrote goes (a pause or a shutdown resumes it).
+ await RemovePartialMediaAsync(context.Job, project).ConfigureAwait(false);
+ throw;
+ }
+ }
+
+ ///
+ /// A first copy of the project's media the user cancelled (the job reads ), once it has
+ /// stopped writing: the photos it wrote (copies the home can make again) are removed under the project's lease, so the
+ /// workspace holds no half media. Media that a copy ever finished (media.json) stay, as do those of a copy paused,
+ /// yielded or stopped with the program, which goes on from its checkpoint. A failure is logged: the next copy checks
+ /// every file it finds.
+ ///
+ private async Task RemovePartialMediaAsync(Job job, WorkspaceProject project)
+ {
+ try
+ {
+ if (await db.Jobs.GetAsync(job.Id, CancellationToken.None).ConfigureAwait(false) is not { State: JobState.Cancelled }) return;
+ using (await project.LockAsync(LockWait, CancellationToken.None).ConfigureAwait(false))
+ {
+ if (File.Exists(project.MediaIndexPath) || !Directory.Exists(project.MediaDirectory)) return;
+ Directory.Delete(project.MediaDirectory, recursive: true);
+ }
+ Log.Info("workspace", $"The media a cancelled first copy of project {project.ProjectId} wrote were removed");
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or DatabaseException)
+ {
+ Log.Warning("workspace", $"The media of a cancelled copy of project {project.ProjectId} could not be removed", ex);
+ }
+ }
+
+ private async Task CopyAsync(JobContext context, WorkspaceProject project, Guid sequenceId, Archive archive, WorkspaceCopyParameters parameters,
+ CancellationToken ct)
+ {
var paths = new ArchivePaths(archive.RootPath);
// Read only: a read-only archive is copied from like any other.
if (ArchiveVolume.Probe(paths) == ArchiveAvailability.Offline) throw new ArchiveOfflineException(archive.RootPath, ArchiveAvailability.Offline);
@@ -221,8 +262,9 @@ internal sealed class WorkspaceCopyJobHandler(ChronosDatabase db, ArchiveService
///
/// The frame's file in the workspace: kept when an earlier run copied it (before the checkpoint, or the same bytes as the
/// archive's proxy), else the archive's current proxy, else one made from the original; none for a frame without either.
- /// The file the media the editor reads now name for the frame () is never removed here: the
- /// editor keeps it while the copy runs and if it fails, and a copy that commits without it removes it then
+ /// The file the media the editor reads now name for the frame () is never removed nor written
+ /// over here: the editor keeps it while the copy runs and if it fails, other bytes for it go under a name of their own
+ /// (), and a copy that commits without it removes it then
/// (). Nor is it taken as this run's copy of a frame whose photo changed since.
///
private WorkspaceFrame Copy(WorkspaceProject project, SequencePaths folder, ArchivePaths paths, Frame frame, ProxyPolicy policy, bool done,
@@ -269,17 +311,41 @@ internal sealed class WorkspaceCopyJobHandler(ChronosDatabase db, ArchiveService
return WorkspaceFrame.Of(frame, null, null, 0);
}
var sha = Sha(bytes);
- if (File.Exists(target) && Sha(AtomicFile.ReadAllBytes(target)) == sha)
+ // The file the editor's media name for the frame holds these bytes already (under its own name, maybe): kept.
+ if (current?.File is { } held && !string.Equals(held, name, StringComparison.OrdinalIgnoreCase)
+ && string.Equals(current.FileSha256, sha, StringComparison.OrdinalIgnoreCase) && Holds(project.MediaFile(held), sha))
+ {
+ tally.Kept++;
+ return WorkspaceFrame.Of(frame, held, sha, bytes.Length);
+ }
+ if (Holds(target, sha))
{
tally.Kept++;
return WorkspaceFrame.Of(frame, name, sha, bytes.Length);
}
+ // Other bytes for the file the editor's media name (a conversion since): written under a name of their own, never over
+ // the editor's file, which the commit switches the media from (RemoveStale then removes it). A copy that fails before
+ // its commit leaves the editor reading the bytes its entry names. A file that no longer holds them (damaged, gone)
+ // is mended where it is.
+ if (listed && current!.FileSha256 is { } editors && Holds(target, editors.ToLowerInvariant()))
+ {
+ name = WorkspaceProject.ProxyName(frame.Id, sha);
+ target = project.MediaFile(name);
+ if (Holds(target, sha))
+ {
+ tally.Kept++;
+ return WorkspaceFrame.Of(frame, name, sha, bytes.Length);
+ }
+ }
WriteVerified(target, bytes, sha);
if (made) tally.Made++;
else tally.Copied++;
return WorkspaceFrame.Of(frame, name, sha, bytes.Length);
}
+ /// Whether the file at is there and hashes as .
+ private static bool Holds(string path, string sha) => File.Exists(path) && Sha(AtomicFile.ReadAllBytes(path)) == sha;
+
/// Writes atomically and reads back: a file that does not hash as its source is written again once, then refused.
private static void WriteVerified(string path, byte[] bytes, string sha)
{
diff --git a/src/Chronos.Data/Workspaces/WorkspaceStore.cs b/src/Chronos.Data/Workspaces/WorkspaceStore.cs
index ccfd163b..6bb7e7ae 100644
--- a/src/Chronos.Data/Workspaces/WorkspaceStore.cs
+++ b/src/Chronos.Data/Workspaces/WorkspaceStore.cs
@@ -36,14 +36,35 @@ public sealed record WorkspaceSyncState(Guid? RestoredFrom, WorkspaceConflict? C
/// take the home's copy. The bundle's base is the commit point: once it is the replay is finished
/// (the replaced set aside, the held ones adopted), before it the replayed ones are set aside and nothing else moved.
///
-public sealed record WorkspaceReplay(Guid OntoBase, IReadOnlyList Replaced, IReadOnlyList Replayed, IReadOnlyList Adopted);
+///
+/// The replay settles the conflict recorded beside it (a pull, a push or a choice that merged): once its base is
+/// that conflict is over, the choice made applied. False for a base moved onto versions the home
+/// held, which leaves the conflict to settle (and for a journal an earlier build wrote).
+///
+public sealed record WorkspaceReplay(Guid OntoBase, IReadOnlyList Replaced, IReadOnlyList Replayed, IReadOnlyList Adopted,
+ bool Settles = false);
///
/// A save-both under way (): the copy made at the home and its first version (the base the
/// local versions are sent on top of), the base this project had when it started, and the id each local version is sent
-/// under, so a retry sends to the same copy what it lacks and the home answers "already stored" for the rest.
+/// under, so a retry sends to the same copy what it lacks and the home answers "already stored" for the rest. Before the
+/// copy is asked of the home its name and the version it is made from are journaled (, the copy's ids
+/// still empty): a retry after a cut finds the copy the home made by them instead of making another.
///
-public sealed record WorkspaceSaveBoth(Guid CopyId, Guid CopyBaseId, int CopyBaseNumber, Guid? FromBase, IReadOnlyList Moves);
+public sealed record WorkspaceSaveBoth(Guid CopyId, Guid CopyBaseId, int CopyBaseNumber, Guid? FromBase, IReadOnlyList Moves,
+ WorkspaceCopyIntent? Intent = null)
+{
+ /// The copy is asked of the home but not known yet: only its is.
+ [JsonIgnore]
+ public bool Intended => CopyId == Guid.Empty;
+}
+
+///
+/// The copy a save-both asks the home for, journaled before it asks: its name, the version it is made from (null: Main's
+/// head) with that version's content hash, and when it was asked. A project of that name made since, whose only version
+/// holds that content, is that copy.
+///
+public sealed record WorkspaceCopyIntent(string Name, Guid? From, string? FromHash, DateTimeOffset Asked);
/// A local version () and the id it is sent under to a save-both's copy.
public sealed record WorkspaceMove(Guid LocalId, Guid CopyVersionId);
@@ -261,7 +282,10 @@ public sealed class WorkspaceProject
public const string ExportsFolder = "exports";
public const string SyncFile = "sync.json";
- /// Old local commits replaced by their replay on top of the home's head: kept, never erased by Chronos.
+ ///
+ /// Old local commits replaced by their replay on top of the home's head, files the home's copy replaced, and the working
+ /// states a take of the server's values replaced: kept up to a month, the newest 20 at most ().
+ ///
public const string ReplacedFolder = ".replaced";
private const string LeaseName = ".lock";
@@ -291,6 +315,16 @@ public sealed class WorkspaceProject
/// The file a frame's proxy is copied to, relative to .
public static string ProxyName(Guid frameId) => ProxiesFolder + "/" + ProxyCache.FileName(frameId);
+ ///
+ /// The file a frame's proxy of other bytes is copied to while the media name for the frame
+ /// (a conversion since): the editor keeps reading that one until the copy commits.
+ ///
+ public static string ProxyName(Guid frameId, string sha256)
+ {
+ ArgumentException.ThrowIfNullOrEmpty(sha256);
+ return ProxiesFolder + "/" + frameId.ToString("N") + "-" + sha256[..Math.Min(16, sha256.Length)].ToLowerInvariant() + ".jpg";
+ }
+
/// The absolute path of a file named relative to .
public string MediaFile(string relative) => LongPath.FromPortableRelative(MediaDirectory, relative);
@@ -358,6 +392,12 @@ public sealed class WorkspaceProject
///
public IReadOnlyList UnreadableVersions() => ReadVersions(log: false).Unreadable;
+ ///
+ /// and from one read of the folder: each file (up to
+ /// ) is parsed once.
+ ///
+ internal (IReadOnlyList Versions, IReadOnlyList Unreadable) ReadVersionFiles() => ReadVersions(log: true);
+
private (List Versions, List Unreadable) ReadVersions(bool log)
{
var versions = new List();
@@ -410,13 +450,15 @@ public sealed class WorkspaceProject
try
{
File.Move(path, target);
- return;
+ break;
}
catch (IOException) when (attempt < SetAsideAttempts && File.Exists(path) && !File.Exists(target))
{
Thread.Sleep(10 * attempt);
}
}
+ // Dated as set aside, which the pruning goes by (a move keeps the time the version was written).
+ TryTouch(target);
}
///
@@ -429,6 +471,62 @@ public sealed class WorkspaceProject
ProjectSidecars.WriteVersion(Path.Combine(VersionsDirectory, ReplacedFolder, Path.GetFileName(VersionPath(version))), version);
}
+ /// Files keeps in versions/.replaced whatever their age.
+ public const int ReplacedKept = 20;
+
+ /// The age past which removes a file of versions/.replaced.
+ public static readonly TimeSpan ReplacedMaxAge = TimeSpan.FromDays(30);
+
+ ///
+ /// Removes from versions/.replaced the files set aside more than ago and those past
+ /// the newest , never one of a version in (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.
+ ///
+ internal int PruneReplaced(IReadOnlySet 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 removed = 0;
+ for (var i = 0; i < files.Count; i++)
+ {
+ var file = files[i];
+ if (i < ReplacedKept && nowUtc - file.LastWriteTimeUtc <= ReplacedMaxAge) continue;
+ if (VersionIdOf(file.Name) is { } id && referenced.Contains(id)) continue;
+ try
+ {
+ file.Delete();
+ removed++;
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+ {
+ Log.Warning("workspace", $"{file.FullName} could not be removed", ex);
+ }
+ }
+ return removed;
+
+ // "-.json", maybe with a suffix a second file of the same version took.
+ static Guid? VersionIdOf(string name)
+ {
+ var end = name.IndexOf(".json", StringComparison.OrdinalIgnoreCase);
+ return end > 0 && ProjectSidecars.TryParseName(name[..(end + 5)], out _, out var id) ? id : null;
+ }
+ }
+
+ private static void TryTouch(string path)
+ {
+ try
+ {
+ if (File.Exists(path)) File.SetLastWriteTimeUtc(path, DateTime.UtcNow);
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+ {
+ Log.Debug("workspace", $"{path} keeps the time it was written: {ex.Message}");
+ }
+ }
+
/// Moves tried, some 1 s in all, before a version file held open fails to move aside.
private const int SetAsideAttempts = 15;
diff --git a/src/Chronos.Data/Workspaces/WorkspaceSync.cs b/src/Chronos.Data/Workspaces/WorkspaceSync.cs
index 228b0803..f5b2d464 100644
--- a/src/Chronos.Data/Workspaces/WorkspaceSync.cs
+++ b/src/Chronos.Data/Workspaces/WorkspaceSync.cs
@@ -35,7 +35,8 @@ public enum WorkspaceState
///
/// The home answered that it no longer has the project or its sequence (the sequence left its index): nothing more can be
- /// sent, and the local copy can only be removed, its work kept aside. Told by the desktop, which asks the home.
+ /// sent, and the local copy can only be removed, its work kept aside. Told by a status asked of the home, and by a sync
+ /// or a choice that met it (nothing here is changed by it).
///
Gone,
@@ -258,7 +259,9 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
///
/// Pushes the local versions in order. When the home moved meanwhile, its versions are pulled and the local ones
- /// replayed on top of them first; a real conflict stops the push ().
+ /// replayed on top of them first; a real conflict stops the push (). A project the
+ /// home no longer has reads as , its versions kept here. A push that ended well prunes
+ /// versions/.replaced ().
///
/// The home cannot be reached; nothing was lost, push again later.
/// The home refused a version for good.
@@ -268,45 +271,55 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
var project = Existing(projectId);
using (await project.LockAsync(LockWait, cancellationToken).ConfigureAwait(false))
{
- await SettleAsync(project, home, cancellationToken).ConfigureAwait(false);
var pushed = new List();
var pulled = new List();
- for (var attempt = 0; attempt < PushAttempts; attempt++)
+ try
{
- var bundle = project.ReadBundle();
- if (project.ReadSync().Conflict is not null) break;
- var diverged = false;
- var locals = Unpushed(project, bundle);
- EnsureChained(project, bundle, locals);
- foreach (var local in locals)
+ await SettleAsync(project, home, cancellationToken).ConfigureAwait(false);
+ for (var attempt = 0; attempt < PushAttempts; attempt++)
{
- var result = await home.PushAsync(projectId, local, cancellationToken).ConfigureAwait(false);
- switch (result.Outcome)
+ var bundle = project.ReadBundle();
+ if (project.ReadSync().Conflict is not null) break;
+ var diverged = false;
+ var locals = Unpushed(project, bundle);
+ EnsureChained(project, bundle, locals);
+ foreach (var local in locals)
{
- case PushOutcome.Stored or PushOutcome.AlreadyStored when result.Version is { } stored:
- Verify(stored);
- // The base moves first: cut after it, the local file still reads as unsent and the next sync
- // adopts it; cut before it, the home answers "already stored" next time. Marked sent first, it
- // would leave the chain from the old base and take the versions after it along.
- bundle = WithBase(bundle, stored);
- project.WriteBundle(bundle);
- Step("push.base");
- Adopt(project, local, stored);
- pushed.Add(stored);
- continue;
- case PushOutcome.Diverged:
- diverged = true;
- break;
- default:
- throw Refused(result.Outcome, local, $"project {projectId}");
+ var result = await home.PushAsync(projectId, local, cancellationToken).ConfigureAwait(false);
+ switch (result.Outcome)
+ {
+ case PushOutcome.Stored or PushOutcome.AlreadyStored when result.Version is { } stored:
+ Verify(stored);
+ // The base moves first: cut after it, the local file still reads as unsent and the next sync
+ // adopts it; cut before it, the home answers "already stored" next time. Marked sent first, it
+ // would leave the chain from the old base and take the versions after it along.
+ bundle = WithBase(bundle, stored);
+ project.WriteBundle(bundle);
+ Step("push.base");
+ Adopt(project, local, stored);
+ pushed.Add(stored);
+ continue;
+ case PushOutcome.Diverged:
+ diverged = true;
+ break;
+ default:
+ throw Refused(result.Outcome, local, $"project {projectId}");
+ }
+ break;
}
- break;
+ if (!diverged) break;
+ var (_, conflict, taken) = await ReplayAsync(project, bundle, home, null, cancellationToken).ConfigureAwait(false);
+ pulled.AddRange(taken);
+ if (conflict is not null) break;
}
- if (!diverged) break;
- var (_, conflict, taken) = await ReplayAsync(project, bundle, home, null, cancellationToken).ConfigureAwait(false);
- pulled.AddRange(taken);
- if (conflict is not null) break;
}
+ catch (ProjectException ex) when (NotFoundAtHome(ex))
+ {
+ // Deleted at the home: no failure to retry but the state the project is in (Gone); nothing here moves.
+ if (!await GoneAsync(project, home, ex, cancellationToken).ConfigureAwait(false)) throw;
+ return new WorkspaceSyncResult(await StatusLockedAsync(project, home, cancellationToken).ConfigureAwait(false), pushed, pulled);
+ }
+ PruneReplaced(project);
return new WorkspaceSyncResult(await StatusLockedAsync(project, home, cancellationToken).ConfigureAwait(false), pushed, pulled);
}
}
@@ -315,7 +328,8 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
/// Takes the home's versions newer than the base: the working state (and any local versions, replayed) moves onto the
/// home's head; a real conflict stops it (). A conflict recorded before is worked
/// out again (the home may have moved on, this side may have been edited since), so what is asked is what differs now;
- /// one that no longer conflicts is settled by the merge.
+ /// one that no longer conflicts is settled by the merge. A project the home no longer has reads as
+ /// , its copy here left as it is.
///
/// The home cannot be reached.
public async Task PullAsync(Guid projectId, IProjectHome home, CancellationToken cancellationToken = default)
@@ -324,20 +338,29 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
var project = Existing(projectId);
using (await project.LockAsync(LockWait, cancellationToken).ConfigureAwait(false))
{
- await SettleAsync(project, home, cancellationToken).ConfigureAwait(false);
IReadOnlyList pulled = [];
- var bundle = project.ReadBundle();
- EnsureChained(project, bundle, Unpushed(project, bundle));
- if (project.ReadSync().Conflict is not null)
+ try
{
- (_, var conflict, pulled) = await ReplayAsync(project, bundle, home, null, cancellationToken).ConfigureAwait(false);
- if (conflict is null) project.WriteSync(project.ReadSync() with { Conflict = null });
+ await SettleAsync(project, home, cancellationToken).ConfigureAwait(false);
+ var bundle = project.ReadBundle();
+ EnsureChained(project, bundle, Unpushed(project, bundle));
+ if (project.ReadSync().Conflict is not null)
+ {
+ (_, var conflict, pulled) = await ReplayAsync(project, bundle, home, null, cancellationToken).ConfigureAwait(false);
+ if (conflict is null) project.WriteSync(project.ReadSync() with { Conflict = null });
+ }
+ else
+ {
+ var head = await home.HeadAsync(projectId, cancellationToken).ConfigureAwait(false);
+ if (head.Id != bundle.Workspace!.Base?.VersionId) (_, _, pulled) = await ReplayAsync(project, bundle, home, null, cancellationToken).ConfigureAwait(false);
+ }
}
- else
+ catch (ProjectException ex) when (NotFoundAtHome(ex))
{
- var head = await home.HeadAsync(projectId, cancellationToken).ConfigureAwait(false);
- if (head.Id != bundle.Workspace!.Base?.VersionId) (_, _, pulled) = await ReplayAsync(project, bundle, home, null, cancellationToken).ConfigureAwait(false);
+ if (!await GoneAsync(project, home, ex, cancellationToken).ConfigureAwait(false)) throw;
+ return new WorkspaceSyncResult(await StatusLockedAsync(project, home, cancellationToken).ConfigureAwait(false), [], pulled);
}
+ if (project.ReadSync().Conflict is null) PruneReplaced(project);
return new WorkspaceSyncResult(await StatusLockedAsync(project, home, cancellationToken).ConfigureAwait(false), [], pulled);
}
}
@@ -346,16 +369,19 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
/// Settles the conflict a pull or push stopped at, as the user was shown it (, else the one
/// recorded). keeps this workspace's values (but for the members in
/// ), takes the server's on the settings listed;
- /// either way the local versions are replayed on the home's head and wait to be pushed. A choice applies only to the
- /// conflicts listed: when what differs now is not that (the home moved on, or this side was edited meanwhile), nothing
- /// is settled, and the conflict found now is recorded and returned to be asked again; so is one the home holds no
- /// versions for now (nothing to take them from). Taking the server's keeps the working state it replaces as a version
- /// file in versions/.replaced, outside the chain: nothing is committed, replayed or sent for it, so a take that
- /// leaves only the server's values sends nothing. After a Save both cut short, either choice first sends the rest of
- /// this workspace's versions to the copy it made (one somebody else pushed to since is left as it is).
+ /// either way the local versions are replayed on the home's head and wait to be pushed (one the choice leaves changing
+ /// nothing is not: its file is kept in versions/.replaced). A choice applies only to the conflicts listed: when
+ /// what differs now is not that (the home moved on, or this side was edited meanwhile), nothing is settled, and the
+ /// conflict found now is recorded and returned to be asked again; so is one the home holds no versions for now (nothing
+ /// to take them from). A choice cut short past its commit point was applied: the conflict is over, and a later choice
+ /// finds nothing to settle. Taking the server's keeps the working state it replaces as a version file in
+ /// versions/.replaced, outside the chain: nothing is committed, replayed or sent for it, so a take that leaves
+ /// only the server's values sends nothing. After a Save both cut short, either choice first sends the rest of this
+ /// workspace's versions to the copy it made (one somebody else pushed to since is left as it is).
/// saves the working state as a version, sends this workspace's versions to a new
/// project at the home (, else this project's name with a number) made from the base,
- /// and moves this project onto the home's head.
+ /// 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 ().
///
/// The home cannot be reached; the conflict stays.
public async Task ResolveAsync(Guid projectId, IProjectHome home, ConflictChoice choice, IReadOnlySet? takeServer = null,
@@ -365,23 +391,31 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
var project = Existing(projectId);
using (await project.LockAsync(LockWait, cancellationToken).ConfigureAwait(false))
{
- await SettleAsync(project, home, cancellationToken).ConfigureAwait(false);
- var bundle = project.ReadBundle();
- var sync = project.ReadSync();
- if (sync.Conflict is not { } recorded) return new WorkspaceSyncResult(await StatusLockedAsync(project, home, cancellationToken).ConfigureAwait(false), [], []);
- EnsureChained(project, bundle, Unpushed(project, bundle));
- if (choice == ConflictChoice.SaveBoth)
- return await SaveBothAsync(project, bundle, home, saveBothName, 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 takeTheirs = choice == ConflictChoice.TakeServer ? AllPaths : takeServer ?? new HashSet();
- ProjectSettings? kept = null;
- var (_, conflict, pulled) = await ReplayAsync(project, bundle, home, takeTheirs, cancellationToken, shown ?? recorded, k => kept = k).ConfigureAwait(false);
- if (conflict is null) project.WriteSync(project.ReadSync() with { Conflict = null });
- return new WorkspaceSyncResult(await StatusLockedAsync(project, home, cancellationToken).ConfigureAwait(false), [], pulled)
+ try
{
- Kept = conflict is null ? kept : null,
- };
+ await SettleAsync(project, home, cancellationToken).ConfigureAwait(false);
+ var bundle = project.ReadBundle();
+ var sync = project.ReadSync();
+ if (sync.Conflict is not { } recorded) return new WorkspaceSyncResult(await StatusLockedAsync(project, home, cancellationToken).ConfigureAwait(false), [], []);
+ EnsureChained(project, bundle, Unpushed(project, bundle));
+ if (choice == ConflictChoice.SaveBoth)
+ return await SaveBothAsync(project, bundle, home, saveBothName, 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 takeTheirs = choice == ConflictChoice.TakeServer ? AllPaths : takeServer ?? new HashSet();
+ ProjectSettings? kept = null;
+ var (_, conflict, pulled) = await ReplayAsync(project, bundle, home, takeTheirs, cancellationToken, shown ?? recorded, k => kept = k).ConfigureAwait(false);
+ if (conflict is null) project.WriteSync(project.ReadSync() with { Conflict = null });
+ return new WorkspaceSyncResult(await StatusLockedAsync(project, home, cancellationToken).ConfigureAwait(false), [], pulled)
+ {
+ Kept = conflict is null ? kept : null,
+ };
+ }
+ catch (ProjectException ex) when (NotFoundAtHome(ex))
+ {
+ if (!await GoneAsync(project, home, ex, cancellationToken).ConfigureAwait(false)) throw;
+ return new WorkspaceSyncResult(await StatusLockedAsync(project, home, cancellationToken).ConfigureAwait(false), [], []);
+ }
}
}
@@ -522,6 +556,13 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
{
var local = locals[i];
var portable = ProjectContent.Canonical(replay.Commits[i].ToJson());
+ // A commit the replay leaves changing nothing (the server's values taken over its own, or the same change made
+ // there) is not replayed into an empty version to send: its file goes to versions/.replaced with the others.
+ if (ProjectContent.SameChoices(parent.SettingsJson, portable, photos))
+ {
+ Log.Info("workspace", $"Version {local.Number} of project {project.ProjectId} changes nothing once replayed on version {head.Number}: it is not sent");
+ continue;
+ }
parent = local with
{
Id = Guid.CreateVersion7(),
@@ -542,7 +583,8 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
if (takeTheirs is EveryPath && differences.Count > 0 && Portable(bundle.Project, media) is { } unsaved
&& (tipVersion is null || !ProjectContent.SameChoices(tipVersion.SettingsJson, unsaved, photos)))
project.WriteAside(VersionOf(project, unsaved, tipVersion, ProjectVersionKind.Commit, null, null, null, media?.FramesVersion ?? bundle.Workspace!.Media.FramesVersion));
- var journal = new WorkspaceReplay(head.Id, [.. locals.Select(v => v.Id)], [.. rebased.Select(v => v.Id)], [.. held.Select(v => v.Id)]);
+ // Past its commit point the replay has settled the conflict recorded beside it, the choice made applied (SettleAsync).
+ var journal = new WorkspaceReplay(head.Id, [.. locals.Select(v => v.Id)], [.. rebased.Select(v => v.Id)], [.. held.Select(v => v.Id)], Settles: true);
project.WriteSync(project.ReadSync() with { Replay = journal });
Step("replay.journal");
foreach (var version in rebased)
@@ -697,11 +739,14 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
var basis = project.ReadBundle().Workspace!.Base;
if (sync.Replay is { } replay)
{
- if (basis?.VersionId == replay.OntoBase) await FinishReplayAsync(project, replay, [], home, cancellationToken).ConfigureAwait(false);
+ var finished = basis?.VersionId == replay.OntoBase;
+ if (finished) await FinishReplayAsync(project, replay, [], home, cancellationToken).ConfigureAwait(false);
else foreach (var id in replay.Replayed) SetAsideUnsent(project, id);
- sync = sync with { Replay = null };
+ // Past its commit point a replay that settles a conflict has applied the choice made: the conflict is over. Cut
+ // before it, nothing moved and the conflict stays to be asked again.
+ sync = sync with { Replay = null, Conflict = finished && replay.Settles ? null : sync.Conflict };
project.WriteSync(sync);
- Log.Info("workspace", $"A sync of project {project.ProjectId} cut short was {(basis?.VersionId == replay.OntoBase ? "finished" : "undone")}");
+ Log.Info("workspace", $"A sync of project {project.ProjectId} cut short was {(finished ? "finished" : "undone")}");
}
if (sync.SaveBoth is { } both && basis?.VersionId != both.FromBase)
{
@@ -744,12 +789,15 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
}
///
- /// Both sides kept: this workspace's versions to a new project at the home, this project onto the home's head. The copy
- /// and the ids its versions are sent under are journaled before the first is sent (): a
- /// retry after a cut sends to the same copy what it lacks (the home answers "already stored" for the rest), whatever name
- /// it is asked for, and the base moving onto the home's head is the commit point. A copy deleted at the home since, or
- /// one somebody else sent versions to (it is theirs now, left as it is), gives way to a new copy that takes them all.
- /// Every local version after the base is sent: one the chain does not reach stops it first ().
+ /// Both sides kept: this workspace's versions to a new project at the home, this project onto the home's head. The
+ /// copy's name and the version it is made from are journaled before the home is asked for it, then the copy and the ids
+ /// its versions are sent under, before the first is sent (): a retry after a cut finds the
+ /// copy the home made by its name () and sends it what it lacks (the home answers
+ /// "already stored" for the rest), whatever name it is asked for, and the base moving onto the home's head is the
+ /// commit point. A copy deleted at the home since, or one somebody else sent versions to (it is theirs now, left as it
+ /// is), gives way to a new copy that takes them all. Every local version after the base is sent: one the chain does not
+ /// reach stops it first (). A project the home deleted meanwhile keeps its versions and its
+ /// working state here as they are, the copy holding them too (); a retry sends nothing new.
///
private async Task SaveBothAsync(WorkspaceProject project, ProjectBundle bundle, IProjectHome home, string? name, CancellationToken cancellationToken)
{
@@ -759,8 +807,11 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
var locals = Unpushed(project, bundle);
EnsureChained(project, bundle, locals);
var pending = project.ReadSync().SaveBoth;
- var copy = locals.Count > 0 && pending is not null ? await OurCopyAsync(project, home, pending, cancellationToken).ConfigureAwait(false) : null;
- if (copy is null) pending = null;
+ SequenceProject? copy = null;
+ if (locals.Count > 0 && pending is not null && await OurCopyAsync(project, home, pending, cancellationToken).ConfigureAwait(false) is { } ours)
+ (copy, pending) = ours;
+ else
+ pending = null;
var pushed = new List();
for (var attempt = 1; locals.Count > 0; attempt++)
{
@@ -768,9 +819,7 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
if (pending is null)
{
var basis = await BaseVersionAsync(project, bundle, home, cancellationToken).ConfigureAwait(false);
- copy = await CreateNamedAsync(home, name, workspace.Name, basis?.Id, cancellationToken).ConfigureAwait(false);
- var first = await home.HeadAsync(copy.Id, cancellationToken).ConfigureAwait(false);
- pending = new WorkspaceSaveBoth(copy.Id, first.Id, first.Number, workspace.Base?.VersionId, []);
+ (copy, pending) = await CreateCopyAsync(project, home, name, workspace, basis, locals, cancellationToken).ConfigureAwait(false);
}
var known = pending.Moves.Select(m => m.LocalId).ToHashSet();
if (!journaled || locals.Any(l => !known.Contains(l.Id)))
@@ -794,7 +843,18 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
}
}
// This project takes the home's head: the local versions now live in the copy (and their files in versions/.replaced).
- var head = await home.HeadAsync(project.ProjectId, cancellationToken).ConfigureAwait(false);
+ ProjectVersion head;
+ try
+ {
+ head = await home.HeadAsync(project.ProjectId, cancellationToken).ConfigureAwait(false);
+ }
+ catch (ProjectException ex) when (NotFoundAtHome(ex))
+ {
+ // Deleted at the home meanwhile: nothing to move onto. The versions are in the copy, and stay here too, unsent,
+ // with the journal, so a retry finds that copy and sends nothing again.
+ ReportGone(project, ex);
+ return new WorkspaceSyncResult(await StatusLockedAsync(project, home, cancellationToken).ConfigureAwait(false), pushed, [], copy);
+ }
Verify(head);
project.WriteVersion(head, replace: true);
var media = project.ReadMedia();
@@ -803,28 +863,107 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
Step("saveboth.base");
foreach (var local in locals) project.SetAside(local);
foreach (var move in pending?.Moves ?? []) SetAsideUnsent(project, move.LocalId);
- project.WriteSync(WorkspaceSyncState.None);
+ // Settled and finished; a restore recorded stays, the next version saved tells whether it still restores.
+ project.WriteSync(project.ReadSync() with { Conflict = null, Replay = null, SaveBoth = null });
return new WorkspaceSyncResult(await StatusLockedAsync(project, home, cancellationToken).ConfigureAwait(false), pushed, [head], copy);
}
///
/// The copy a save-both cut short made () while it is still this workspace's to send to: at the
- /// home, its head the version it was made with or one this workspace sent it. Null when it was deleted since, or somebody
- /// else sent it a version (it is theirs: never sent to, never deleted by this workspace).
+ /// home, its head the version it was made with or one this workspace sent it; with the journal as it now names it. One
+ /// only asked for (: a cut came before its answer) is found by the name it was
+ /// asked under: a project of that name made since, whose only version is the one it was made from (its ids journaled
+ /// then). Null when it was deleted since, never made, or somebody else sent it a version (it is theirs: never sent to,
+ /// never deleted by this workspace).
///
- private static async Task OurCopyAsync(WorkspaceProject project, IProjectHome home, WorkspaceSaveBoth pending, CancellationToken cancellationToken)
+ private static async Task<(SequenceProject Copy, WorkspaceSaveBoth Pending)?> OurCopyAsync(WorkspaceProject project, IProjectHome home,
+ WorkspaceSaveBoth pending, CancellationToken cancellationToken)
{
- if ((await home.ListAsync(cancellationToken).ConfigureAwait(false)).FirstOrDefault(p => p.Id == pending.CopyId) is not { } copy)
+ var listed = await home.ListAsync(cancellationToken).ConfigureAwait(false);
+ if (pending.Intended)
+ {
+ if (pending.Intent is not { } intent
+ || listed.FirstOrDefault(p => string.Equals(p.Name, intent.Name.Trim(), StringComparison.OrdinalIgnoreCase)) is not { } named
+ || named.CreatedAt < intent.Asked - IntentSkew)
+ {
+ Log.Info("workspace", $"The copy a save-both of project {project.ProjectId} asked for was not made at the home");
+ return null;
+ }
+ var first = await home.HeadAsync(named.Id, cancellationToken).ConfigureAwait(false);
+ if (first.Number != 1 || (intent.FromHash is { } hash && !string.Equals(first.ContentHash, hash, StringComparison.OrdinalIgnoreCase)))
+ {
+ Log.Info("workspace", $"Project '{named.Name}' at the home is not the copy a save-both of project {project.ProjectId} asked for: it is left as it is");
+ return null;
+ }
+ var found = pending with { CopyId = named.Id, CopyBaseId = first.Id, CopyBaseNumber = first.Number };
+ project.WriteSync(project.ReadSync() with { SaveBoth = found });
+ Log.Info("workspace", $"Project '{named.Name}' at the home is the copy a save-both of project {project.ProjectId} cut short asked for: it is used");
+ return (named, found);
+ }
+ if (listed.FirstOrDefault(p => p.Id == pending.CopyId) is not { } copy)
{
Log.Info("workspace", $"The copy a save-both of project {project.ProjectId} made is no longer at the home");
return null;
}
var head = await home.HeadAsync(copy.Id, cancellationToken).ConfigureAwait(false);
- if (head.Id == pending.CopyBaseId || pending.Moves.Any(m => m.CopyVersionId == head.Id)) return copy;
+ if (head.Id == pending.CopyBaseId || pending.Moves.Any(m => m.CopyVersionId == head.Id)) return (copy, pending);
Log.Info("workspace", $"Project '{copy.Name}', the copy a save-both of project {project.ProjectId} made, took another's version since: it is left as it is");
return null;
}
+ /// How much earlier than asked a home's clock may date the copy a save-both asked for ().
+ private static readonly TimeSpan IntentSkew = TimeSpan.FromMinutes(5);
+
+ ///
+ /// A new project at the home for a save-both, named , else "'s name
+ /// (2)", "(3)"… whichever is free, made from . Each name is journaled before the home is asked
+ /// (), then the copy with the ids are sent under. A name the
+ /// home finds taken leaves no journal when it was asked for (the caller asks again without one).
+ ///
+ /// The name asked for is taken or invalid.
+ private async Task<(SequenceProject Copy, WorkspaceSaveBoth Pending)> CreateCopyAsync(WorkspaceProject project, IProjectHome home, string? name,
+ BundleWorkspace workspace, ProjectVersion? basis, IReadOnlyList locals, CancellationToken cancellationToken)
+ {
+ var moves = locals.Select(l => new WorkspaceMove(l.Id, Guid.CreateVersion7())).ToList();
+ var named = !string.IsNullOrWhiteSpace(name);
+ HashSet taken = named ? [] : (await home.ListAsync(cancellationToken).ConfigureAwait(false)).Select(p => p.Name).ToHashSet(StringComparer.OrdinalIgnoreCase);
+ for (var n = 2; ; n++)
+ {
+ var candidate = named ? name!.Trim() : Numbered(workspace.Name, n);
+ if (!named && n < 100 && taken.Contains(candidate)) continue;
+ var intended = new WorkspaceSaveBoth(Guid.Empty, Guid.Empty, 0, workspace.Base?.VersionId, moves,
+ new WorkspaceCopyIntent(candidate, basis?.Id, basis?.ContentHash, DateTimeOffset.UtcNow));
+ project.WriteSync(project.ReadSync() with { SaveBoth = intended });
+ Step("saveboth.intent");
+ SequenceProject copy;
+ try
+ {
+ copy = await home.CreateAsync(candidate, basis?.Id, null, cancellationToken).ConfigureAwait(false);
+ }
+ catch (ProjectException ex) when (ex.Reason == ProjectError.NameTaken && !named && n < 100)
+ {
+ continue;
+ }
+ catch (ProjectException ex) when (ex.Reason is ProjectError.NameTaken or ProjectError.InvalidName)
+ {
+ // Not made: no copy of that name is this workspace's.
+ project.WriteSync(project.ReadSync() with { SaveBoth = null });
+ throw;
+ }
+ Step("saveboth.created");
+ var first = await home.HeadAsync(copy.Id, cancellationToken).ConfigureAwait(false);
+ var pending = intended with { CopyId = copy.Id, CopyBaseId = first.Id, CopyBaseNumber = first.Number };
+ project.WriteSync(project.ReadSync() with { SaveBoth = pending });
+ return (copy, pending);
+ }
+
+ static string Numbered(string source, int n)
+ {
+ var candidate = $"{source} ({n})";
+ return candidate.Length > ProjectService.MaxNameLength ? $"{source[..(ProjectService.MaxNameLength - 6)]} ({n})" : candidate;
+ }
+ }
+
///
/// Sends to the save-both's copy under the ids its journal gives them, in order on the version
/// it was made with (the home answers "already stored" for those a cut sent before).
@@ -854,18 +993,20 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
///
/// Keep mine or take the server's after a Save both cut short (its journal still there): the rest of this workspace's
- /// versions the journal lists go to the copy it made, so the home never keeps half of one; a copy deleted or taken over
- /// since is left as it is. The journal itself goes once the project moved (the caller's commit point).
+ /// versions the journal lists go to the copy it made (or asked for, found by its name), so the home never keeps half of
+ /// one; a copy deleted, never made or taken over since is left as it is. The journal itself goes once the project moved
+ /// (the caller's commit point).
///
private async Task FinishCopyAsync(WorkspaceProject project, IProjectHome home, IReadOnlyList chain, CancellationToken cancellationToken)
{
if (project.ReadSync().SaveBoth is not { } pending) return;
var listed = pending.Moves.Select(m => m.LocalId).ToHashSet();
var sent = chain.TakeWhile(v => listed.Contains(v.Id)).ToList();
- if (sent.Count == 0 || await OurCopyAsync(project, home, pending, cancellationToken).ConfigureAwait(false) is not { } copy) return;
+ if (sent.Count == 0 || await OurCopyAsync(project, home, pending, cancellationToken).ConfigureAwait(false) is not { } ours) return;
+ var (copy, known) = ours;
try
{
- await SendToCopyAsync(project, home, copy, pending, sent, cancellationToken).ConfigureAwait(false);
+ await SendToCopyAsync(project, home, copy, known, sent, cancellationToken).ConfigureAwait(false);
}
catch (CopyMovedException)
{
@@ -884,24 +1025,6 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
_ => new WorkspaceSyncException(outcome, $"The home refused version {local.Number} of {target}: {outcome}."),
};
- /// A new project at the home named , else " (2)", "(3)"… whichever is free.
- private static async Task CreateNamedAsync(IProjectHome home, string? name, string source, Guid? from, CancellationToken cancellationToken)
- {
- if (!string.IsNullOrWhiteSpace(name)) return await home.CreateAsync(name, from, null, cancellationToken).ConfigureAwait(false);
- for (var n = 2; ; n++)
- {
- var candidate = $"{source} ({n})";
- if (candidate.Length > ProjectService.MaxNameLength) candidate = $"{source[..(ProjectService.MaxNameLength - 6)]} ({n})";
- try
- {
- return await home.CreateAsync(candidate, from, null, cancellationToken).ConfigureAwait(false);
- }
- catch (ProjectException ex) when (ex.Reason == ProjectError.NameTaken && n < 100)
- {
- }
- }
- }
-
private ProjectVersion? CommitLocked(WorkspaceProject project, ProjectBundle bundle, string? note, string? author)
{
if (bundle.IsReadOnly) throw ReadOnly(project.ProjectId);
@@ -909,13 +1032,14 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
var media = project.ReadMedia();
var portable = Portable(bundle.Project, media) ?? throw MediaMissing(project.ProjectId);
var hash = ProjectContent.Hash(portable);
- var locals = Unpushed(project, bundle);
+ var versions = project.Versions();
+ var locals = Unpushed(versions, bundle);
// Saved after a gap, the new version would hang from the versions before it and the ones after it would be left out.
EnsureChained(project, bundle, locals);
var (tipId, tipNumber, tipHash) = locals.Count > 0
? (locals[^1].Id, locals[^1].Number, locals[^1].ContentHash)
: (workspace.Base?.VersionId, workspace.Base?.Number ?? 0, workspace.Base?.ContentHash);
- if (hash == tipHash || SameAsTip(project, bundle, locals, portable, media)) return null;
+ if (hash == tipHash || SameAsTip(versions, bundle, locals, portable, media)) return null;
var sync = project.ReadSync();
// A restore taken back since (Undo, Ctrl+Z) no longer shows in the working state: that version is no restore.
var restoredFrom = sync.RestoredFrom is { } restored && StillRestores(project, restored, Tip(project, bundle, locals), portable, media?.Photos ?? NoFrames)
@@ -956,40 +1080,41 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
/// Where the project stands. With a , the media first learn how it names its photos now (a photo
/// hashed or converted there since the copy, ), so a version the home made since
/// and the working state name each photo alike: written at once while the project's lease is held
- /// (), else when it can be taken without waiting (
- /// when it cannot).
+ /// (), else when it can be taken now or after a moment (
+ /// when it cannot). The home's frames are read again only when its stamp of them moved ().
+ /// 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 .
///
private async Task StatusLockedAsync(WorkspaceProject project, IProjectHome? home, CancellationToken cancellationToken, bool leased = true)
{
- var bundle = project.ReadBundle();
+ var local = ReadLocal(project);
+ if (local.Damaged > 0 && !leased) local = await ConfirmDamagedAsync(project, local, cancellationToken).ConfigureAwait(false);
+ var (bundle, media, sync, versions, locals, damaged) = local;
var workspace = bundle.Workspace!;
- WorkspaceMedia? media;
- try
- {
- media = project.ReadMedia();
- }
- catch (InvalidDataException)
- {
- media = null;
- }
- var sync = project.ReadSync();
- var conflict = sync.Conflict;
- var locals = Unpushed(project, bundle);
- var damaged = Gaps(project, bundle, locals, sync).Count;
+ // A take of the server's values (or any replay that settles) cut past its commit point applied the choice: the
+ // conflict is over, as the next sync writes.
+ var conflict = sync.Replay is { Settles: true } replay && workspace.Base?.VersionId == replay.OntoBase ? null : sync.Conflict;
ProjectVersion? head = null;
HomeFrames? frames = null;
var offline = false;
+ var gone = false;
if (home is not null)
{
try
{
head = await home.HeadAsync(project.ProjectId, cancellationToken).ConfigureAwait(false);
- if (media is not null) frames = await home.FramesAsync(cancellationToken).ConfigureAwait(false);
+ if (media is not null) frames = await FramesOfAsync(home, workspace.Home, cancellationToken).ConfigureAwait(false);
}
catch (HomeUnavailableException)
{
offline = true;
}
+ catch (ProjectException ex) when (ex.Reason is ProjectError.NotFound or ProjectError.SequenceNotFound)
+ {
+ ReportGone(project, ex);
+ (gone, offline) = (true, true);
+ }
}
var outdated = false;
if (media is not null && frames is not null)
@@ -1001,11 +1126,12 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
}
var tipHash = locals.Count > 0 ? locals[^1].ContentHash : workspace.Base?.ContentHash;
var modified = !bundle.IsReadOnly && (Portable(bundle.Project, media) is not { } portable
- || (ProjectContent.Hash(portable) != tipHash && !SameAsTip(project, bundle, locals, portable, media)));
+ || (ProjectContent.Hash(portable) != tipHash && !SameAsTip(versions, bundle, locals, portable, media)));
var behind = head is not null && head.Id != workspace.Base?.VersionId ? Math.Max(1, head.Number - (workspace.Base?.Number ?? 0)) : 0;
// A local commit the home stored although its answer was lost reads as behind by the commits it holds: they are ours.
if (head is not null && locals.Any(v => v.Id == head.Id)) behind = 0;
- var state = media is null ? WorkspaceState.MediaRemoved
+ var state = gone ? WorkspaceState.Gone
+ : media is null ? WorkspaceState.MediaRemoved
: damaged > 0 ? WorkspaceState.Damaged
: conflict is not null ? WorkspaceState.Conflict
: offline ? WorkspaceState.Offline
@@ -1020,17 +1146,137 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
};
}
+ /// What the workspace holds of a project, read once: its working state, media, sync state and versions.
+ private sealed record LocalState(ProjectBundle Bundle, WorkspaceMedia? Media, WorkspaceSyncState Sync, IReadOnlyList Versions,
+ List Locals, int Damaged);
+
+ private static LocalState ReadLocal(WorkspaceProject project)
+ {
+ var bundle = project.ReadBundle();
+ WorkspaceMedia? media;
+ try
+ {
+ media = project.ReadMedia();
+ }
+ catch (InvalidDataException)
+ {
+ media = null;
+ }
+ var sync = project.ReadSync();
+ var (versions, unreadable) = project.ReadVersionFiles();
+ var locals = Unpushed(versions, bundle);
+ return new LocalState(bundle, media, sync, versions, locals, Gaps(project, bundle, locals, sync, versions, unreadable).Count);
+ }
+
+ ///
+ /// A state read without the lease that found damaged versions, read again under it (taken without waiting): what that
+ /// read finds. While another operation holds the project its writes may be half done, so nothing is reported damaged.
+ ///
+ private static async Task ConfirmDamagedAsync(WorkspaceProject project, LocalState local, CancellationToken cancellationToken)
+ {
+ IDisposable lease;
+ try
+ {
+ lease = await project.LockAsync(TimeSpan.Zero, cancellationToken).ConfigureAwait(false);
+ }
+ catch (LeaseUnavailableException)
+ {
+ Log.Debug("workspace", $"Project {project.ProjectId} reads as damaged while another operation holds it: not reported yet");
+ return local with { Damaged = 0 };
+ }
+ using (lease) return ReadLocal(project);
+ }
+
+ ///
+ /// The home's frames: read again only when the home's stamp of them moved since they were last read for that home
+ /// (), else those read then; always read from a home that keeps no stamp.
+ ///
+ private async Task FramesOfAsync(IProjectHome home, BundleHome key, CancellationToken cancellationToken)
+ {
+ var stamp = await home.FramesStampAsync(cancellationToken).ConfigureAwait(false);
+ if (stamp is not null && _frames.TryGetValue(key, out var known) && known.Stamp == stamp) return known.Frames;
+ var frames = await home.FramesAsync(cancellationToken).ConfigureAwait(false);
+ // Read after the stamp: these frames are at least as new as it, so a stamp moved meanwhile reads them again next time.
+ if (stamp is not null) _frames[key] = (stamp, frames);
+ return frames;
+ }
+
+ /// The homes' frames last read by a status, by home, with the stamp they were read at.
+ private readonly System.Collections.Concurrent.ConcurrentDictionary _frames = new();
+
+ /// The projects whose home answered it no longer has them, each logged once.
+ private readonly System.Collections.Concurrent.ConcurrentDictionary _gone = new();
+
+ private void ReportGone(WorkspaceProject project, ProjectException ex)
+ {
+ if (_gone.TryAdd(project.ProjectId, 0))
+ Log.Info("workspace", $"The home no longer has project {project.ProjectId}: its copy here is kept as it is, with its versions ({ex.Message})");
+ }
+
+ ///
+ /// After (a project or version the home does not know) stopped a sync: whether the home no longer
+ /// has the project itself (deleted there, or its sequence gone), which is no failure to retry but the state the project is
+ /// in. False when the home still has it (the version alone was not found) or cannot be asked now.
+ ///
+ private async Task GoneAsync(WorkspaceProject project, IProjectHome home, ProjectException ex, CancellationToken cancellationToken)
+ {
+ try
+ {
+ await home.HeadAsync(project.ProjectId, cancellationToken).ConfigureAwait(false);
+ return false;
+ }
+ catch (ProjectException gone) when (gone.Reason is ProjectError.NotFound or ProjectError.SequenceNotFound)
+ {
+ ReportGone(project, ex);
+ return true;
+ }
+ catch (HomeUnavailableException)
+ {
+ return false;
+ }
+ }
+
+ ///
+ /// versions/.replaced pruned after a sync that ended well (): never a
+ /// version the sync state still names (a journal, a conflict, a restore). A file that cannot go waits for the next one.
+ ///
+ private static void PruneReplaced(WorkspaceProject project)
+ {
+ var sync = project.ReadSync();
+ var referenced = new HashSet();
+ if (sync.Replay is { } replay) referenced.UnionWith([.. replay.Replaced, .. replay.Replayed, .. replay.Adopted, replay.OntoBase]);
+ if (sync.SaveBoth is { } both) referenced.UnionWith([.. both.Moves.Select(m => m.LocalId), .. both.Moves.Select(m => m.CopyVersionId)]);
+ if (sync.Conflict is { } conflict) referenced.UnionWith([.. conflict.Mine, conflict.TheirsVersionId, conflict.BaseVersionId]);
+ if (sync.RestoredFrom is { } restored) referenced.Add(restored);
+ var removed = project.PruneReplaced(referenced, DateTime.UtcNow);
+ if (removed > 0) Log.Info("workspace", $"{removed} old file(s) of project {project.ProjectId} left versions/.replaced");
+ }
+
+ /// Whether a sync stopped because the home does not know a project or a version ( tells which).
+ private static bool NotFoundAtHome(ProjectException ex) => ex.Reason is ProjectError.NotFound or ProjectError.SequenceNotFound;
+
///
/// Writes the media with the photos named as name them (read again under the lease: a copy
- /// may have written new media meanwhile); without , only when the lease is free now. Whether
- /// the media know the home's names.
+ /// may have written new media meanwhile); without , only when the lease can be taken now or,
+ /// tried once more, after a moment (). Whether the media know the home's names.
///
private async Task LearnNamesAsync(WorkspaceProject project, HomeFrames frames, bool leased, CancellationToken cancellationToken)
{
IDisposable? lease = null;
try
{
- if (!leased) lease = await project.LockAsync(TimeSpan.Zero, cancellationToken).ConfigureAwait(false);
+ if (!leased)
+ {
+ try
+ {
+ lease = await project.LockAsync(TimeSpan.Zero, cancellationToken).ConfigureAwait(false);
+ }
+ catch (LeaseUnavailableException)
+ {
+ // Two reads of the state at once (the picker and the menu), or a copy's commit: held only for a moment.
+ lease = await project.LockAsync(LearnWait, cancellationToken).ConfigureAwait(false);
+ }
+ }
if (project.ReadMedia() is not { } media) return false;
var named = media.NamedAsAt(frames);
if (!ReferenceEquals(named, media)) project.WriteMedia(named);
@@ -1046,20 +1292,30 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
}
}
+ /// How long a status read waits, the second time, for the lease to teach the media the home's names.
+ private static readonly TimeSpan LearnWait = TimeSpan.FromMilliseconds(500);
+
///
/// The version files after the base the chain of versions to send () does not reach: files that
/// cannot be read, and unsent versions that do not follow from the base. Those a replay or a save-both cut short left
- /// (their journals, which the next sync settles) are not counted.
+ /// (their journals, which the next sync settles) are not counted. The files are read once.
///
private static List Gaps(WorkspaceProject project, ProjectBundle bundle, IReadOnlyList chain, WorkspaceSyncState sync)
+ {
+ var (versions, unreadable) = project.ReadVersionFiles();
+ return Gaps(project, bundle, chain, sync, versions, unreadable);
+ }
+
+ private static List Gaps(WorkspaceProject project, ProjectBundle bundle, IReadOnlyList chain, WorkspaceSyncState sync,
+ IReadOnlyList versions, IReadOnlyList unreadable)
{
var basis = bundle.Workspace!.Base;
var after = basis?.Number ?? 0;
var reached = chain.Select(v => v.Id).ToHashSet();
if (sync.Replay is { } replay) reached.UnionWith([.. replay.Replayed, .. replay.Replaced]);
if (sync.SaveBoth is { } both) reached.UnionWith(both.Moves.Select(m => m.LocalId));
- var gaps = project.UnreadableVersions().Where(u => u.Number > after && !reached.Contains(u.Id)).Select(u => u.Path).ToList();
- gaps.AddRange(project.Versions().Where(v => v.StoredAt is null && v.Number > after && v.Id != basis?.VersionId && !reached.Contains(v.Id))
+ var gaps = unreadable.Where(u => u.Number > after && !reached.Contains(u.Id)).Select(u => u.Path).ToList();
+ gaps.AddRange(versions.Where(v => v.StoredAt is null && v.Number > after && v.Id != basis?.VersionId && !reached.Contains(v.Id))
.Select(project.VersionPath));
return gaps;
}
@@ -1082,15 +1338,19 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
/// once each names its photos as the media hold them now: a version saved before the media were copied again after a
/// conversion or a hash at the home parks the same photos under their former names.
///
- private static bool SameAsTip(WorkspaceProject project, ProjectBundle bundle, List locals, string portable, WorkspaceMedia? media)
+ private static bool SameAsTip(IReadOnlyList versions, ProjectBundle bundle, List locals, string portable, WorkspaceMedia? media)
{
if (media is null) return false;
- return Tip(project, bundle, locals) is { } tip && ProjectContent.SameChoices(tip.SettingsJson, portable, media.Photos);
+ return Tip(versions, bundle, locals) is { } tip && ProjectContent.SameChoices(tip.SettingsJson, portable, media.Photos);
}
/// The last version: the newest local one, else the base (null when this workspace keeps neither).
private static ProjectVersion? Tip(WorkspaceProject project, ProjectBundle bundle, List locals) =>
- locals.Count > 0 ? locals[^1] : bundle.Workspace!.Base is { } basis ? project.Versions().FirstOrDefault(v => v.Id == basis.VersionId) : null;
+ locals.Count > 0 ? locals[^1] : Tip(project.Versions(), bundle, locals);
+
+ /// The last version among (the workspace's, read once).
+ private static ProjectVersion? Tip(IReadOnlyList versions, ProjectBundle bundle, List locals) =>
+ locals.Count > 0 ? locals[^1] : bundle.Workspace!.Base is { } basis ? versions.FirstOrDefault(v => v.Id == basis.VersionId) : null;
///
/// Whether the working state , saved as a version on , still restores
@@ -1125,10 +1385,13 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
shown.Count == found.Count && shown.ToHashSet().SetEquals(found);
/// The local versions after the base, oldest first, each the child of the one before (the base's for the first).
- private static List Unpushed(WorkspaceProject project, ProjectBundle bundle)
+ private static List Unpushed(WorkspaceProject project, ProjectBundle bundle) => Unpushed(project.Versions(), bundle);
+
+ /// The local versions after the base among (the workspace's, read once).
+ private static List Unpushed(IReadOnlyList versions, ProjectBundle bundle)
{
var basis = bundle.Workspace!.Base;
- var candidates = project.Versions().Where(v => v.StoredAt is null && v.Number > (basis?.Number ?? 0)).ToList();
+ var candidates = versions.Where(v => v.StoredAt is null && v.Number > (basis?.Number ?? 0)).ToList();
var chain = new List();
var parent = basis?.VersionId;
while (candidates.FirstOrDefault(v => v.ParentId == parent) is { } next)
diff --git a/tests/Chronos.App.Tests/Workspace/WorkspaceFallbackTests.cs b/tests/Chronos.App.Tests/Workspace/WorkspaceFallbackTests.cs
index 93f6e9c2..33d6ceb0 100644
--- a/tests/Chronos.App.Tests/Workspace/WorkspaceFallbackTests.cs
+++ b/tests/Chronos.App.Tests/Workspace/WorkspaceFallbackTests.cs
@@ -189,26 +189,6 @@ public sealed class WorkspaceFallbackTests(TestContext context)
|| f.Contains(unsent.Id.ToString("N"), StringComparison.OrdinalIgnoreCase)), "the version never sent is kept");
}
- [Test]
- public async Task ACancelledFirstCopyLeavesNoHalfMedia()
- {
- await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 4);
- var host = bed.Host();
- var mainId = await bed.CheckoutAsync(host);
- var project = host.Store.Find(mainId)!;
- Assert.False(await host.RemovePartialMediaAsync(mainId), "a copy that ended keeps its media");
- Assert.FileExists(project.MediaIndexPath);
-
- // A first copy stopped before its index was written: what it wrote goes, the working state stays.
- File.Delete(project.MediaIndexPath);
- Assert.NotEmpty(Directory.EnumerateFiles(project.MediaDirectory, "*", SearchOption.AllDirectories));
- Assert.True(await host.RemovePartialMediaAsync(mainId));
- Assert.False(Directory.Exists(project.MediaDirectory));
- Assert.FileExists(project.BundlePath);
- Assert.False(await host.RemovePartialMediaAsync(mainId), "nothing left to remove");
- Assert.False(await host.RemovePartialMediaAsync(Guid.NewGuid()));
- }
-
[Test]
public async Task OpenInWorkspaceShowsTheCopysSizeAndTheFreeSpace()
{
diff --git a/tests/Chronos.Data.Tests/Workspaces/WorkspaceConflictTests.cs b/tests/Chronos.Data.Tests/Workspaces/WorkspaceConflictTests.cs
index 51b18b07..8c32019b 100644
--- a/tests/Chronos.Data.Tests/Workspaces/WorkspaceConflictTests.cs
+++ b/tests/Chronos.Data.Tests/Workspaces/WorkspaceConflictTests.cs
@@ -126,7 +126,10 @@ public abstract class WorkspaceConflictTests(TestContext context) : DatabaseTest
Assert.Null(settled.Status.Conflict, "one answer settles what was shown");
Assert.Equal(0.5, (await two.OpenAsync(id, fx.Ct)).Working.Exposure.ExposureOffsetEv);
Assert.Equal(1.0, Assert.NotNull(settled.Kept).Exposure.ExposureOffsetEv);
- Assert.Equal("warmer", two.Unpushed(id).Single().Note, "the saved version is replayed, nothing more");
+ // The saved version changes nothing once the library's offset is taken: it is not sent, its file kept aside.
+ Assert.Empty(two.Unpushed(id));
+ var replaced = Path.Combine(two.Store.Find(id)!.VersionsDirectory, WorkspaceProject.ReplacedFolder);
+ Assert.Contains(Directory.GetFiles(replaced).Select(ProjectSidecars.ReadVersion), v => v.Note == "warmer");
}
[Test]
diff --git a/tests/Chronos.Data.Tests/Workspaces/WorkspaceFixture.cs b/tests/Chronos.Data.Tests/Workspaces/WorkspaceFixture.cs
index 9c8cde30..6f8fab68 100644
--- a/tests/Chronos.Data.Tests/Workspaces/WorkspaceFixture.cs
+++ b/tests/Chronos.Data.Tests/Workspaces/WorkspaceFixture.cs
@@ -83,6 +83,19 @@ internal sealed class WorkspaceFixture : IAsyncDisposable
return await Archive.WaitForAsync(job.Id, expected, (int)TestTiming.Budget(60));
}
+ /// Queues a workspace copy job and returns at once, while it runs.
+ public async Task StartCopyAsync(WorkspaceStore store, Guid projectId)
+ {
+ var engine = await EngineAsync();
+ return await engine.EnqueueAsync(WorkspaceJobs.Copy(Sequence, store.Root, projectId), cancellationToken: Ct);
+ }
+
+ /// Cancels a job, as the user does from the jobs list.
+ public async Task CancelAsync(Guid jobId) => await (await EngineAsync()).CancelAsync(jobId, Ct);
+
+ /// Pauses a job, as the user does from the jobs list.
+ public async Task PauseAsync(Guid jobId) => await (await EngineAsync()).PauseAsync(jobId, Ct);
+
private async Task EngineAsync()
{
if (_engine is not null) return _engine;
@@ -151,6 +164,39 @@ internal sealed class CuttingHome(IProjectHome home) : IProjectHome
public Task FramesAsync(CancellationToken cancellationToken) => home.FramesAsync(cancellationToken);
}
+/// A home that counts its reads of the frames, its stamp of them passed through.
+internal sealed class CountingHome(IProjectHome home) : IProjectHome
+{
+ public int FramesReads { get; private set; }
+
+ public Task FramesAsync(CancellationToken cancellationToken)
+ {
+ FramesReads++;
+ return home.FramesAsync(cancellationToken);
+ }
+
+ public Task FramesStampAsync(CancellationToken cancellationToken) => home.FramesStampAsync(cancellationToken);
+
+ public Task SequenceAsync(CancellationToken cancellationToken) => home.SequenceAsync(cancellationToken);
+ public Task> ListAsync(CancellationToken cancellationToken) => home.ListAsync(cancellationToken);
+
+ public Task CreateAsync(string name, Guid? fromVersionId, string? author, CancellationToken cancellationToken) =>
+ home.CreateAsync(name, fromVersionId, author, cancellationToken);
+
+ public Task HeadAsync(Guid projectId, CancellationToken cancellationToken) => home.HeadAsync(projectId, cancellationToken);
+
+ public Task GetVersionAsync(Guid projectId, Guid versionId, CancellationToken cancellationToken) =>
+ home.GetVersionAsync(projectId, versionId, cancellationToken);
+
+ public Task> VersionsAfterAsync(Guid projectId, int afterNumber, int limit, CancellationToken cancellationToken) =>
+ home.VersionsAfterAsync(projectId, afterNumber, limit, cancellationToken);
+
+ public Task> HistoryAsync(Guid projectId, int? beforeNumber, int limit, CancellationToken cancellationToken) =>
+ home.HistoryAsync(projectId, beforeNumber, limit, cancellationToken);
+
+ public Task PushAsync(Guid projectId, ProjectVersion version, CancellationToken cancellationToken) => home.PushAsync(projectId, version, cancellationToken);
+}
+
/// A home that cannot be reached, standing for a server out of reach or an archive offline.
internal sealed class UnreachableHome(IProjectHome home) : IProjectHome
{
diff --git a/tests/Chronos.Data.Tests/Workspaces/WorkspaceMergeTests.cs b/tests/Chronos.Data.Tests/Workspaces/WorkspaceMergeTests.cs
index ed8518d3..64b63a33 100644
--- a/tests/Chronos.Data.Tests/Workspaces/WorkspaceMergeTests.cs
+++ b/tests/Chronos.Data.Tests/Workspaces/WorkspaceMergeTests.cs
@@ -188,6 +188,30 @@ public abstract class WorkspaceMergeTests(TestContext context) : DatabaseTest(co
Assert.SequenceEqual([2], (await sync.OpenAsync(id, fx.Ct)).Working.ExcludedFrames);
}
+ [Test]
+ public async Task AProjectHeldForAMomentStillLetsTheMediaLearnTheHomesNames()
+ {
+ var fx = await FixtureAsync();
+ await UnhashAsync(fx, 2);
+ var (_, sync) = fx.Workspace();
+ var project = await fx.CheckoutAsync(sync);
+ var id = project.ProjectId;
+ await VerifyAsync(fx);
+ var hashed = (await fx.Db.Frames.ListBySequenceAsync(fx.Sequence.Id))[2].Sha256!;
+
+ // Another read of the state holds the project for a moment as this one asks: it waits for it, once.
+ var lease = await project.LockAsync(TimeSpan.FromSeconds(TestTiming.Budget(10)), fx.Ct);
+ var release = Task.Run(async () =>
+ {
+ await Task.Delay(150, fx.Ct);
+ lease.Dispose();
+ }, fx.Ct);
+ var status = await sync.StatusAsync(id, fx.Home, fx.Ct);
+ await release;
+ Assert.False(status.MediaOutdated);
+ Assert.Equal(hashed, project.ReadMedia()!.Frames[2].Sha256);
+ }
+
[Test]
public async Task APhotoConvertedAtTheHomeIsOutdatedMediaAndTheMediaLearnItsEncodings()
{
diff --git a/tests/Chronos.Data.Tests/Workspaces/WorkspaceRecoveryTests.cs b/tests/Chronos.Data.Tests/Workspaces/WorkspaceRecoveryTests.cs
index 0cb89b11..79c746bb 100644
--- a/tests/Chronos.Data.Tests/Workspaces/WorkspaceRecoveryTests.cs
+++ b/tests/Chronos.Data.Tests/Workspaces/WorkspaceRecoveryTests.cs
@@ -534,7 +534,10 @@ public abstract class WorkspaceRecoveryTests(TestContext context) : DatabaseTest
// One read in another folder (the sequence moved since, another may hold its old one) checks every file again.
job = await fx.CopyAsync(store, main.Id, checkpoint: $"copy:{copied.Frames.Count}:{fx.Sequence.FramesVersion}:elsewhere/folder");
Assert.Contains(Loc.L("Archive.Log.WorkspaceCopied", fx.Sequence.DisplayTitle, 1, 0, 4, 0), job.LogTail!);
- Assert.Equal(copied.Frames[0].FileSha256, Convert.ToHexStringLower(SHA256.HashData(File.ReadAllBytes(damaged))));
+ // Under a name of its own: the media named the file kept before, which the editor reads until the commit.
+ var mended = project.MediaFile(project.ReadMedia()!.Frames[0].File!);
+ Assert.Equal(copied.Frames[0].FileSha256, Convert.ToHexStringLower(SHA256.HashData(File.ReadAllBytes(mended))));
+ Assert.False(File.Exists(damaged));
}
[Test]
diff --git a/tests/Chronos.Data.Tests/Workspaces/WorkspaceSafetyTests.cs b/tests/Chronos.Data.Tests/Workspaces/WorkspaceSafetyTests.cs
new file mode 100644
index 00000000..4a7d3d0a
--- /dev/null
+++ b/tests/Chronos.Data.Tests/Workspaces/WorkspaceSafetyTests.cs
@@ -0,0 +1,480 @@
+using Chronos.Core.Model;
+using Chronos.Core.Project;
+using Chronos.Data.Jobs;
+using Chronos.Data.Projects;
+using Chronos.Data.Tests.Archiving;
+using Chronos.Data.Tests.Infrastructure;
+using Chronos.Data.Tests.Projects;
+using Chronos.Data.Workspaces;
+using Chronos.Testing;
+
+namespace Chronos.Data.Tests.Workspaces;
+
+///
+/// What the workspace's sync and copy never lose or leave behind (owner review 2, R8, fix round 3): a choice cut short is
+/// applied or asked again, a version a take leaves changing nothing is not sent, a save-both cut short makes one copy, a
+/// project deleted at the home stops the sync once, the copy never writes over the editor's photo nor leaves half media.
+///
+[Category("workspace")]
+public abstract class WorkspaceSafetyTests(TestContext context) : DatabaseTest(context)
+{
+ private async Task FixtureAsync(int frames = 5)
+ {
+ var archive = Own(await ArchiveFixture.CreateAsync(Context, database: await NewOptionsAsync(multiConnection: true)));
+ return Own(await WorkspaceFixture.CreateAsync(Context, archive, frames));
+ }
+
+ private static async Task EditAsync(WorkspaceSync sync, Guid projectId, Func edit, CancellationToken ct)
+ {
+ var session = await sync.OpenAsync(projectId, ct);
+ await sync.SaveAsync(projectId, edit(session.Working), ct);
+ }
+
+ private static ProjectSettings Offset(ProjectSettings s, double ev) => s with { Exposure = s.Exposure with { ExposureOffsetEv = ev } };
+
+ private static ProjectSettings Settings(ProjectVersion version) => ProjectSettings.FromJson(version.SettingsJson);
+
+ private static async Task WorkingOffsetAsync(WorkspaceSync sync, Guid projectId, CancellationToken ct) =>
+ (await sync.OpenAsync(projectId, ct)).Working.Exposure.ExposureOffsetEv;
+
+ private static List Replaced(WorkspaceProject project)
+ {
+ var aside = Path.Combine(project.VersionsDirectory, WorkspaceProject.ReplacedFolder);
+ return Directory.Exists(aside) ? [.. Directory.GetFiles(aside).Select(ProjectSidecars.ReadVersion)] : [];
+ }
+
+ private static TimeSpan Wait => TimeSpan.FromSeconds(TestTiming.Budget(10));
+
+ /// Polls until it holds, failing after the budget.
+ private static async Task UntilAsync(Func done, string what, CancellationToken ct)
+ {
+ var until = DateTime.UtcNow + TimeSpan.FromSeconds(TestTiming.Budget(30));
+ while (!done())
+ {
+ if (DateTime.UtcNow > until) Assert.Fail($"Timed out waiting: {what}");
+ await Task.Delay(20, ct);
+ }
+ }
+
+ ///
+ /// A project of its own checked out into two workspaces: the first sent an offset of 0.5, the second changed it to 1
+ /// without saving and was asked. The second's store, sync and project, and the conflict shown.
+ ///
+ private static async Task<(WorkspaceStore Store, WorkspaceSync Two, WorkspaceProject Project, WorkspaceConflict Shown)> AskedAsync(WorkspaceFixture fx, Guid id)
+ {
+ var (_, one) = fx.Workspace("one");
+ var (store, two) = fx.Workspace("two");
+ await fx.CheckoutAsync(one, id);
+ var project = 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);
+ 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);
+ return (store, two, project, shown);
+ }
+
+ private static async Task ProjectAsync(WorkspaceFixture fx, string name) =>
+ (await fx.Archive.Service.Projects.CreateAsync(fx.Sequence.Id, name, cancellationToken: fx.Ct)).Id;
+
+ [Test]
+ public async Task ATakeCutPastItsCommitPointIsAppliedAndALaterChoiceFindsNothingToSettle()
+ {
+ var fx = await FixtureAsync();
+ var id = await ProjectAsync(fx, "Cut late");
+ var (store, two, project, shown) = await AskedAsync(fx, id);
+ await Assert.ThrowsAsync(() =>
+ WorkspaceFixture.Cutting(store, "replay.base").ResolveAsync(id, fx.Home, ConflictChoice.TakeServer, shown: shown, cancellationToken: fx.Ct));
+
+ // The working state is on the library's head with its value: the choice was made, nothing asks it again.
+ var status = await two.StatusAsync(id, fx.Home, fx.Ct);
+ Assert.Null(status.Conflict, "a take past its commit point was applied");
+ Assert.Equal(WorkspaceState.InSync, status.State);
+ Assert.Equal(0.5, await WorkingOffsetAsync(two, id, fx.Ct));
+ Assert.Contains(Replaced(project), v => Settings(v).Exposure.ExposureOffsetEv == 1.0);
+
+ // The dialog still open answers Keep mine: there is nothing left to settle, and nothing is cleared without applying it.
+ var later = await two.ResolveAsync(id, fx.Home, ConflictChoice.KeepMine, shown: shown, cancellationToken: fx.Ct);
+ Assert.Null(later.Status.Conflict);
+ Assert.Equal(0.5, await WorkingOffsetAsync(two, id, fx.Ct));
+ Assert.Equal(WorkspaceSyncState.None, project.ReadSync());
+ }
+
+ [Test]
+ public async Task ATakeCutBeforeItsCommitPointKeepsTheConflictAndALaterChoiceIsApplied()
+ {
+ var fx = await FixtureAsync();
+ var id = await ProjectAsync(fx, "Cut early");
+ var (store, two, project, shown) = await AskedAsync(fx, id);
+ await Assert.ThrowsAsync(() =>
+ WorkspaceFixture.Cutting(store, "replay.journal").ResolveAsync(id, fx.Home, ConflictChoice.TakeServer, shown: shown, cancellationToken: fx.Ct));
+
+ var status = await two.StatusAsync(id, fx.Home, fx.Ct);
+ Assert.Equal(WorkspaceState.Conflict, status.State);
+ Assert.Equal(1.0, await WorkingOffsetAsync(two, id, fx.Ct));
+
+ // Keep mine, asked again: applied, and sent.
+ var kept = await two.ResolveAsync(id, fx.Home, ConflictChoice.KeepMine, shown: Assert.NotNull(status.Conflict), cancellationToken: fx.Ct);
+ Assert.Null(kept.Status.Conflict);
+ Assert.Equal(1.0, await WorkingOffsetAsync(two, id, fx.Ct));
+ Assert.Null(project.ReadSync().Conflict);
+ await two.CommitAsync(id, cancellationToken: fx.Ct);
+ await two.PushAsync(id, fx.Home, fx.Ct);
+ Assert.Equal(1.0, Settings(await fx.Home.HeadAsync(id, fx.Ct)).Exposure.ExposureOffsetEv);
+ }
+
+ [Test]
+ public async Task AVersionTheTakeLeavesChangingNothingIsNotSentAndStaysAside()
+ {
+ var fx = await FixtureAsync();
+ var (_, one) = fx.Workspace("one");
+ var (_, two) = fx.Workspace("two");
+ var id = (await fx.CheckoutAsync(one)).ProjectId;
+ var project = 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: an offset and a stack, then the offset alone again.
+ await EditAsync(two, id, s => Offset(s, 0.8) with { Stack = new StackSettings { Mode = StackSetting.Mean } }, fx.Ct);
+ await two.CommitAsync(id, "stacked", cancellationToken: fx.Ct);
+ await EditAsync(two, id, s => Offset(s, 0.9), fx.Ct);
+ await two.CommitAsync(id, "again", cancellationToken: fx.Ct);
+ var shown = Assert.NotNull((await two.PullAsync(id, fx.Home, fx.Ct)).Status.Conflict);
+
+ // The library's offset taken: "again" changes nothing on "stacked" replayed, so only that one waits to be sent.
+ var settled = await two.ResolveAsync(id, fx.Home, ConflictChoice.TakeServer, shown: shown, cancellationToken: fx.Ct);
+ Assert.Null(settled.Status.Conflict);
+ Assert.Equal("stacked", two.Unpushed(id).Single().Note);
+ Assert.Contains(Replaced(project), v => v.Note == "again");
+ var history = (await fx.Home.HistoryAsync(id, null, 10, fx.Ct)).Count;
+ Assert.Count(1, (await two.PushAsync(id, fx.Home, fx.Ct)).Pushed);
+ Assert.Equal(history + 1, (await fx.Home.HistoryAsync(id, null, 10, fx.Ct)).Count);
+ var head = Settings(await fx.Home.HeadAsync(id, fx.Ct));
+ Assert.Equal((0.5, StackSetting.Mean), (head.Exposure.ExposureOffsetEv, head.Stack.Mode));
+
+ // A take whose every version changes nothing sends none, merge or not.
+ var (_, three) = fx.Workspace("three");
+ await fx.CheckoutAsync(three, id);
+ await EditAsync(one, id, s => Offset(s, 0.6), fx.Ct);
+ await one.PullAsync(id, fx.Home, 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.0), fx.Ct);
+ await three.CommitAsync(id, "bright", cancellationToken: fx.Ct);
+ var asked = Assert.NotNull((await three.PullAsync(id, fx.Home, fx.Ct)).Status.Conflict);
+ var taken = await three.ResolveAsync(id, fx.Home, ConflictChoice.TakeServer, shown: asked, cancellationToken: fx.Ct);
+ Assert.Equal(WorkspaceState.InSync, taken.Status.State);
+ Assert.Empty(three.Unpushed(id));
+ Assert.Contains(Replaced(three.Store.Project(id)), v => v.Note == "bright");
+ }
+
+ /// A conflict where this side saved "bright" (offset 2) and has nothing unsaved: the working state is that version.
+ private static async Task<(WorkspaceStore Store, WorkspaceSync Three, WorkspaceProject Project, Guid Id)> SavedConflictAsync(WorkspaceFixture fx, Guid? projectId = null)
+ {
+ var (_, one) = fx.Workspace("one");
+ var (store, three) = fx.Workspace("three");
+ var id = (await fx.CheckoutAsync(one, projectId)).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);
+ Assert.Equal(WorkspaceState.Conflict, (await three.PushAsync(id, fx.Home, fx.Ct)).Status.State);
+ return (store, three, project, id);
+ }
+
+ [Test]
+ public async Task ASaveBothCutOnceTheHomeMadeTheCopyUsesThatCopyOnRetry()
+ {
+ var fx = await FixtureAsync();
+ var (store, three, project, id) = await SavedConflictAsync(fx);
+ await Assert.ThrowsAsync(() =>
+ WorkspaceFixture.Cutting(store, "saveboth.created").ResolveAsync(id, fx.Home, ConflictChoice.SaveBoth, saveBothName: "Main (PC)", cancellationToken: fx.Ct));
+ var made = (await fx.Home.ListAsync(fx.Ct)).Single(p => p.Name == "Main (PC)");
+ Assert.True(Assert.NotNull(project.ReadSync().SaveBoth).Intended, "the copy was asked for under a journal");
+
+ // The retry, asked another name, finds the copy it asked for and makes no other.
+ var both = await three.ResolveAsync(id, fx.Home, ConflictChoice.SaveBoth, saveBothName: "Main (other)", cancellationToken: fx.Ct);
+ Assert.Equal(made.Id, Assert.NotNull(both.SavedAs).Id);
+ Assert.Equal(2, (await fx.Home.ListAsync(fx.Ct)).Count);
+ Assert.Equal(2.0, Settings(await fx.Home.HeadAsync(made.Id, fx.Ct)).Exposure.ExposureOffsetEv);
+ Assert.Equal(2, (await fx.Home.HistoryAsync(made.Id, null, 10, fx.Ct)).Count);
+ Assert.Equal(WorkspaceState.InSync, both.Status.State);
+ Assert.Equal(WorkspaceSyncState.None, project.ReadSync());
+ }
+
+ [Test]
+ public async Task ASaveBothCutBeforeTheHomeWasAskedMakesOneCopyOnRetry()
+ {
+ var fx = await FixtureAsync();
+ var (store, three, project, id) = await SavedConflictAsync(fx);
+ await Assert.ThrowsAsync(() =>
+ WorkspaceFixture.Cutting(store, "saveboth.intent").ResolveAsync(id, fx.Home, ConflictChoice.SaveBoth, saveBothName: "Main (PC)", cancellationToken: fx.Ct));
+ Assert.Count(1, await fx.Home.ListAsync(fx.Ct));
+
+ var both = await three.ResolveAsync(id, fx.Home, ConflictChoice.SaveBoth, saveBothName: "Main (PC)", cancellationToken: fx.Ct);
+ Assert.Equal("Main (PC)", Assert.NotNull(both.SavedAs).Name);
+ Assert.Equal(2, (await fx.Home.ListAsync(fx.Ct)).Count);
+ Assert.Equal(WorkspaceSyncState.None, project.ReadSync());
+ }
+
+ [Test]
+ public async Task ASaveBothKeepsTheRestoreRecorded()
+ {
+ var fx = await FixtureAsync();
+ var (_, three, project, id) = await SavedConflictAsync(fx);
+ var first = (await fx.Home.HistoryAsync(id, null, 10, fx.Ct)).Single(v => v.Number == 1);
+ project.WriteSync(project.ReadSync() with { RestoredFrom = first.Id });
+
+ var both = await three.ResolveAsync(id, fx.Home, ConflictChoice.SaveBoth, cancellationToken: fx.Ct);
+ Assert.NotNull(both.SavedAs);
+ Assert.Equal(new WorkspaceSyncState(first.Id, null), project.ReadSync());
+ }
+
+ [Test]
+ public async Task AProjectDeletedAtTheHomeIsGoneAndKeepsEverythingHere()
+ {
+ var fx = await FixtureAsync();
+ var id = await ProjectAsync(fx, "Side");
+ var (_, sync) = fx.Workspace();
+ var project = await fx.CheckoutAsync(sync, id);
+ await EditAsync(sync, id, s => Offset(s, 0.5), fx.Ct);
+ await sync.CommitAsync(id, "unsent", cancellationToken: fx.Ct);
+ await EditAsync(sync, id, s => Offset(s, 0.9), fx.Ct);
+ await fx.Archive.Service.Projects.DeleteAsync(id, fx.Ct);
+
+ // Every sync answers Gone, without throwing, and moves nothing.
+ var pulled = await sync.PullAsync(id, fx.Home, fx.Ct);
+ Assert.Equal(WorkspaceState.Gone, pulled.Status.State);
+ Assert.Empty(pulled.Pulled);
+ var pushed = await sync.PushAsync(id, fx.Home, fx.Ct);
+ Assert.Equal(WorkspaceState.Gone, pushed.Status.State);
+ Assert.Empty(pushed.Pushed);
+ Assert.Equal(WorkspaceState.Gone, (await sync.StatusAsync(id, fx.Home, fx.Ct)).State);
+ Assert.Equal("unsent", sync.Unpushed(id).Single().Note);
+ Assert.Equal(0.9, await WorkingOffsetAsync(sync, id, fx.Ct));
+ Assert.Equal(WorkspaceSyncState.None, project.ReadSync());
+ }
+
+ [Test]
+ public async Task ASaveBothOfAProjectDeletedAtTheHomeIsGoneAndARetryMakesNoOtherCopy()
+ {
+ 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);
+ await fx.Archive.Service.Projects.DeleteAsync(id, fx.Ct);
+
+ var both = await three.ResolveAsync(id, fx.Home, ConflictChoice.SaveBoth, cancellationToken: fx.Ct);
+ Assert.Equal(WorkspaceState.Gone, both.Status.State);
+ 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.Equal(listed, (await fx.Home.ListAsync(fx.Ct)).Count);
+ 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.
+ var working = (await three.OpenAsync(id, fx.Ct)).Working;
+ Assert.Equal((2.0, StackSetting.Mean), (working.Exposure.ExposureOffsetEv, working.Stack.Mode));
+ Assert.Contains(project.Versions(), v => v.Note == "bright");
+ }
+
+ [Test]
+ public async Task ACopyWritesAConvertedPhotoUnderANameOfItsOwnAndSwitchesAtItsCommit()
+ {
+ var fx = await FixtureAsync(4);
+ var (store, sync) = fx.Workspace();
+ var project = await fx.CheckoutAsync(sync);
+ var id = project.ProjectId;
+ var before = project.ReadMedia()!.Frames[1];
+ var editors = project.MediaFile(before.File!);
+ var bytes = File.ReadAllBytes(editors);
+ await ProjectServiceTests.ConvertAsync(fx.Archive, fx.Sequence.Id, [1], 700);
+ // The archive's proxy of the frame is made again from the converted photo.
+ var row = (await fx.Db.Sequences.GetAsync(fx.Sequence.Id))!;
+ var proxy = fx.Archive.Paths.Sequence(row.Folder).Proxy(1);
+ if (File.Exists(proxy)) File.Delete(proxy);
+
+ Job job;
+ string? written = null;
+ using (await project.LockAsync(Wait, fx.Ct))
+ {
+ // The copy waits for the lease at its commit, its files written.
+ job = await fx.StartCopyAsync(store, id);
+ await UntilAsync(() => (written = Directory.GetFiles(project.ProxiesDirectory, $"{before.Id:N}-*.jpg").FirstOrDefault()) is not null,
+ "the converted photo's proxy", fx.Ct);
+ await fx.Archive.WaitForAsync(job.Id, JobState.Running, (int)TestTiming.Budget(30));
+ Assert.SequenceEqual(bytes, File.ReadAllBytes(editors), "the editor's file is never written over before the commit");
+ Assert.Equal(before.File, project.ReadMedia()!.Frames[1].File);
+ }
+ await fx.Archive.WaitForAsync(job.Id, JobState.Done, (int)TestTiming.Budget(60));
+ var after = project.ReadMedia()!.Frames[1];
+ Assert.Equal(Path.GetFileName(written), Path.GetFileName(after.File));
+ Assert.NotEqual(before.FileSha256, after.FileSha256);
+ Assert.False(File.Exists(editors), "the file the media no longer name goes at the commit");
+ }
+
+ [Test]
+ public async Task ACancelledFirstCopyRemovesTheMediaItWroteOnceItStopped()
+ {
+ 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);
+ var lease = await project.LockAsync(Wait, fx.Ct);
+ Job job;
+ try
+ {
+ 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.CancelAsync(job.Id);
+ await fx.Archive.WaitForAsync(job.Id, JobState.Cancelled, (int)TestTiming.Budget(30));
+ 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 second copy 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.CancelAsync(job.Id);
+ await fx.Archive.WaitForAsync(job.Id, JobState.Cancelled, (int)TestTiming.Budget(30));
+ }
+ 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 async Task APausedFirstCopyKeepsWhatItWrote()
+ {
+ 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);
+ using (await project.LockAsync(Wait, fx.Ct))
+ {
+ var 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));
+ }
+ // Taken again by this test: nothing waited for it to remove the files.
+ using (await project.LockAsync(Wait, fx.Ct))
+ Assert.Equal(fx.Frames.Count, Directory.GetFiles(project.ProxiesDirectory, "*.jpg").Length);
+ }
+
+ [Test]
+ public async Task AVersionReadAsDamagedWhileAnotherHoldsTheProjectIsReportedOnlyOnceConfirmed()
+ {
+ var fx = await FixtureAsync();
+ var (_, sync) = fx.Workspace();
+ var project = await fx.CheckoutAsync(sync);
+ var id = project.ProjectId;
+ await EditAsync(sync, id, s => Offset(s, 0.5), fx.Ct);
+ var version = Assert.NotNull(await sync.CommitAsync(id, "first", cancellationToken: fx.Ct));
+ File.WriteAllText(project.VersionPath(version), "{ half written");
+
+ WorkspaceStatus busy;
+ using (await project.LockAsync(Wait, fx.Ct))
+ busy = await sync.StatusAsync(id, fx.Home, fx.Ct);
+ Assert.Equal(0, busy.Damaged);
+ Assert.NotEqual(WorkspaceState.Damaged, busy.State);
+
+ var free = await sync.StatusAsync(id, fx.Home, fx.Ct);
+ Assert.Equal((WorkspaceState.Damaged, 1), (free.State, free.Damaged));
+ }
+
+ [Test]
+ public void TheReplacedVersionsArePrunedByAgeAndCountButNeverOneStillNamed()
+ {
+ var store = new WorkspaceStore(Path.Combine(Context.CreateTempDirectory("prune"), "workspace"));
+ var project = store.Project(Guid.CreateVersion7());
+ var aside = Path.Combine(project.VersionsDirectory, WorkspaceProject.ReplacedFolder);
+ Directory.CreateDirectory(aside);
+ var now = DateTime.UtcNow;
+ var files = new List<(string Path, Guid Id)>();
+ for (var i = 0; i < 25; i++)
+ {
+ var id = Guid.CreateVersion7();
+ var path = Path.Combine(aside, $"{i + 1}-{id:N}.json" + (i == 24 ? ".638000000000000000" : ""));
+ File.WriteAllText(path, "{}");
+ File.SetLastWriteTimeUtc(path, now - (i < 22 ? TimeSpan.FromHours(i + 1) : TimeSpan.FromDays(31 + i)));
+ files.Add((path, id));
+ }
+
+ // The newest 20 stay; of the rest, only those a journal still names.
+ var removed = project.PruneReplaced(new HashSet { files[21].Id, files[24].Id }, now);
+ Assert.Equal(3, removed);
+ var left = Directory.GetFiles(aside).ToHashSet(StringComparer.OrdinalIgnoreCase);
+ foreach (var (path, _) in files.Take(20)) Assert.Contains(path, left);
+ Assert.Contains(files[21].Path, left);
+ Assert.Contains(files[24].Path, left);
+ Assert.DoesNotContain(files[20].Path, left);
+ Assert.DoesNotContain(files[22].Path, left);
+ Assert.DoesNotContain(files[23].Path, left);
+ }
+
+ [Test]
+ public async Task ASyncThatEndsWellPrunesTheReplacedVersions()
+ {
+ var fx = await FixtureAsync();
+ var id = await ProjectAsync(fx, "Pruned");
+ var (_, two, project, shown) = await AskedAsync(fx, id);
+ await two.ResolveAsync(id, fx.Home, ConflictChoice.TakeServer, shown: shown, cancellationToken: fx.Ct);
+ var aside = Path.Combine(project.VersionsDirectory, WorkspaceProject.ReplacedFolder);
+ var files = Directory.GetFiles(aside);
+ 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));
+
+ await two.PushAsync(id, fx.Home, fx.Ct);
+ Assert.False(File.Exists(old));
+ Assert.True(File.Exists(taken), "what the take replaced stays a month");
+ }
+
+ [Test]
+ public async Task TheHomesFramesAreReadAgainOnlyWhenItsStampMoved()
+ {
+ var fx = await FixtureAsync(4);
+ var (_, sync) = fx.Workspace();
+ var project = await fx.CheckoutAsync(sync);
+ var id = project.ProjectId;
+ var home = new CountingHome(fx.Home);
+ Assert.False((await sync.StatusAsync(id, home, fx.Ct)).MediaOutdated);
+ var read = home.FramesReads;
+ Assert.False((await sync.StatusAsync(id, home, fx.Ct)).MediaOutdated);
+ Assert.Equal(read, home.FramesReads, "the same stamp: the frames read before");
+
+ await ProjectServiceTests.ConvertAsync(fx.Archive, fx.Sequence.Id, [1], 700);
+ Assert.True((await sync.StatusAsync(id, home, fx.Ct)).MediaOutdated);
+ Assert.Equal(read + 1, home.FramesReads);
+ Assert.True((await sync.StatusAsync(id, home, fx.Ct)).MediaOutdated);
+ Assert.Equal(read + 1, home.FramesReads);
+ }
+}
+
+public sealed class SqliteWorkspaceSafetyTests(TestContext context) : WorkspaceSafetyTests(context)
+{
+ protected override Backend Backend => Backend.SqliteFile;
+}
+
+[RequiresEnvironment(PgTestServer.Variable)]
+public sealed class PostgresWorkspaceSafetyTests(TestContext context) : WorkspaceSafetyTests(context)
+{
+ protected override Backend Backend => Backend.Postgres;
+}