diff --git a/src/Chronos.App/Shell/ShellViewModel.cs b/src/Chronos.App/Shell/ShellViewModel.cs
index d0fc0999..1264f416 100644
--- a/src/Chronos.App/Shell/ShellViewModel.cs
+++ b/src/Chronos.App/Shell/ShellViewModel.cs
@@ -4,6 +4,7 @@ using System.Windows.Shell;
using Chronos.App.About;
using Chronos.App.Infrastructure;
using Chronos.App.Sections;
+using Chronos.App.Workspace;
using Chronos.Core.Diagnostics;
using Chronos.Core.Localization;
using Chronos.Ui.Controls;
@@ -172,6 +173,8 @@ public sealed class ShellViewModel : LocalizedViewModel
Settings.Attach();
About.Attach();
await Server.AttachAsync();
+ // A move of the workspace folder that stopped before it ended is offered again (phase 5c).
+ await WorkspaceFolderChange.NoticeUnfinishedMoveAsync(this);
}
/// Opens a sequence in Edit.
diff --git a/src/Chronos.App/Workspace/WorkspaceFolderChange.cs b/src/Chronos.App/Workspace/WorkspaceFolderChange.cs
index 81c744a3..388a9c3c 100644
--- a/src/Chronos.App/Workspace/WorkspaceFolderChange.cs
+++ b/src/Chronos.App/Workspace/WorkspaceFolderChange.cs
@@ -4,6 +4,8 @@ using Chronos.App.Infrastructure;
using Chronos.App.Shell;
using Chronos.Core.Diagnostics;
using Chronos.Core.Localization;
+using Chronos.Data;
+using Chronos.Data.Workspaces;
namespace Chronos.App.Workspace;
@@ -12,7 +14,8 @@ namespace Chronos.App.Workspace;
/// inside a library, where Edit cannot be used until one is chosen. The folder is picked, its plan shown and confirmed
/// (the projects the folder in use keeps, those the new one holds), a workspace project open in the editor closes (its
/// last edit stored first), and only then does the setting change. Nothing is moved or deleted: the projects of the
-/// folder left stay there, listed again once it is chosen back. Moving a workspace with its projects comes in phase 5c.
+/// folder left stay there, listed again once it is chosen back. Settings › Workspace › Move… (phase 5c) moves the folder
+/// with its projects instead, after its plan, by a job; a move that stopped before it ended is offered again at start.
///
public static class WorkspaceFolderChange
{
@@ -20,14 +23,8 @@ public static class WorkspaceFolderChange
public static async Task ChooseAsync(ShellViewModel shell)
{
ArgumentNullException.ThrowIfNull(shell);
- var changed = await ChooseAsync(shell.Services.Workspace, shell.Services.Dialogs, async () =>
- {
- if (shell.Sequence.Editor?.Session.Source is not WorkspaceSequenceSource) return true;
- if (!await shell.Sequence.ConfirmCloseAsync()) return false;
- await shell.Sequence.CloseAsync();
- shell.KeepSequence(null);
- return true;
- }, message => shell.Notify(Loc.L("Settings.Workspace.NotChanged"), message, isError: true));
+ var changed = await ChooseAsync(shell.Services.Workspace, shell.Services.Dialogs, () => CloseProjectAsync(shell),
+ message => shell.Notify(Loc.L("Settings.Workspace.NotChanged"), message, isError: true));
if (changed) shell.Notify(Loc.L("Settings.Workspace.Changed"), shell.Services.Workspace.Root);
return changed;
}
@@ -70,25 +67,115 @@ public static class WorkspaceFolderChange
/// Settings › Workspace › Move… (phase 5c): the shell's flow over ,
/// with its folder picker, confirmation, editor and toasts. True when the move was queued.
///
- public static Task MoveAsync(ShellViewModel shell)
+ public static async Task MoveAsync(ShellViewModel shell)
{
ArgumentNullException.ThrowIfNull(shell);
- throw new NotImplementedException("Moving the workspace folder comes with phase 5c (P6).");
+ var host = shell.Services.Workspace;
+ var from = host.Root;
+ var queued = await MoveAsync(host, shell.Services.Dialogs, () => CloseProjectAsync(shell),
+ message => shell.Notify(Loc.L("Settings.Workspace.NotMoved"), message, isError: true));
+ if (queued) shell.Notify(Loc.L("Settings.Workspace.Moving"), from);
+ return queued;
}
///
/// Picks the folder the workspace moves to through , shows its plan
/// () and asks for the user's word, lets close a
/// workspace project open in the editor (false keeps everything as it is), then queues the move
- /// (). hears why it was refused. True when it was queued.
+ /// () of the plan read again once the project is closed (its last edit
+ /// stored), unless that one refuses. hears why it was refused. True when it was queued.
///
- public static Task MoveAsync(WorkspaceHost host, IAppDialogs dialogs, Func> closeProject, Action failed)
+ public static async Task MoveAsync(WorkspaceHost host, IAppDialogs dialogs, Func> closeProject, Action failed)
{
ArgumentNullException.ThrowIfNull(host);
ArgumentNullException.ThrowIfNull(dialogs);
ArgumentNullException.ThrowIfNull(closeProject);
ArgumentNullException.ThrowIfNull(failed);
- throw new NotImplementedException("Moving the workspace folder comes with phase 5c (P6).");
+ if (host.IsMoving)
+ {
+ failed(Loc.L("Errors.Workspace.Moving"));
+ return false;
+ }
+ if (dialogs.PickFolder(Loc.L("Settings.Workspace.MoveTitle"), Directory.Exists(host.Root) ? Path.GetDirectoryName(host.Root) : null) is not { } folder)
+ return false;
+ try
+ {
+ var plan = await host.PlanMoveAsync(folder);
+ if (plan.Refusal is { } refused)
+ {
+ failed(refused);
+ return false;
+ }
+ if (!dialogs.Confirm(MoveRequest(plan))) return false;
+ if (!await closeProject()) return false;
+ // Closing stored the last edit: the job checks the plan of the workspace as it is now.
+ plan = await host.PlanMoveAsync(folder);
+ if (plan.Refusal is { } refusedNow)
+ {
+ failed(refusedNow);
+ return false;
+ }
+ await host.QueueMoveAsync(plan);
+ return true;
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException or ArgumentException or WorkspaceException)
+ {
+ Log.Warning("workspace", $"The workspace folder was not moved to {folder}", ex);
+ failed(ex is WorkspaceException ? ex.Message : Loc.L("Errors.Workspace.FolderUnusable", folder));
+ return false;
+ }
+ }
+
+ ///
+ /// At start: a move of the workspace folder that stopped before it ended (its journal in the folder in use, no move job
+ /// waiting) is said, with Resume, which queues it again to go on from its journal. A move job still waiting holds the
+ /// workspace until it ends.
+ ///
+ public static async Task NoticeUnfinishedMoveAsync(ShellViewModel shell)
+ {
+ ArgumentNullException.ThrowIfNull(shell);
+ var host = shell.Services.Workspace;
+ if (!host.IsAvailable) return;
+ try
+ {
+ if (await host.UnfinishedMoveAsync() is not { } journal) return;
+ shell.Notify(Loc.L("Settings.Workspace.MoveUnfinished"), Loc.L("Settings.Workspace.MoveUnfinishedMessage", journal.To, journal.From),
+ Loc.L("Settings.Workspace.ResumeMove"), Loc.L("Tooltips.Settings.Workspace.ResumeMove"), () => _ = ResumeAsync(shell, journal), isError: true);
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or DatabaseException)
+ {
+ Log.Warning("workspace", "An unfinished move of the workspace could not be looked for", ex);
+ }
+ }
+
+ ///
+ /// The move's plan as a confirmation: where the projects go, how many and how big, the free bytes at the target, whether
+ /// folders are renamed or files copied and checked, and how many projects hold work not at their home (they move with it).
+ ///
+ public static ConfirmRequest MoveRequest(WorkspaceMovePlan plan)
+ {
+ ArgumentNullException.ThrowIfNull(plan);
+ var lines = new List
+ {
+ Loc.L("Settings.Workspace.MovePlan.Projects", Formatting.Count(plan.Projects.Count)),
+ Loc.L("Settings.Workspace.MovePlan.Files", Formatting.Count(plan.Files)),
+ Loc.L("Settings.Workspace.MovePlan.Size", Formatting.Bytes(plan.Bytes)),
+ };
+ if (plan.Free is { } free) lines.Add(Loc.L("Settings.Workspace.MovePlan.Free", Formatting.Bytes(free)));
+ lines.Add(Loc.L(plan.SameVolume ? "Settings.Workspace.MovePlan.SameVolume" : "Settings.Workspace.MovePlan.OtherVolume"));
+ if (plan.Warnings > 0) lines.Add(Loc.L("Settings.Workspace.MovePlan.Unsent", Formatting.Count(plan.Warnings)));
+ return new ConfirmRequest
+ {
+ Heading = Loc.L("Settings.Workspace.MovePlan.Title"),
+ Message = Loc.L("Settings.Workspace.MovePlan.Message", plan.From, plan.To),
+ Detail = string.Join(Environment.NewLine, lines),
+ DetailToolTip = plan.Warnings > 0 ? Loc.L("Tooltips.Settings.Workspace.MovePlan.Unsent") : null,
+ IsDetailMonospaced = false,
+ SafeText = Loc.L("Archive.Dialog.Cancel"),
+ SafeToolTip = Loc.L("Tooltips.Settings.Workspace.MovePlan.Keep"),
+ ActionText = Loc.L("Settings.Workspace.MovePlan.Action"),
+ ActionToolTip = Loc.L("Tooltips.Settings.Workspace.MovePlan.Action"),
+ };
}
/// The plan as a confirmation: where Edit's projects come from now, and what stays where it is.
@@ -108,4 +195,30 @@ public static class WorkspaceFolderChange
ActionToolTip = Loc.L("Tooltips.Settings.UseWorkspace"),
};
}
+
+ /// Queues again the move a journal records, the project open in the editor closed first.
+ private static async Task ResumeAsync(ShellViewModel shell, WorkspaceMoveJournal journal)
+ {
+ try
+ {
+ if (!await CloseProjectAsync(shell)) return;
+ await shell.Services.Workspace.ResumeMoveAsync(journal);
+ shell.Notify(Loc.L("Settings.Workspace.Moving"), journal.From);
+ }
+ catch (Exception ex) when (ex is IOException or WorkspaceException or DatabaseException)
+ {
+ Log.Warning("workspace", $"The move of the workspace to {journal.To} could not be queued again", ex);
+ shell.Notify(Loc.L("Settings.Workspace.NotMoved"), ex is WorkspaceException ? ex.Message : null, isError: true);
+ }
+ }
+
+ /// A workspace project open in the editor closes (its last edit stored first); false when the user kept it open.
+ private static async Task CloseProjectAsync(ShellViewModel shell)
+ {
+ if (shell.Sequence.Editor?.Session.Source is not WorkspaceSequenceSource) return true;
+ if (!await shell.Sequence.ConfirmCloseAsync()) return false;
+ await shell.Sequence.CloseAsync();
+ shell.KeepSequence(null);
+ return true;
+ }
}
diff --git a/src/Chronos.App/Workspace/WorkspaceHost.Move.cs b/src/Chronos.App/Workspace/WorkspaceHost.Move.cs
index 9d70dfc6..f1250666 100644
--- a/src/Chronos.App/Workspace/WorkspaceHost.Move.cs
+++ b/src/Chronos.App/Workspace/WorkspaceHost.Move.cs
@@ -1,5 +1,10 @@
+using System.IO;
+using Chronos.Core.Diagnostics;
using Chronos.Core.Localization;
using Chronos.Core.Model;
+using Chronos.Data.Archiving;
+using Chronos.Data.Jobs;
+using Chronos.Data.Workspaces;
namespace Chronos.App.Workspace;
@@ -18,8 +23,9 @@ public sealed record WorkspaceMoveProject(Guid ProjectId, string Name, int Files
///
/// Why the move cannot go, one localized sentence: the target is the folder itself or inside it
/// (Errors.Workspace.MoveSameFolder), already holds a workspace or a project of the same id
-/// (Errors.Workspace.MoveTargetNotEmpty), lacks the room (Errors.Workspace.DiskFull), or a workspace job is
-/// pending or running (Errors.Workspace.JobsRunning); null when it can go.
+/// (Errors.Workspace.MoveTargetNotEmpty), lies inside a library (Errors.Workspace.InsideLibraryFolder), lacks
+/// the room (Errors.Workspace.MoveNoRoom), or a workspace job is pending or running (Errors.Workspace.JobsRunning);
+/// null when it can go.
///
public sealed record WorkspaceMovePlan(string From, string To, IReadOnlyList Projects, int Files, long Bytes, long? Free, bool SameVolume,
string? Refusal, string Fingerprint)
@@ -33,38 +39,169 @@ public sealed record WorkspaceMovePlan(string From, string To, IReadOnlyList
/// Moving the workspace folder with its projects (phase 5c, P6): the plan, the that
-/// carries it out, and the workspace that follows the folder once every file is verified there. While a move is queued or
-/// running the workspace is refused for syncs, saves and opens (). Stubs until the move lands.
+/// carries it out, and the workspace that follows the folder once every file is verified there. While a move is queued,
+/// running or paused, and while the folder in use holds a move's journal (a move under way, or one stopped before it
+/// ended), the workspace is refused for checkouts, copies, saves, syncs, opens and another folder
+/// ().
///
public sealed partial class WorkspaceHost
{
- /// A move of the workspace folder is queued or running: syncs, saves and opens wait for it.
- public bool IsMoving => false;
+ /// The kinds of job that write into the workspace folder: none may wait or run when a move starts.
+ private static readonly JobKind[] WorkspaceJobKinds = [JobKind.WorkspaceCopy, JobKind.WorkspaceRender, JobKind.WorkspaceSend, JobKind.WorkspaceMove];
- /// The plan of moving the workspace folder to (); nothing is written.
+ /// The thread the host was made on (the UI's): the settings are written there when a move ends.
+ private readonly SynchronizationContext? _moveContext = SynchronizationContext.Current;
+
+ /// The move job queued from here (or found waiting at start), until it ends; empty when there is none.
+ private Guid _moveJob;
+
+ /// The engine whose job changes the host follows, to see a move end.
+ private JobEngine? _followed;
+
+ ///
+ /// A move of the workspace folder is queued, running or paused, or the folder in use holds the journal of one that has
+ /// not ended: syncs, saves and opens wait for it.
+ ///
+ public bool IsMoving
+ {
+ get
+ {
+ lock (_gate)
+ {
+ if (_moveJob != Guid.Empty) return true;
+ }
+ return WorkspaceMover.HasJournal(Root);
+ }
+ }
+
+ ///
+ /// A move stopped before it ended: the folder in use holds its journal and no move job waits, runs or is paused. Null
+ /// when there is none (a move under way is no move to take up). A move job waiting at start is followed from now on,
+ /// so the workspace waits for it ().
+ ///
+ public Task UnfinishedMoveAsync(CancellationToken cancellationToken = default) => Task.Run(async () =>
+ {
+ if (_db() is not { } db) return null;
+ foreach (var state in new[] { JobState.Running, JobState.Queued, JobState.Paused })
+ {
+ if ((await db.Jobs.ListAsync(state, JobKind.WorkspaceMove, 1, cancellationToken: cancellationToken).ConfigureAwait(false)).Items is [var pending, ..])
+ {
+ Follow(pending.Id);
+ return null;
+ }
+ }
+ return WorkspaceMover.HasJournal(Root) ? WorkspaceMover.ReadJournal(Root) : null;
+ }, cancellationToken);
+
+ ///
+ /// The plan of moving the workspace folder to (); nothing is
+ /// written. Each project is read here, never at its home: a move keeps whatever is not sent yet, the plan only says so.
+ ///
+ /// The workspace folder cannot be read.
public Task PlanMoveAsync(string to, CancellationToken cancellationToken = default)
{
ArgumentException.ThrowIfNullOrWhiteSpace(to);
- throw new NotImplementedException("Moving the workspace folder comes with phase 5c (P6).");
+ var root = Root;
+ var free = _archives()?.FreeSpace;
+ return Task.Run(async () =>
+ {
+ var target = Path.GetFullPath(to);
+ var survey = new WorkspaceMover(root, target) { FreeSpace = free }.Survey();
+ var projects = new List();
+ foreach (var folder in survey.Projects.Where(p => p.IsProject))
+ {
+ cancellationToken.ThrowIfCancellationRequested();
+ projects.Add(await MoveProjectAsync(folder, cancellationToken).ConfigureAwait(false));
+ }
+ var refusal = survey.RefusalText;
+ if (refusal is null && await InsideALibraryAsync(survey.To, cancellationToken).ConfigureAwait(false))
+ refusal = Loc.L("Errors.Workspace.InsideLibraryFolder", survey.To);
+ if (refusal is null && (IsMoving || WorkspaceMover.HasJournal(survey.From))) refusal = Loc.L("Errors.Workspace.Moving");
+ if (refusal is null && _db() is { } db && await db.Jobs.HasPendingAsync(WorkspaceJobKinds, cancellationToken: cancellationToken).ConfigureAwait(false))
+ refusal = Loc.L("Errors.Workspace.JobsRunning");
+ return new WorkspaceMovePlan(survey.From, survey.To, projects, survey.Files, survey.Bytes, survey.Free, survey.SameVolume, refusal, survey.Fingerprint);
+ }, cancellationToken);
}
- /// Queues the of a plan the user confirmed.
- /// The plan refuses the move.
- public Task QueueMoveAsync(WorkspaceMovePlan plan, CancellationToken cancellationToken = default)
+ ///
+ /// Queues the of a plan the user confirmed: from now until it ends the workspace is
+ /// refused for writes and opens ().
+ ///
+ /// The plan refuses the move, or a move is under way already.
+ public async Task QueueMoveAsync(WorkspaceMovePlan plan, CancellationToken cancellationToken = default)
{
ArgumentNullException.ThrowIfNull(plan);
- throw new NotImplementedException("Moving the workspace folder comes with phase 5c (P6).");
+ if (plan.Refusal is { } refusal) throw new WorkspaceException(refusal);
+ EnsureNotMoving();
+ var engine = _engine() ?? throw new WorkspaceException(Loc.L("Editor.Error.NoEngine"));
+ var job = await engine.EnqueueAsync(WorkspaceJobs.Move(plan.From, plan.To, plan.Fingerprint), cancellationToken: cancellationToken).ConfigureAwait(false);
+ Follow(job.Id);
+ Log.Info("workspace", $"Move {job.Id} of the workspace {plan.From} to {plan.To} queued ({plan.Projects.Count} project(s), {plan.Bytes} bytes)");
+ return job;
+ }
+
+ ///
+ /// Queues again the move a journal records (): it goes on from the journal, nothing
+ /// verified is copied twice.
+ ///
+ /// The index or the engine is not open.
+ public async Task ResumeMoveAsync(WorkspaceMoveJournal journal, CancellationToken cancellationToken = default)
+ {
+ ArgumentNullException.ThrowIfNull(journal);
+ var engine = _engine() ?? throw new WorkspaceException(Loc.L("Editor.Error.NoEngine"));
+ var job = await engine.EnqueueAsync(WorkspaceJobs.Move(journal.From, journal.To, journal.Fingerprint), cancellationToken: cancellationToken).ConfigureAwait(false);
+ Follow(job.Id);
+ Log.Info("workspace", $"Move {job.Id} of the workspace {journal.From} to {journal.To} queued again from its journal");
+ return job;
}
///
/// Told by the move job once every file of the workspace is verified at
- /// (WorkspaceJobOptions.Moved): Settings › Workspace names the new folder and the workspace opens there.
+ /// (WorkspaceJobOptions.Moved, any thread): on the thread the host was made on, Settings › Workspace names the new
+ /// folder (none when it is the default) and the workspace opens there. A workspace that is no longer in
+ /// (another folder chosen meanwhile) keeps its folder.
///
public Task MovedAsync(string from, string to)
{
ArgumentException.ThrowIfNullOrWhiteSpace(from);
ArgumentException.ThrowIfNullOrWhiteSpace(to);
- throw new NotImplementedException("Moving the workspace folder comes with phase 5c (P6).");
+ if (_moveContext is not { } context) return Task.Run(() => FollowFolder(from, to));
+ if (SynchronizationContext.Current == context)
+ {
+ FollowFolder(from, to);
+ return Task.CompletedTask;
+ }
+ var done = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+ context.Post(_ =>
+ {
+ try
+ {
+ FollowFolder(from, to);
+ done.TrySetResult();
+ }
+ catch (Exception ex)
+ {
+ done.TrySetException(ex);
+ }
+ }, null);
+ return done.Task;
+ }
+
+ /// The settings name the folder a move verified everything in.
+ private void FollowFolder(string from, string to)
+ {
+ var target = Full(to);
+ if (!string.Equals(Full(Root), Full(from), StringComparison.OrdinalIgnoreCase) && !string.Equals(Full(Root), target, StringComparison.OrdinalIgnoreCase))
+ {
+ Log.Warning("workspace", $"The workspace moved from {from} to {to}, but {Root} is in use now: it stays so");
+ return;
+ }
+ _settings.WorkspaceFolder = string.Equals(target, Full(DefaultRoot(_environment)), StringComparison.OrdinalIgnoreCase) ? null : target;
+ _savePreferences();
+ lock (_gate) _open = null;
+ Log.Info("workspace", $"The workspace folder is now {target}, moved from {from}");
+
+ static string Full(string folder) => Path.TrimEndingDirectorySeparator(Path.GetFullPath(folder));
}
/// Refuses an operation that writes into the workspace while its folder is being moved.
@@ -73,4 +210,61 @@ public sealed partial class WorkspaceHost
{
if (IsMoving) throw new WorkspaceException(Loc.L("Errors.Workspace.Moving"));
}
+
+ /// Holds the workspace while move job waits, runs or is paused; lets go once it ends, however it ends.
+ private void Follow(Guid jobId)
+ {
+ var engine = _engine();
+ lock (_gate)
+ {
+ _moveJob = jobId;
+ if (engine is null || ReferenceEquals(engine, _followed)) return;
+ if (_followed is { } before) before.JobChanged -= OnMoveJobChanged;
+ _followed = engine;
+ engine.JobChanged += OnMoveJobChanged;
+ }
+ }
+
+ private void OnMoveJobChanged(Job job)
+ {
+ if (job.Kind != JobKind.WorkspaceMove || job.State is not (JobState.Done or JobState.Failed or JobState.Cancelled)) return;
+ lock (_gate)
+ {
+ if (_moveJob == job.Id) _moveJob = Guid.Empty;
+ }
+ }
+
+ /// A project as the move's plan lists it, read from the workspace alone (its versions not sent, its ledger, its changes).
+ private async Task MoveProjectAsync(WorkspaceMoveFolder folder, CancellationToken cancellationToken)
+ {
+ var project = Store.Project(folder.ProjectId);
+ var entry = await EntryOrUnreadableAsync(project, cancellationToken).ConfigureAwait(false);
+ // What a copy this Chronos cannot read holds is not known: it moves as it is, counted as work not at its home.
+ if (!entry.IsReadable) return new WorkspaceMoveProject(folder.ProjectId, entry.KnownName ?? entry.Name, folder.Files, folder.Bytes, true, false);
+ try
+ {
+ var status = await Sync.StatusAsync(folder.ProjectId, null, cancellationToken).ConfigureAwait(false);
+ var renders = UnsentRenders(project);
+ return new WorkspaceMoveProject(folder.ProjectId, entry.Name, folder.Files, folder.Bytes, status.Ahead + status.Damaged + renders > 0 || status.Conflict is not null,
+ status.Modified && !status.ReadOnly);
+ }
+ catch (Exception ex) when (ex is IOException or InvalidDataException or UnauthorizedAccessException)
+ {
+ Log.Info("workspace", $"Where project {folder.ProjectId} stands could not be read for the move's plan: {ex.Message}");
+ return new WorkspaceMoveProject(folder.ProjectId, entry.Name, folder.Files, folder.Bytes, true, false);
+ }
+
+ static int UnsentRenders(WorkspaceProject project)
+ {
+ try
+ {
+ return project.ReadRenders().Unsent.Count;
+ }
+ catch (InvalidDataException)
+ {
+ // A ledger this Chronos cannot read: what it lists is not known to be at the home.
+ return 1;
+ }
+ }
+ }
}
diff --git a/src/Chronos.App/Workspace/WorkspaceHost.cs b/src/Chronos.App/Workspace/WorkspaceHost.cs
index 61d5a5a5..dc0e31c1 100644
--- a/src/Chronos.App/Workspace/WorkspaceHost.cs
+++ b/src/Chronos.App/Workspace/WorkspaceHost.cs
@@ -329,13 +329,19 @@ public sealed partial class WorkspaceHost
return (IReadOnlyList)entries;
}, cancellationToken);
- /// The workspace projects of one sequence.
- public async Task> ProjectsOfAsync(Guid sequenceId, CancellationToken cancellationToken = default) =>
- [.. (await ListAsync(cancellationToken).ConfigureAwait(false)).Where(e => e.SequenceId == sequenceId)];
+ /// The workspace projects of one sequence, as Edit opens one.
+ /// The workspace folder is being moved (Errors.Workspace.Moving).
+ public async Task> ProjectsOfAsync(Guid sequenceId, CancellationToken cancellationToken = default)
+ {
+ EnsureNotMoving();
+ return [.. (await ListAsync(cancellationToken).ConfigureAwait(false)).Where(e => e.SequenceId == sequenceId)];
+ }
/// A workspace project by id (damaged or newer when this Chronos cannot read its working state); null when the workspace has none.
+ /// The workspace folder is being moved (Errors.Workspace.Moving).
public Task FindAsync(Guid projectId, CancellationToken cancellationToken = default) => Task.Run(async () =>
{
+ EnsureNotMoving();
if (!Directory.Exists(Root) && await InsideALibraryAsync(cancellationToken).ConfigureAwait(false)) return null;
return Store.Find(projectId) is { } project ? await EntryOrUnreadableAsync(project, cancellationToken).ConfigureAwait(false) : null;
}, cancellationToken);
@@ -363,11 +369,12 @@ public sealed partial class WorkspaceHost
/// Edit's workspace becomes (made, with its manifest, when it is new): Settings › Workspace ›
/// Folder names it from now on (none when it is the default). The projects of the folder left stay there, untouched.
///
- /// The folder lies inside a library ().
+ /// The folder lies inside a library (), or the workspace is being moved.
/// The folder cannot be made or read.
/// The folder holds another program's or a newer workspace manifest.
public async Task UseFolderAsync(string folder, CancellationToken cancellationToken = default)
{
+ EnsureNotMoving();
var plan = await PlanFolderAsync(folder, cancellationToken).ConfigureAwait(false);
if (plan.IsSame) return;
if (plan.InsideLibrary) throw new WorkspaceException(Loc.L("Errors.Workspace.InsideLibraryFolder", plan.Folder)) { FolderRefused = true };
diff --git a/src/Chronos.Data/Workspaces/WorkspaceMoveJobHandler.cs b/src/Chronos.Data/Workspaces/WorkspaceMoveJobHandler.cs
index 6df7803b..71fe5652 100644
--- a/src/Chronos.Data/Workspaces/WorkspaceMoveJobHandler.cs
+++ b/src/Chronos.Data/Workspaces/WorkspaceMoveJobHandler.cs
@@ -1,3 +1,6 @@
+using System.Globalization;
+using Chronos.Core.Diagnostics;
+using Chronos.Core.Localization;
using Chronos.Core.Model;
using Chronos.Data.Jobs;
@@ -8,16 +11,79 @@ namespace Chronos.Data.Workspaces;
/// projects, after the plan the user confirmed (its fingerprint checked again): journaled in <from>/.move.json,
/// moved per project on one volume, copied and hash-verified on both sides across volumes, a project's source deleted only
/// once every file of it is verified, resumable from the journal; at the end is told.
-/// On failure the source stays the workspace and unverified partial copies are removed.
+/// On failure the source stays the workspace and unverified partial copies are removed ().
+/// A move that starts afresh is refused while another job of the workspace waits, runs or is paused (they write into the
+/// folder that moves). Cancelled by the user, while it runs or while it is paused or failed, what it did is undone as
+/// after a failure, unless the target already became the workspace; a pause or the program closing keeps the journal,
+/// from which the next run goes on. The checkpoint carries the progress only: the journal and the files' names say what
+/// is done (a file reaches its final name in the target only once verified).
///
-internal sealed class WorkspaceMoveJobHandler(ChronosDatabase db, WorkspaceJobOptions options) : IJobHandler
+internal sealed class WorkspaceMoveJobHandler(ChronosDatabase db, WorkspaceJobOptions options) : ICancelledJobHandler
{
+ /// The other jobs of the workspace, which write into the folder a move takes away.
+ private static readonly JobKind[] WorkspaceKinds = [JobKind.WorkspaceCopy, JobKind.WorkspaceRender, JobKind.WorkspaceSend];
+
public JobKind Kind => JobKind.WorkspaceMove;
- public Task RunAsync(JobContext context)
+ /// Tests: the mover the job runs (one volume or not, a crash, a damaged copy); null makes the real one.
+ internal Func? Movers { get; init; }
+
+ public async Task RunAsync(JobContext context)
{
ArgumentNullException.ThrowIfNull(context);
- _ = (db, options);
- throw new NotImplementedException("Moving the workspace folder comes with phase 5c (P6).");
+ var ct = context.Cancellation;
+ var parameters = WorkspaceJobs.MoveParameters(context.Job) is { From.Length: > 0, To.Length: > 0, PlanFingerprint.Length: > 0 } read
+ ? read
+ : throw new InvalidDataException(Loc.L("Errors.Workspace.JobParameters"));
+ var mover = Mover(parameters);
+ if (WorkspaceMover.ReadJournal(mover.From) is null && await db.Jobs.HasPendingAsync(WorkspaceKinds, cancellationToken: ct).ConfigureAwait(false))
+ throw new InvalidOperationException(Loc.L("Errors.Workspace.JobsRunning"));
+ try
+ {
+ await mover.MoveAsync(parameters.PlanFingerprint, options.Moved, (done, total, durable) => durable
+ ? context.CheckpointAsync(string.Create(CultureInfo.InvariantCulture, $"move:{done}"), done, total)
+ : context.ReportAsync(done, total),
+ context.Log, ct).ConfigureAwait(false);
+ }
+ catch (OperationCanceledException) when (ct.IsCancellationRequested)
+ {
+ // Stopped: the user's cancel undoes what was done; a pause, a yield or the program closing goes on from the journal.
+ if (await db.Jobs.GetAsync(context.Job.Id, CancellationToken.None).ConfigureAwait(false) is { State: JobState.Cancelled }) Undo(mover, context.Job);
+ throw;
+ }
+ }
+
+ /// A move cancelled while no handler ran it (paused, failed): what it did is undone, unless the target is the workspace already.
+ public Task CancelledAsync(Job job, CancellationToken cancellationToken)
+ {
+ ArgumentNullException.ThrowIfNull(job);
+ if (WorkspaceJobs.MoveParameters(job) is not { From.Length: > 0, To.Length: > 0 } parameters) return Task.CompletedTask;
+ _ = Task.Run(() =>
+ {
+ try
+ {
+ Undo(Mover(parameters), job);
+ }
+ catch (Exception ex) when (ex is not OutOfMemoryException)
+ {
+ // Nobody waits for this task: the journal stays, and the move can be taken up.
+ Log.Warning("workspace", $"Cancelled move {job.Id} could not be undone", ex);
+ }
+ }, CancellationToken.None);
+ return Task.CompletedTask;
+ }
+
+ private WorkspaceMover Mover(WorkspaceMoveParameters parameters) => Movers?.Invoke(parameters) ?? new WorkspaceMover(parameters.From, parameters.To);
+
+ private static void Undo(WorkspaceMover mover, Job job)
+ {
+ try
+ {
+ if (!mover.Abandon()) Log.Info("workspace", $"Move {job.Id} was cancelled after {mover.To} became the workspace; it is not undone");
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+ {
+ Log.Warning("workspace", $"Cancelled move {job.Id} could not be undone; its journal stays to take it up", ex);
+ }
}
}
diff --git a/src/Chronos.Data/Workspaces/WorkspaceMover.cs b/src/Chronos.Data/Workspaces/WorkspaceMover.cs
new file mode 100644
index 00000000..578130f0
--- /dev/null
+++ b/src/Chronos.Data/Workspaces/WorkspaceMover.cs
@@ -0,0 +1,634 @@
+using System.Globalization;
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Chronos.Core.Diagnostics;
+using Chronos.Core.IO;
+using Chronos.Core.Localization;
+
+namespace Chronos.Data.Workspaces;
+
+/// Why the workspace folder cannot move to a folder ().
+public enum WorkspaceMoveRefusal
+{
+ /// The target is the workspace folder itself or lies inside it (Errors.Workspace.MoveSameFolder).
+ SameFolder,
+
+ /// The target holds a workspace (its manifest, its trash, a move's journal) or a folder of the same name as one moved (Errors.Workspace.MoveTargetNotEmpty).
+ TargetNotEmpty,
+
+ /// The target's drive lacks the room for a copy across drives (Errors.Workspace.MoveNoRoom).
+ NoRoom,
+}
+
+/// A folder of a project the workspace holds, as a move surveys it.
+/// It holds a working state (project.chronos); a folder that does not (a leftover) moves all the same.
+public sealed record WorkspaceMoveFolder(Guid ProjectId, bool IsProject, int Files, long Bytes);
+
+///
+/// What moving a workspace folder to would take, read without writing anything: the
+/// entries that move (every folder named by a project id, the manifest, the trash), their files and bytes (leases left
+/// out), the target drive's free bytes, whether both lie on one volume, why it is refused, and a fingerprint of the files
+/// read (their relative names, sizes and times), which the move checks again before it starts.
+///
+/// The target drive's free bytes; null when they cannot be measured (a share), which is not refused.
+/// With , the bytes the target's drive lacks; 0 otherwise.
+public sealed record WorkspaceMoveSurvey(string From, string To, IReadOnlyList Projects, IReadOnlyList Entries, int Files, long Bytes,
+ long? Free, bool SameVolume, WorkspaceMoveRefusal? Refusal, long Missing, string Fingerprint)
+{
+ public bool CanMove => Refusal is null;
+
+ /// The refusal as one localized sentence; null when the move can go.
+ public string? RefusalText => Refusal switch
+ {
+ WorkspaceMoveRefusal.SameFolder => Loc.L("Errors.Workspace.MoveSameFolder", To),
+ WorkspaceMoveRefusal.TargetNotEmpty => Loc.L("Errors.Workspace.MoveTargetNotEmpty", To),
+ WorkspaceMoveRefusal.NoRoom => Loc.L("Errors.Workspace.MoveNoRoom", (Missing / 1e9).ToString("0.0", Loc.Culture)),
+ _ => null,
+ };
+}
+
+/// How far a move of the workspace folder went, as its journal records it.
+public enum WorkspaceMoveStage
+{
+ /// The entries are being moved (one volume) or copied and verified (across volumes); the source is the workspace.
+ Moving,
+
+ /// Every entry is verified at the target and the desktop was told: the target is the workspace; what is left of the source goes.
+ Switched,
+}
+
+///
+/// The journal of a move of the workspace folder (<from>/.move.json, ):
+/// where it goes, the plan's fingerprint, whether it renames folders on one volume, the entries it moves in their order,
+/// those copied and verified at the target already (across volumes), and how far it went. Written whole and atomically
+/// before every step that depends on it, so a move stopped at any moment is taken up, or undone, from it.
+///
+public sealed record WorkspaceMoveJournal(string Format, int FormatVersion, string From, string To, string Fingerprint, bool SameVolume,
+ IReadOnlyList Entries, IReadOnlyList Verified, WorkspaceMoveStage Stage, DateTimeOffset Started)
+{
+ public const string FormatName = "chronos-workspace-move";
+ public const int CurrentFormatVersion = 1;
+}
+
+[JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase, DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+ UseStringEnumConverter = true, WriteIndented = true)]
+[JsonSerializable(typeof(WorkspaceMoveJournal))]
+internal sealed partial class WorkspaceMoveJson : JsonSerializerContext;
+
+///
+/// Moves a workspace folder with its projects (phase 5c, ). What moves: every
+/// folder named by a project id, then workspace.json, then .trash, in that order; anything else in the folder
+/// stays where it is. On one volume each entry is renamed into the target ();
+/// across volumes each file is copied into a .part beside its place, hashed as it is read and read back to hash the
+/// copy, and only once both SHA-256 agree renamed into place (with the source's time), so a file at its final name in the
+/// target is always one verified. The source is the workspace until every entry is at the target: then the desktop is told
+/// (the switch), and only after it does the source of a copy go. The journal () is
+/// written in the source before the first step and at every entry: a move stopped (paused, the program closed, the PC
+/// down) goes on from it, trusting the files at their final names and the entries it records as verified; a move that
+/// fails before the switch is undone (): renamed entries go back, copies at the target are removed,
+/// the journal goes.
+///
+public sealed class WorkspaceMover
+{
+ /// The journal of a move under way, in the workspace folder it leaves.
+ public const string JournalFile = ".move.json";
+
+ /// Where a file copied across volumes is written until its hash is checked.
+ internal const string PartSuffix = ".part";
+
+ private const int BufferSize = 1 << 20;
+ private const int DeleteAttempts = 5;
+
+ /// The workspace folder in use.
+ /// The folder it moves to (made when it is not there).
+ public WorkspaceMover(string from, string to)
+ {
+ ArgumentException.ThrowIfNullOrWhiteSpace(from);
+ ArgumentException.ThrowIfNullOrWhiteSpace(to);
+ From = WorkspaceStore.FullRoot(from);
+ To = WorkspaceStore.FullRoot(to);
+ }
+
+ public string From { get; }
+
+ public string To { get; }
+
+ /// Free bytes on the volume of a folder (the host's measure); null takes the drive's ().
+ public Func? FreeSpace { get; init; }
+
+ /// Whether both folders lie on one volume; null decides from their drives (tests set it to try the copy on one disk).
+ public bool? SameVolume { get; init; }
+
+ /// Bytes a copy across volumes leaves free on the target's drive besides what it copies (as a copy into the workspace keeps).
+ public long Reserve { get; init; } = WorkspaceCopyJobHandler.SpaceReserve;
+
+ ///
+ /// Called at named steps with the path concerned (tests: a crash, a file damaged on its way): verify (a copy's
+ /// .part, written and about to be read back), copied (a file at its final name), moved (an entry
+ /// renamed into the target), switched (the desktop told).
+ ///
+ internal Action? Cut { get; init; }
+
+ /// The journal of a move under way out of ; null when there is none, or it cannot be read (logged).
+ public static WorkspaceMoveJournal? ReadJournal(string root)
+ {
+ ArgumentException.ThrowIfNullOrWhiteSpace(root);
+ var path = Path.Combine(WorkspaceStore.FullRoot(root), JournalFile);
+ if (!File.Exists(path)) return null;
+ try
+ {
+ if (JsonSerializer.Deserialize(AtomicFile.ReadAllText(path), WorkspaceMoveJson.Default.WorkspaceMoveJournal) is
+ { Format: WorkspaceMoveJournal.FormatName, From.Length: > 0, To.Length: > 0, Entries: not null, Verified: not null } journal
+ && journal.FormatVersion <= WorkspaceMoveJournal.CurrentFormatVersion)
+ return journal;
+ Log.Warning("workspace", $"{path} is not a journal of a move this Chronos reads");
+ }
+ catch (Exception ex) when (ex is JsonException or IOException or UnauthorizedAccessException)
+ {
+ Log.Warning("workspace", $"{path} cannot be read", ex);
+ }
+ return null;
+ }
+
+ ///
+ /// True when holds a move's journal, readable or not: the folder is being moved, or a move of it
+ /// stopped before it ended, and nothing may write there until it is taken up or undone.
+ ///
+ public static bool HasJournal(string root) => File.Exists(Path.Combine(WorkspaceStore.FullRoot(root), JournalFile));
+
+ private string JournalPath => Path.Combine(From, JournalFile);
+
+ /// What the move would take and whether it can go (); nothing is written.
+ /// The workspace folder cannot be read.
+ public WorkspaceMoveSurvey Survey()
+ {
+ var comparison = PathComparison;
+ var projects = new List();
+ var entries = new List();
+ var (files, bytes) = (0, 0L);
+ var fingerprint = new StringBuilder();
+ fingerprint.Append(From).Append('\n').Append(To).Append('\n');
+ if (Directory.Exists(From))
+ {
+ foreach (var directory in Directory.EnumerateDirectories(From).Order(StringComparer.Ordinal))
+ {
+ var name = Path.GetFileName(directory);
+ if (!Guid.TryParseExact(name, "N", out var id)) continue;
+ var (count, size) = Read(directory, name, fingerprint);
+ projects.Add(new WorkspaceMoveFolder(id, File.Exists(Path.Combine(directory, WorkspaceProject.BundleFile)), count, size));
+ entries.Add(name);
+ (files, bytes) = (files + count, bytes + size);
+ }
+ var manifest = Path.Combine(From, WorkspaceStore.ManifestFile);
+ if (File.Exists(manifest))
+ {
+ var info = new FileInfo(manifest);
+ entries.Add(WorkspaceStore.ManifestFile);
+ Line(fingerprint, WorkspaceStore.ManifestFile, info);
+ (files, bytes) = (files + 1, bytes + info.Length);
+ }
+ var trash = Path.Combine(From, TrashFolder);
+ if (Directory.Exists(trash))
+ {
+ var (count, size) = Read(trash, TrashFolder, fingerprint);
+ entries.Add(TrashFolder);
+ (files, bytes) = (files + count, bytes + size);
+ }
+ }
+ var same = SameVolume ?? OnOneVolume(From, To);
+ var free = FreeBytes(To);
+ WorkspaceMoveRefusal? refusal = null;
+ long missing = 0;
+ if (string.Equals(From, To, comparison) || To.StartsWith(From + Path.DirectorySeparatorChar, comparison))
+ {
+ refusal = WorkspaceMoveRefusal.SameFolder;
+ }
+ else if (File.Exists(To) || TargetHolds(entries))
+ {
+ refusal = WorkspaceMoveRefusal.TargetNotEmpty;
+ }
+ else if (!same && free is { } room && room < bytes + Reserve)
+ {
+ refusal = WorkspaceMoveRefusal.NoRoom;
+ missing = bytes + Reserve - room;
+ }
+ return new WorkspaceMoveSurvey(From, To, projects, entries, files, bytes, free, same, refusal, missing,
+ Convert.ToHexStringLower(SHA256.HashData(Encoding.UTF8.GetBytes(fingerprint.ToString()))));
+ }
+
+ ///
+ /// Moves the workspace, or takes up the move its journal records: the plan of is checked
+ /// again first (a move taken up has checked it), every entry is moved or copied and verified,
+ /// is told (from, to) once all are at the target, then what is left of the source goes and the journal with it.
+ /// hears the files done and their total, with true where the job should keep it as its
+ /// checkpoint; the lines of the job's log. A failure before the switch undoes what was done
+ /// () and is thrown; a cancel (a pause, the program closing) leaves the journal for the next run.
+ ///
+ /// The survey of the move as it began, and whether it was taken up from a journal.
+ ///
+ /// The workspace changed since its plan (Errors.Workspace.MoveChanged), the move is refused now (the target filled,
+ /// the room went), another move's journal is there (Errors.Workspace.Moving), or a copy did not match its source
+ /// (Errors.Workspace.MoveVerify).
+ ///
+ /// A file or folder could not be read, written or moved.
+ public async Task<(WorkspaceMoveSurvey Survey, bool Resumed)> MoveAsync(string fingerprint, Func? switched = null,
+ Func? progress = null, Action? log = null, CancellationToken cancellationToken = default)
+ {
+ ArgumentException.ThrowIfNullOrWhiteSpace(fingerprint);
+ var survey = Survey();
+ var journal = ReadJournal(From);
+ var resumed = journal is not null;
+ if (journal is null)
+ {
+ if (HasJournal(From)) throw new InvalidOperationException(Loc.L("Errors.Workspace.Moving"));
+ if (!string.Equals(survey.Fingerprint, fingerprint, StringComparison.Ordinal)) throw new InvalidOperationException(Loc.L("Errors.Workspace.MoveChanged"));
+ if (survey.RefusalText is { } refused) throw new InvalidOperationException(refused);
+ journal = new WorkspaceMoveJournal(WorkspaceMoveJournal.FormatName, WorkspaceMoveJournal.CurrentFormatVersion, From, To, fingerprint, survey.SameVolume,
+ survey.Entries, [], WorkspaceMoveStage.Moving, DateTimeOffset.UtcNow);
+ Directory.CreateDirectory(To);
+ WriteJournal(journal);
+ Log.Info("workspace", $"Moving the workspace {From} to {To} ({survey.Entries.Count} entries, {survey.Files} files, {survey.Bytes} bytes, "
+ + (survey.SameVolume ? "renamed" : "copied") + ")");
+ }
+ else
+ {
+ if (!string.Equals(journal.To, To, PathComparison) || !string.Equals(journal.From, From, PathComparison))
+ throw new InvalidOperationException(Loc.L("Errors.Workspace.Moving"));
+ log?.Invoke(Loc.L("Archive.Log.WorkspaceMoveResumed", JournalPath));
+ Log.Info("workspace", $"The move of the workspace {From} to {To} is taken up from its journal ({journal.Stage})");
+ }
+
+ if (journal.Stage == WorkspaceMoveStage.Moving)
+ {
+ try
+ {
+ journal = journal.SameVolume
+ ? await RenameAsync(journal, progress, log, cancellationToken).ConfigureAwait(false)
+ : await CopyAsync(journal, survey, progress, log, cancellationToken).ConfigureAwait(false);
+ }
+ catch (Exception ex) when (ex is not OperationCanceledException || !cancellationToken.IsCancellationRequested)
+ {
+ Log.Warning("workspace", $"The move of the workspace {From} to {To} failed; it is undone", ex);
+ TryAbandon();
+ throw;
+ }
+ journal = journal with { Stage = WorkspaceMoveStage.Switched };
+ WriteJournal(journal);
+ }
+ // From here on the target is the workspace: told again when a run taken up after the switch did not see its answer.
+ if (switched is not null) await switched(From, To).ConfigureAwait(false);
+ Cut?.Invoke("switched", To);
+ Clean(journal);
+ log?.Invoke(Loc.L("Archive.Log.WorkspaceMoved", To, journal.Entries.Count(e => Guid.TryParseExact(e, "N", out _)), survey.Files));
+ Log.Info("workspace", $"The workspace moved from {From} to {To}");
+ return (survey, resumed);
+ }
+
+ ///
+ /// Undoes a move its journal records as not switched yet, so the source stays the workspace: on one volume the entries
+ /// renamed into the target go back; across volumes the copies it made at the target are removed (what cannot be removed
+ /// is logged: the source is whole). The journal then goes. A move that switched is not undone (false): the target is the
+ /// workspace, and the move is taken up to finish clearing the source. True when there was nothing left to undo, or it was.
+ ///
+ /// An entry renamed into the target could not go back; the journal stays, and the move can be taken up.
+ public bool Abandon()
+ {
+ var journal = ReadJournal(From);
+ if (journal is null) return true;
+ if (journal.Stage != WorkspaceMoveStage.Moving) return false;
+ foreach (var entry in journal.Entries.Reverse())
+ {
+ var source = Path.Combine(From, entry);
+ var target = Path.Combine(To, entry);
+ if (journal.SameVolume)
+ {
+ if (Exists(target) && !Exists(source)) Rename(target, source);
+ continue;
+ }
+ try
+ {
+ // Refused when the target held the entry: whatever is there is this move's copy.
+ if (Directory.Exists(target)) Directory.Delete(target, recursive: true);
+ else if (File.Exists(target)) File.Delete(target);
+ var part = target + PartSuffix;
+ if (File.Exists(part)) File.Delete(part);
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+ {
+ Log.Warning("workspace", $"The copy {target} of an undone move could not be removed", ex);
+ }
+ }
+ File.Delete(JournalPath);
+ TryDeleteEmpty(To);
+ Log.Info("workspace", $"The move of the workspace {From} to {To} was undone; the workspace stays in {From}");
+ return true;
+ }
+
+ private void TryAbandon()
+ {
+ try
+ {
+ Abandon();
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+ {
+ Log.Warning("workspace", $"The move of the workspace {From} to {To} could not be undone; its journal stays to take it up", ex);
+ }
+ }
+
+ /// One volume: each entry renamed into the target, an entry already there (a run that stopped after it) taken as moved.
+ private async Task RenameAsync(WorkspaceMoveJournal journal, Func? progress, Action? log,
+ CancellationToken cancellationToken)
+ {
+ var moved = 0;
+ foreach (var entry in journal.Entries)
+ {
+ cancellationToken.ThrowIfCancellationRequested();
+ var source = Path.Combine(From, entry);
+ var target = Path.Combine(To, entry);
+ if (Exists(source))
+ {
+ if (Exists(target)) throw new IOException(Loc.L("Errors.Workspace.MoveTargetNotEmpty", To));
+ Rename(source, target);
+ Cut?.Invoke("moved", target);
+ if (Guid.TryParseExact(entry, "N", out _)) log?.Invoke(Loc.L("Archive.Log.WorkspaceMoveProject", Name(target)));
+ }
+ else if (!Exists(target))
+ {
+ // Gone from both sides: nothing to move (the trash emptied meanwhile cannot happen while the move holds the workspace).
+ Log.Warning("workspace", $"{entry} of the workspace {From} is neither there nor at {To}");
+ }
+ moved++;
+ if (progress is not null) await progress(moved, journal.Entries.Count, true).ConfigureAwait(false);
+ }
+ return journal;
+ }
+
+ ///
+ /// Across volumes: each entry's files copied and verified (), the entry recorded as verified in
+ /// the journal once all of its files are; nothing of the source is touched.
+ ///
+ private async Task CopyAsync(WorkspaceMoveJournal journal, WorkspaceMoveSurvey survey, Func? progress,
+ Action? log, CancellationToken cancellationToken)
+ {
+ var total = (long)survey.Files;
+ long done = 0;
+ var clock = System.Diagnostics.Stopwatch.StartNew();
+ foreach (var entry in journal.Entries)
+ {
+ cancellationToken.ThrowIfCancellationRequested();
+ var source = Path.Combine(From, entry);
+ var target = Path.Combine(To, entry);
+ if (journal.Verified.Contains(entry, StringComparer.Ordinal))
+ {
+ done += Directory.Exists(source) ? Listed(source).Count : File.Exists(source) ? 1 : 0;
+ continue;
+ }
+ if (File.Exists(source))
+ {
+ await CopyFileAsync(source, target, cancellationToken).ConfigureAwait(false);
+ done++;
+ }
+ else if (Directory.Exists(source))
+ {
+ Directory.CreateDirectory(target);
+ foreach (var folder in new DirectoryInfo(source).EnumerateDirectories("*", SearchOption.AllDirectories))
+ Directory.CreateDirectory(Path.Combine(target, Path.GetRelativePath(source, folder.FullName)));
+ foreach (var relative in Listed(source))
+ {
+ cancellationToken.ThrowIfCancellationRequested();
+ await CopyFileAsync(Path.Combine(source, relative), Path.Combine(target, relative), cancellationToken).ConfigureAwait(false);
+ done++;
+ var durable = clock.Elapsed >= CheckpointEvery;
+ if (durable) clock.Restart();
+ if (progress is not null) await progress(done, total, durable).ConfigureAwait(false);
+ }
+ if (Guid.TryParseExact(entry, "N", out _)) log?.Invoke(Loc.L("Archive.Log.WorkspaceMoveProject", Name(source)));
+ }
+ journal = journal with { Verified = [.. journal.Verified, entry] };
+ WriteJournal(journal);
+ if (progress is not null) await progress(done, total, true).ConfigureAwait(false);
+ }
+ return journal;
+ }
+
+ ///
+ /// One file across volumes: a file at its final name with the source's size was verified by an earlier run and stays;
+ /// otherwise the source is streamed into <target>.part and hashed as it is read, the copy is read back and
+ /// hashed, and only when both agree is it renamed into place, with the source's time.
+ ///
+ /// The copy does not match its source (Errors.Workspace.MoveVerify); the .part is removed.
+ private async Task CopyFileAsync(string source, string target, CancellationToken cancellationToken)
+ {
+ var info = new FileInfo(source);
+ if (File.Exists(target) && new FileInfo(target).Length == info.Length) return;
+ var part = target + PartSuffix;
+ try
+ {
+ string sha;
+ using (var hash = IncrementalHash.CreateHash(HashAlgorithmName.SHA256))
+ {
+ var buffer = new byte[BufferSize];
+ await using (var input = new FileStream(source, FileMode.Open, FileAccess.Read, FileShare.Read, BufferSize, FileOptions.Asynchronous | FileOptions.SequentialScan))
+ await using (var output = new FileStream(part, FileMode.Create, FileAccess.Write, FileShare.None, BufferSize, FileOptions.Asynchronous))
+ {
+ int read;
+ while ((read = await input.ReadAsync(buffer, cancellationToken).ConfigureAwait(false)) > 0)
+ {
+ hash.AppendData(buffer, 0, read);
+ await output.WriteAsync(buffer.AsMemory(0, read), cancellationToken).ConfigureAwait(false);
+ }
+ await output.FlushAsync(cancellationToken).ConfigureAwait(false);
+ output.Flush(flushToDisk: true);
+ }
+ sha = Convert.ToHexStringLower(hash.GetHashAndReset());
+ }
+ Cut?.Invoke("verify", part);
+ if (!string.Equals(await Sha256Async(part, cancellationToken).ConfigureAwait(false), sha, StringComparison.Ordinal))
+ throw new InvalidOperationException(Loc.L("Errors.Workspace.MoveVerify", LongPath.ToPortableRelative(From, source)));
+ File.Move(part, target, overwrite: true);
+ File.SetLastWriteTimeUtc(target, info.LastWriteTimeUtc);
+ Cut?.Invoke("copied", target);
+ }
+ catch
+ {
+ TryDelete(part);
+ throw;
+ }
+ }
+
+ ///
+ /// After the switch: across volumes every entry of the source goes (each one verified at the target), folders first, the
+ /// manifest last; then the journal, and the source folder when nothing else is left in it.
+ ///
+ /// An entry of the source could not be removed; the journal stays, and the move taken up removes it.
+ private void Clean(WorkspaceMoveJournal journal)
+ {
+ if (!journal.SameVolume)
+ {
+ foreach (var entry in journal.Entries.OrderBy(e => e == WorkspaceStore.ManifestFile ? 1 : 0))
+ {
+ var source = Path.Combine(From, entry);
+ for (var attempt = 1; ; attempt++)
+ {
+ try
+ {
+ if (Directory.Exists(source)) Directory.Delete(source, recursive: true);
+ else if (File.Exists(source)) File.Delete(source);
+ break;
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException && attempt < DeleteAttempts)
+ {
+ // An indexer or an antivirus reading a file a moment: tried again shortly.
+ Thread.Sleep(100 * attempt);
+ }
+ }
+ }
+ }
+ File.Delete(JournalPath);
+ TryDeleteEmpty(From);
+ }
+
+ /// A folder's files relative to it, in ordinal order, the leases left out (they belong to whoever holds the project there).
+ private static List Listed(string folder) =>
+ [.. new DirectoryInfo(folder).EnumerateFiles("*", SearchOption.AllDirectories).Where(f => !WorkspaceProject.IsLeaseFile(f.Name))
+ .Select(f => Path.GetRelativePath(folder, f.FullName)).Order(StringComparer.Ordinal)];
+
+ /// Files and bytes of an entry, each file's name, size and time added to the fingerprint.
+ private static (int Files, long Bytes) Read(string folder, string name, StringBuilder fingerprint)
+ {
+ var (files, bytes) = (0, 0L);
+ foreach (var relative in Listed(folder))
+ {
+ var info = new FileInfo(Path.Combine(folder, relative));
+ Line(fingerprint, name + "/" + relative.Replace('\\', '/'), info);
+ files++;
+ bytes += info.Length;
+ }
+ return (files, bytes);
+ }
+
+ private static void Line(StringBuilder fingerprint, string name, FileInfo info) =>
+ fingerprint.Append(name).Append('|').Append(info.Length.ToString(CultureInfo.InvariantCulture)).Append('|')
+ .Append(info.LastWriteTimeUtc.Ticks.ToString(CultureInfo.InvariantCulture)).Append('\n');
+
+ /// The target holds a workspace's own files, or a folder or file named as one of the entries that move.
+ private bool TargetHolds(IEnumerable entries) =>
+ Directory.Exists(To) && (Exists(Path.Combine(To, WorkspaceStore.ManifestFile)) || Exists(Path.Combine(To, TrashFolder)) || Exists(Path.Combine(To, JournalFile))
+ || entries.Any(e => Exists(Path.Combine(To, e))));
+
+ private const string TrashFolder = ".trash";
+
+ private static readonly TimeSpan CheckpointEvery = TimeSpan.FromSeconds(5);
+
+ private static StringComparison PathComparison => OperatingSystem.IsWindows() ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
+
+ private static bool Exists(string path) => Directory.Exists(path) || File.Exists(path);
+
+ private static void Rename(string source, string target)
+ {
+ if (Directory.Exists(source)) Directory.Move(source, target);
+ else File.Move(source, target);
+ }
+
+ /// The name a project's working state gives it, for the log; its folder's name when it cannot be read.
+ private static string Name(string folder)
+ {
+ var bundle = Path.Combine(folder, WorkspaceProject.BundleFile);
+ try
+ {
+ if (File.Exists(bundle) && Core.Project.ProjectBundle.Load(bundle).Workspace?.Name is { Length: > 0 } name) return name;
+ }
+ catch (Exception ex) when (ex is IOException or InvalidDataException or UnauthorizedAccessException or JsonException)
+ {
+ Log.Debug("workspace", $"{bundle} names no project: {ex.Message}");
+ }
+ return Path.GetFileName(folder);
+ }
+
+ private void WriteJournal(WorkspaceMoveJournal journal) =>
+ AtomicFile.WriteAllText(JournalPath, JsonSerializer.Serialize(journal, WorkspaceMoveJson.Default.WorkspaceMoveJournal));
+
+ /// Free bytes on the volume of (its nearest folder that exists); null when they cannot be measured.
+ private long? FreeBytes(string folder)
+ {
+ var existing = Nearest(folder);
+ if (existing is null) return null;
+ if (FreeSpace is { } measure) return measure(existing);
+ try
+ {
+ // Windows wants a drive root; Unix accepts any directory and reports the volume it is mounted on.
+ return new DriveInfo(OperatingSystem.IsWindows() ? Path.GetPathRoot(existing)! : existing).AvailableFreeSpace;
+ }
+ catch (Exception ex) when (ex is ArgumentException or IOException or UnauthorizedAccessException)
+ {
+ return null;
+ }
+ }
+
+ ///
+ /// Both folders on one volume: on Windows the same drive; on Unix the same mount point. A doubt reads as two volumes,
+ /// whose copy is the safe way (a rename across volumes would fail).
+ ///
+ private static bool OnOneVolume(string from, string to)
+ {
+ try
+ {
+ if (Nearest(to) is not { } target) return false;
+ if (OperatingSystem.IsWindows())
+ return string.Equals(Path.GetPathRoot(from), Path.GetPathRoot(target), StringComparison.OrdinalIgnoreCase)
+ && !Path.GetPathRoot(from)!.StartsWith(@"\\", StringComparison.Ordinal);
+ var mounts = DriveInfo.GetDrives().Select(d => Path.TrimEndingDirectorySeparator(d.RootDirectory.FullName)).ToList();
+ return string.Equals(Mount(from, mounts), Mount(target, mounts), StringComparison.Ordinal);
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or ArgumentException)
+ {
+ return false;
+ }
+
+ static string? Mount(string path, List mounts) =>
+ mounts.Where(m => path == m || path.StartsWith(m.EndsWith('/') ? m : m + "/", StringComparison.Ordinal)).MaxBy(m => m.Length);
+ }
+
+ /// or its nearest parent that exists; null when none does.
+ private static string? Nearest(string folder)
+ {
+ for (var current = folder; !string.IsNullOrEmpty(current); current = Path.GetDirectoryName(current))
+ {
+ if (Directory.Exists(current)) return current;
+ }
+ return null;
+ }
+
+ private static async Task Sha256Async(string path, CancellationToken cancellationToken)
+ {
+ await using var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, BufferSize, FileOptions.Asynchronous | FileOptions.SequentialScan);
+ return Convert.ToHexStringLower(await SHA256.HashDataAsync(stream, cancellationToken).ConfigureAwait(false));
+ }
+
+ private static void TryDelete(string path)
+ {
+ try
+ {
+ File.Delete(path);
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+ {
+ Log.Debug("workspace", $"{path} stays: {ex.Message}");
+ }
+ }
+
+ private static void TryDeleteEmpty(string folder)
+ {
+ try
+ {
+ if (Directory.Exists(folder) && !Directory.EnumerateFileSystemEntries(folder).Any()) Directory.Delete(folder);
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+ {
+ Log.Debug("workspace", $"{folder} stays: {ex.Message}");
+ }
+ }
+}
diff --git a/tests/Chronos.App.Tests/Workspace/WorkspaceMoveTests.cs b/tests/Chronos.App.Tests/Workspace/WorkspaceMoveTests.cs
new file mode 100644
index 00000000..70d9a308
--- /dev/null
+++ b/tests/Chronos.App.Tests/Workspace/WorkspaceMoveTests.cs
@@ -0,0 +1,224 @@
+using System.Globalization;
+using System.IO;
+using Chronos.App.Infrastructure;
+using Chronos.App.Workspace;
+using Chronos.Core.Localization;
+using Chronos.Core.Model;
+using Chronos.Data;
+using Chronos.Data.Archiving;
+using Chronos.Data.Jobs;
+using Chronos.Data.Workspaces;
+using Chronos.Testing;
+
+namespace Chronos.App.Tests.Workspace;
+
+///
+/// Settings › Workspace › Move… (phase 5c, P6) as the desktop runs it: the plan and its confirmation, the open project
+/// closed first, the workspace held while the move waits or runs, the setting switched only once the move verified
+/// everything, a failed move that leaves both as they were, and a move stopped before it ended taken up again.
+///
+[Category("workspace")]
+public sealed class WorkspaceMoveTests(TestContext context)
+{
+ static WorkspaceMoveTests() => Loc.SetCulture(CultureInfo.GetCultureInfo("en"));
+
+ [Test]
+ public async Task TheWorkspaceWaitsForTheMoveAndFollowsTheFolderOnlyOnceItEnded()
+ {
+ await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 4);
+ var settings = new AppSettings();
+ var mainId = await bed.CheckoutAsync(bed.Host(settings));
+ await using var moves = await MovesAsync(bed, settings);
+ var host = moves.Host;
+ var from = host.Root;
+ var target = Path.Combine(bed.Directory, "moved workspace");
+
+ var plan = await host.PlanMoveAsync(target);
+ Assert.True(plan.CanMove, plan.Refusal);
+ Assert.Equal((from, Path.GetFullPath(target), true), (plan.From, plan.To, plan.SameVolume));
+ var project = Assert.NotNull(plan.Projects.SingleOrDefault());
+ Assert.Equal(mainId, project.ProjectId);
+ Assert.True(plan.Files >= project.Files && project.Files > 0 && plan.Bytes > 0);
+
+ var failures = new List();
+ var closes = 0;
+ var close = true;
+ Task CloseProject()
+ {
+ closes++;
+ return Task.FromResult(close);
+ }
+
+ // Declined, or the open project kept open: nothing is queued.
+ var dialogs = new MoveDialogs { Folder = target, Answer = false };
+ Assert.False(await WorkspaceFolderChange.MoveAsync(host, dialogs, CloseProject, failures.Add));
+ var asked = Assert.NotNull(dialogs.Asked.SingleOrDefault());
+ Assert.Equal(Loc.L("Settings.Workspace.MovePlan.Message", plan.From, plan.To), asked.Message);
+ Assert.Contains(Loc.L("Settings.Workspace.MovePlan.Projects", Formatting.Count(1)), asked.Detail);
+ Assert.Contains(Loc.L("Settings.Workspace.MovePlan.SameVolume"), asked.Detail);
+ Assert.True(asked is { IsDestructive: false, ActionText.Length: > 0, ActionToolTip.Length: > 0, SafeToolTip.Length: > 0 });
+ Assert.Equal(0, closes, "nothing closed before the plan is confirmed");
+ dialogs.Answer = true;
+ close = false;
+ Assert.False(await WorkspaceFolderChange.MoveAsync(host, dialogs, CloseProject, failures.Add));
+ Assert.False(host.IsMoving);
+
+ // Queued: until it ends the workspace opens, copies, syncs and changes folder no more, and is not moved twice.
+ close = true;
+ Assert.True(await WorkspaceFolderChange.MoveAsync(host, dialogs, CloseProject, failures.Add));
+ Assert.Empty(failures);
+ Assert.True(host.IsMoving);
+ var moving = Loc.L("Errors.Workspace.Moving");
+ Assert.Equal(moving, (await Assert.ThrowsAsync(() => host.FindAsync(mainId))).Message);
+ Assert.Equal(moving, (await Assert.ThrowsAsync(() => host.ProjectsOfAsync(bed.SequenceId))).Message);
+ Assert.Equal(moving, (await Assert.ThrowsAsync(() => host.SyncAsync(mainId))).Message);
+ Assert.Equal(moving, (await Assert.ThrowsAsync(() => host.QueueCopyAsync(mainId))).Message);
+ Assert.Equal(moving, (await Assert.ThrowsAsync(() => host.CheckoutAsync(bed.SequenceId, mainId, null))).Message);
+ Assert.Equal(moving, (await Assert.ThrowsAsync(() => host.UseFolderAsync(Path.Combine(bed.Directory, "elsewhere")))).Message);
+ Assert.False(await WorkspaceFolderChange.MoveAsync(host, dialogs, CloseProject, failures.Add));
+ Assert.SequenceEqual([moving], failures);
+ Assert.Equal(((string?)null, 0), (settings.WorkspaceFolder, moves.Saves), "the setting waits for the move");
+
+ await moves.Engine.StartAsync(context.Cancellation);
+ var job = Assert.NotNull((await moves.Db.Jobs.ListAsync(null, JobKind.WorkspaceMove, 5, cancellationToken: context.Cancellation)).Items.SingleOrDefault());
+ await moves.WaitAsync(job.Id, JobState.Done);
+ await WorkspaceTestBed.UntilAsync(() => !host.IsMoving, "the workspace is let go");
+
+ Assert.Equal((Path.GetFullPath(target), 1), (settings.WorkspaceFolder, moves.Saves));
+ Assert.Equal(Path.GetFullPath(target), host.Root);
+ Assert.Equal(mainId, Assert.NotNull(await host.FindAsync(mainId)).ProjectId);
+ Assert.Equal(mainId, (await host.ListAsync()).Single().ProjectId);
+ Assert.False(Directory.Exists(Path.Combine(from, mainId.ToString("N"))), "the project left the folder");
+ }
+
+ [Test]
+ public async Task AMoveThatFailsLeavesTheSettingAndTheWorkspaceWhereTheyWere()
+ {
+ await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 4);
+ var settings = new AppSettings();
+ var mainId = await bed.CheckoutAsync(bed.Host(settings));
+ await using var moves = await MovesAsync(bed, settings);
+ var host = moves.Host;
+ var from = host.Root;
+ var target = Path.Combine(bed.Directory, "target");
+
+ // A workspace job waiting refuses the plan.
+ var copy = await moves.Engine.EnqueueAsync(JobKind.WorkspaceCopy, [bed.SequenceId], "copy", null, cancellationToken: context.Cancellation);
+ Assert.Equal(Loc.L("Errors.Workspace.JobsRunning"), (await host.PlanMoveAsync(target)).Refusal);
+ await moves.Engine.CancelAsync(copy.Id, context.Cancellation);
+
+ var plan = await host.PlanMoveAsync(target);
+ await host.QueueMoveAsync(plan);
+ // Meanwhile the target became a workspace of its own: the job refuses it.
+ _ = new WorkspaceStore(target);
+ await moves.Engine.StartAsync(context.Cancellation);
+ var job = Assert.NotNull((await moves.Db.Jobs.ListAsync(null, JobKind.WorkspaceMove, 5, cancellationToken: context.Cancellation)).Items.SingleOrDefault());
+ var failed = await moves.WaitAsync(job.Id, JobState.Failed);
+ Assert.Equal(Loc.L("Errors.Workspace.MoveTargetNotEmpty", Path.GetFullPath(target)), failed.Error);
+ await WorkspaceTestBed.UntilAsync(() => !host.IsMoving, "the workspace is let go");
+
+ Assert.Equal(((string?)null, 0, from), (settings.WorkspaceFolder, moves.Saves, host.Root));
+ Assert.Equal(mainId, Assert.NotNull(await host.FindAsync(mainId)).ProjectId);
+ Assert.Empty(new WorkspaceStore(target).List());
+ }
+
+ [Test]
+ public async Task AMoveStoppedBeforeItEndedIsOfferedAgainAndGoesOn()
+ {
+ await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 4);
+ var settings = new AppSettings();
+ var mainId = await bed.CheckoutAsync(bed.Host(settings));
+ await using var moves = await MovesAsync(bed, settings);
+ var host = moves.Host;
+ var from = host.Root;
+ var target = Path.Combine(bed.Directory, "target");
+
+ // The program closed as the move began: its journal is in the folder, and no job waits for it.
+ var plan = await host.PlanMoveAsync(target);
+ using (var closed = new CancellationTokenSource())
+ {
+ await closed.CancelAsync();
+ await Assert.ThrowsAsync(() => new WorkspaceMover(from, target).MoveAsync(plan.Fingerprint, cancellationToken: closed.Token));
+ }
+ Assert.True(host.IsMoving, "a journal holds the workspace");
+ Assert.Equal(Loc.L("Errors.Workspace.Moving"), (await Assert.ThrowsAsync(() => host.FindAsync(mainId))).Message);
+ var journal = Assert.NotNull(await host.UnfinishedMoveAsync());
+ Assert.Equal((Path.GetFullPath(target), WorkspaceMoveStage.Moving), (journal.To, journal.Stage));
+
+ var job = await host.ResumeMoveAsync(journal);
+ Assert.Null(await host.UnfinishedMoveAsync());
+ await moves.Engine.StartAsync(context.Cancellation);
+ var done = await moves.WaitAsync(job.Id, JobState.Done);
+ Assert.Contains(Loc.L("Archive.Log.WorkspaceMoveResumed", Path.Combine(from, WorkspaceMover.JournalFile)), done.LogTail);
+ await WorkspaceTestBed.UntilAsync(() => !host.IsMoving, "the workspace is let go");
+ Assert.Equal(Path.GetFullPath(target), settings.WorkspaceFolder);
+ Assert.Equal(mainId, Assert.NotNull(await host.FindAsync(mainId)).ProjectId);
+ Assert.Null(await host.UnfinishedMoveAsync());
+ }
+
+ ///
+ /// A workspace over the bed's folder whose move jobs run on an engine of their own (over an index of their own, so the
+ /// bed's engine never takes them), which tells the workspace once a move ended; the engine is started by the test.
+ ///
+ private async Task MovesAsync(WorkspaceTestBed bed, AppSettings settings)
+ {
+ var db = await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(context.CreateTempDirectory("moves"), "index.db")), context.Cancellation);
+ var moves = new Moves(db);
+ var options = new WorkspaceJobOptions(WorkspaceJobOptions.For(bed.Archives).Processing, () => false, (f, t) => moves.Host.MovedAsync(f, t));
+ moves.Engine = new JobEngine(db, WorkspaceJobs.CreateHandlers(db, bed.Archives, null, options),
+ new JobEngineOptions { Workers = 1, WorkerId = "moves", PollInterval = TimeSpan.FromMilliseconds(50), CheckpointInterval = TimeSpan.FromMilliseconds(50) });
+ moves.Host = new WorkspaceHost(bed.Environment, settings, () => moves.Saves++, () => db, () => bed.Archives, () => moves.Engine)
+ {
+ LockWait = TimeSpan.FromSeconds(TestTiming.Budget(10)),
+ };
+ return moves;
+ }
+
+ private sealed class Moves(ChronosDatabase db) : IAsyncDisposable
+ {
+ public ChronosDatabase Db { get; } = db;
+ public JobEngine Engine { get; set; } = null!;
+ public WorkspaceHost Host { get; set; } = null!;
+ public int Saves { get; set; }
+
+ public async Task WaitAsync(Guid jobId, JobState expected)
+ {
+ var deadline = DateTime.UtcNow + TimeSpan.FromSeconds(TestTiming.Budget(60));
+ while (true)
+ {
+ var job = await Db.Jobs.GetAsync(jobId);
+ if (job is { State: JobState.Done or JobState.Failed or JobState.Cancelled })
+ {
+ Assert.Equal(expected, job.State, job.Error ?? job.LogTail);
+ return job;
+ }
+ if (DateTime.UtcNow > deadline) Assert.Fail($"Job {jobId} still {job?.State} after its time budget");
+ await Task.Delay(50);
+ }
+ }
+
+ public async ValueTask DisposeAsync()
+ {
+ await Engine.DisposeAsync();
+ await Db.DisposeAsync();
+ }
+ }
+
+ /// Dialogs that pick and answer every confirmation with , recording what they were asked.
+ private sealed class MoveDialogs : IAppDialogs
+ {
+ public string? Folder { get; set; }
+ public bool Answer { get; set; }
+ public List Asked { get; } = [];
+ public string? PickFolder(string title, string? initialFolder = null) => Folder;
+ public string? PickJsonFile(string title) => null;
+
+ public bool Confirm(ConfirmRequest request)
+ {
+ Asked.Add(request);
+ return Answer;
+ }
+
+ public bool SignIn(string server, string? username, Func> signIn) => false;
+ }
+}
diff --git a/tests/Chronos.Data.Tests/Workspaces/WorkspaceMoveTests.cs b/tests/Chronos.Data.Tests/Workspaces/WorkspaceMoveTests.cs
new file mode 100644
index 00000000..e3af0e07
--- /dev/null
+++ b/tests/Chronos.Data.Tests/Workspaces/WorkspaceMoveTests.cs
@@ -0,0 +1,392 @@
+using System.Globalization;
+using System.Security.Cryptography;
+using Chronos.Core.Localization;
+using Chronos.Core.Model;
+using Chronos.Data.Archiving;
+using Chronos.Data.Jobs;
+using Chronos.Data.Processing;
+using Chronos.Data.Workspaces;
+using Chronos.Testing;
+
+namespace Chronos.Data.Tests.Workspaces;
+
+///
+/// Moving the workspace folder with its projects (phase 5c, P6): renamed on one volume, copied and hash-verified across
+/// volumes (one disk told it is two), a damaged copy that never costs the source, a move stopped and taken up from its
+/// journal, the refusals of the plan, a failure undone, and the job that carries it out.
+///
+[Category("workspace")]
+public sealed class WorkspaceMoveTests(TestContext context)
+{
+ static WorkspaceMoveTests() => Loc.SetCulture(CultureInfo.GetCultureInfo("en"));
+
+ [Test]
+ public async Task OnOneVolumeEveryProjectIsRenamedAndTheDesktopToldOnce()
+ {
+ var (from, ids) = Workspace(projects: 2);
+ File.WriteAllText(Path.Combine(from, "notes.txt"), "the user's own");
+ var before = Contents(from);
+ var to = Path.Combine(context.CreateTempDirectory("target"), "moved");
+ var mover = new WorkspaceMover(from, to);
+ var survey = mover.Survey();
+ Assert.True(survey.CanMove, survey.RefusalText);
+ Assert.True(survey.SameVolume, "both folders lie in the test's own temporary folder");
+ Assert.SequenceEqual([.. ids.Select(i => i.ToString("N")).Order(StringComparer.Ordinal), WorkspaceStore.ManifestFile, ".trash"], survey.Entries);
+ Assert.Equal(before.Keys.Count(k => k != "notes.txt" && !IsLease(k)), survey.Files, "the leases and the user's file are not counted");
+ Assert.True(survey.Projects.All(p => p.IsProject));
+
+ var told = new List<(string, string)>();
+ var log = new List();
+ var (_, resumed) = await mover.MoveAsync(survey.Fingerprint, (f, t) =>
+ {
+ told.Add((f, t));
+ return Task.CompletedTask;
+ }, log: log.Add, cancellationToken: context.Cancellation);
+
+ Assert.False(resumed);
+ Assert.SequenceEqual([(mover.From, mover.To)], told);
+ // Everything of the workspace is at the target as it was, the lease with its project; the user's file stays.
+ var after = Contents(to);
+ foreach (var (name, sha) in before.Where(b => b.Key != "notes.txt")) Assert.Equal(sha, after.GetValueOrDefault(name), name);
+ Assert.SequenceEqual(["notes.txt"], Directory.EnumerateFileSystemEntries(from).Select(Path.GetFileName).ToList());
+ Assert.False(WorkspaceMover.HasJournal(from));
+ Assert.Contains(Loc.L("Archive.Log.WorkspaceMoved", mover.To, 2, survey.Files), log);
+ Assert.Equal(ids.Count, new WorkspaceStore(to).List().Count);
+ }
+
+ [Test]
+ public async Task AcrossVolumesEveryFileIsCopiedAndCheckedBeforeTheSourceGoes()
+ {
+ var (from, ids) = Workspace(projects: 3);
+ var before = Contents(from);
+ var times = File.GetLastWriteTimeUtc(Path.Combine(from, ids[0].ToString("N"), WorkspaceProject.BundleFile));
+ var to = Path.Combine(context.CreateTempDirectory("target"), "moved");
+ var atSwitch = (Source: new Dictionary(), Target: new Dictionary());
+ var mover = new WorkspaceMover(from, to)
+ {
+ SameVolume = false,
+ Cut = (step, _) =>
+ {
+ if (step != "switched") return;
+ atSwitch = (Contents(from), Contents(to));
+ },
+ };
+ var survey = mover.Survey();
+ Assert.False(survey.SameVolume);
+ var told = 0;
+ await mover.MoveAsync(survey.Fingerprint, (_, _) =>
+ {
+ told++;
+ // Told only once everything is at the target: the source is still whole.
+ Assert.Equal(before.Count, Contents(from).Count);
+ return Task.CompletedTask;
+ }, cancellationToken: context.Cancellation);
+
+ Assert.Equal(1, told);
+ // At the switch both sides held everything (the lease is the project holder's: not copied).
+ Assert.Equal(before.Count, atSwitch.Source.Count);
+ foreach (var (name, sha) in before.Where(b => !IsLease(b.Key))) Assert.Equal(sha, atSwitch.Target.GetValueOrDefault(name), name);
+ // Then the source went, the journal last, and the folder with them.
+ Assert.False(Directory.Exists(from));
+ Assert.Equal(times, File.GetLastWriteTimeUtc(Path.Combine(to, ids[0].ToString("N"), WorkspaceProject.BundleFile)), "the copy keeps the file's time");
+ Assert.Empty(Directory.EnumerateFiles(to, "*" + WorkspaceMover.PartSuffix, SearchOption.AllDirectories));
+ Assert.True(Directory.Exists(Path.Combine(to, ids[0].ToString("N"), "media", "empty")), "an empty folder comes along");
+ Assert.Equal(ids.Count, new WorkspaceStore(to).List().Count);
+ }
+
+ [Test]
+ public async Task ACopyThatDoesNotMatchItsSourceNeverCostsTheSource()
+ {
+ var (from, _) = Workspace(projects: 2);
+ var before = Contents(from);
+ var to = Path.Combine(context.CreateTempDirectory("target"), "moved");
+ var copies = 0;
+ var mover = new WorkspaceMover(from, to)
+ {
+ SameVolume = false,
+ Cut = (step, path) =>
+ {
+ // The fourth file is damaged on its way to the target disk.
+ if (step != "verify" || ++copies != 4) return;
+ var bytes = File.ReadAllBytes(path);
+ bytes[0] ^= 0xFF;
+ File.WriteAllBytes(path, bytes);
+ },
+ };
+ var told = 0;
+ var failed = await Assert.ThrowsAsync(() => mover.MoveAsync(mover.Survey().Fingerprint, (_, _) =>
+ {
+ told++;
+ return Task.CompletedTask;
+ }, cancellationToken: context.Cancellation));
+
+ Assert.True(failed.Message.StartsWith(Loc.L("Errors.Workspace.MoveVerify", "§").Split('§')[0], StringComparison.Ordinal), failed.Message);
+ Assert.Equal(0, told);
+ Same(before, Contents(from));
+ Assert.False(WorkspaceMover.HasJournal(from), "the move was undone");
+ Assert.False(Directory.Exists(to) && Directory.EnumerateFileSystemEntries(to).Any(), "no copy is left at the target");
+ }
+
+ [Test]
+ public async Task AMoveStoppedAcrossVolumesGoesOnFromItsJournalWithoutCopyingTwice()
+ {
+ var (from, _) = Workspace(projects: 3);
+ var before = Contents(from);
+ var to = Path.Combine(context.CreateTempDirectory("target"), "moved");
+ using var stop = CancellationTokenSource.CreateLinkedTokenSource(context.Cancellation);
+ var copied = 0;
+ var first = new WorkspaceMover(from, to)
+ {
+ SameVolume = false,
+ Cut = (step, _) =>
+ {
+ // The program closes after the fifth file reached the target.
+ if (step == "copied" && ++copied == 5) stop.Cancel();
+ },
+ };
+ var fingerprint = first.Survey().Fingerprint;
+ await Assert.ThrowsAsync(() => first.MoveAsync(fingerprint, cancellationToken: stop.Token));
+ Assert.True(WorkspaceMover.HasJournal(from), "the journal stays for the next run");
+ Same(before, Contents(from));
+ Assert.Equal(WorkspaceMoveStage.Moving, WorkspaceMover.ReadJournal(from)!.Stage);
+
+ // The workspace changed since (a lease taken and let go does not count): the move taken up does not ask the plan again.
+ var again = 0;
+ var second = new WorkspaceMover(from, to)
+ {
+ SameVolume = false,
+ Cut = (step, _) =>
+ {
+ if (step == "copied") again++;
+ },
+ };
+ var told = 0;
+ var log = new List();
+ var (_, resumed) = await second.MoveAsync("another plan", (_, _) =>
+ {
+ told++;
+ return Task.CompletedTask;
+ }, log: log.Add, cancellationToken: context.Cancellation);
+
+ Assert.True(resumed);
+ Assert.Equal(1, told);
+ var copiedFiles = before.Keys.Count(k => !IsLease(k));
+ Assert.Equal(copiedFiles - 5, again, "the files verified before the stop are not copied again");
+ Assert.True(log.Any(l => l.StartsWith(Loc.L("Archive.Log.WorkspaceMoveResumed", "§").Split('§')[0], StringComparison.Ordinal)), string.Join("; ", log));
+ var after = Contents(to);
+ foreach (var (name, sha) in before.Where(b => !IsLease(b.Key))) Assert.Equal(sha, after.GetValueOrDefault(name), name);
+ Assert.False(Directory.Exists(from));
+ }
+
+ [Test]
+ public async Task AMoveStoppedOnOneVolumeGoesOnFromItsJournal()
+ {
+ var (from, ids) = Workspace(projects: 3);
+ var before = Contents(from);
+ var to = Path.Combine(context.CreateTempDirectory("target"), "moved");
+ using var stop = CancellationTokenSource.CreateLinkedTokenSource(context.Cancellation);
+ var first = new WorkspaceMover(from, to)
+ {
+ SameVolume = true,
+ Cut = (step, _) =>
+ {
+ if (step == "moved") stop.Cancel();
+ },
+ };
+ await Assert.ThrowsAsync(() => first.MoveAsync(first.Survey().Fingerprint, cancellationToken: stop.Token));
+ Assert.True(WorkspaceMover.HasJournal(from));
+ Assert.True(Directory.Exists(Path.Combine(to, ids.Select(i => i.ToString("N")).Order(StringComparer.Ordinal).First())), "the first project went");
+
+ var (_, resumed) = await new WorkspaceMover(from, to) { SameVolume = true }.MoveAsync("whatever", cancellationToken: context.Cancellation);
+ Assert.True(resumed);
+ Same(before, Contents(to));
+ Assert.False(Directory.Exists(from));
+ }
+
+ [Test]
+ public async Task AMoveThatFailsOnOneVolumeIsUndone()
+ {
+ var (from, _) = Workspace(projects: 3);
+ var before = Contents(from);
+ var to = Path.Combine(context.CreateTempDirectory("target"), "moved");
+ var moved = 0;
+ var mover = new WorkspaceMover(from, to)
+ {
+ SameVolume = true,
+ Cut = (step, _) =>
+ {
+ // The second project's rename meets a file someone holds open.
+ if (step == "moved" && ++moved == 2) throw new IOException("The file is in use.");
+ },
+ };
+ await Assert.ThrowsAsync(() => mover.MoveAsync(mover.Survey().Fingerprint, cancellationToken: context.Cancellation));
+
+ Same(before, Contents(from));
+ Assert.False(WorkspaceMover.HasJournal(from));
+ Assert.False(Directory.Exists(to), "the target made for the move went with it");
+ }
+
+ [Test]
+ public async Task APlanIsRefusedForTheFolderItselfAFullTargetNoRoomAndAChangedWorkspace()
+ {
+ var (from, ids) = Workspace(projects: 1);
+ Assert.Equal(WorkspaceMoveRefusal.SameFolder, new WorkspaceMover(from, from + Path.DirectorySeparatorChar).Survey().Refusal);
+ var inside = Path.Combine(from, "inner");
+ var refused = new WorkspaceMover(from, inside).Survey();
+ Assert.Equal(WorkspaceMoveRefusal.SameFolder, refused.Refusal);
+ Assert.Equal(Loc.L("Errors.Workspace.MoveSameFolder", refused.To), refused.RefusalText);
+
+ // A target that is a workspace already, or holds a project of this one.
+ var other = context.CreateTempDirectory("other");
+ _ = new WorkspaceStore(other);
+ Assert.Equal(WorkspaceMoveRefusal.TargetNotEmpty, new WorkspaceMover(from, other).Survey().Refusal);
+ var holding = context.CreateTempDirectory("holding");
+ Directory.CreateDirectory(Path.Combine(holding, ids[0].ToString("N")));
+ var full = new WorkspaceMover(from, holding).Survey();
+ Assert.Equal(Loc.L("Errors.Workspace.MoveTargetNotEmpty", full.To), full.RefusalText);
+ // Unrelated files do not refuse it.
+ var used = context.CreateTempDirectory("used");
+ File.WriteAllText(Path.Combine(used, "readme.txt"), "x");
+ Assert.True(new WorkspaceMover(from, used).Survey().CanMove);
+
+ // Across volumes the target's drive must hold the workspace and the reserve; a rename needs no room.
+ var small = new WorkspaceMover(from, Path.Combine(used, "w")) { SameVolume = false, FreeSpace = _ => 1000, Reserve = 0 }.Survey();
+ Assert.Equal((WorkspaceMoveRefusal?)WorkspaceMoveRefusal.NoRoom, small.Refusal);
+ Assert.Equal(small.Bytes - 1000, small.Missing);
+ Assert.True(new WorkspaceMover(from, Path.Combine(used, "w")) { SameVolume = true, FreeSpace = _ => 1000 }.Survey().CanMove);
+
+ // A file written after the plan: the move refuses it and touches nothing.
+ var to = Path.Combine(used, "moved");
+ var mover = new WorkspaceMover(from, to);
+ var fingerprint = mover.Survey().Fingerprint;
+ Assert.Equal(fingerprint, mover.Survey().Fingerprint, "the plan reads the same twice");
+ File.WriteAllText(Path.Combine(from, ids[0].ToString("N"), "versions", "late.json"), "{}");
+ var changed = await Assert.ThrowsAsync(() => mover.MoveAsync(fingerprint, cancellationToken: context.Cancellation));
+ Assert.Equal(Loc.L("Errors.Workspace.MoveChanged"), changed.Message);
+ Assert.False(Directory.Exists(to));
+ Assert.False(WorkspaceMover.HasJournal(from));
+ }
+
+ [Test]
+ public async Task TheJobMovesTheWorkspaceAndTellsTheDesktop()
+ {
+ var (from, ids) = Workspace(projects: 2);
+ var before = Contents(from);
+ var to = Path.Combine(context.CreateTempDirectory("target"), "moved");
+ await using var db = await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(context.CreateTempDirectory("db"), "chronos.db")), context.Cancellation);
+ var told = new List<(string, string)>();
+ var options = new WorkspaceJobOptions(new ProcessingOptions(), () => false, (f, t) =>
+ {
+ told.Add((f, t));
+ return Task.CompletedTask;
+ });
+ var handler = new WorkspaceMoveJobHandler(db, options) { Movers = p => new WorkspaceMover(p.From, p.To) { SameVolume = false } };
+ await using var engine = new JobEngine(db, [handler],
+ new JobEngineOptions { Workers = 1, WorkerId = "test", PollInterval = TimeSpan.FromMilliseconds(50), CheckpointInterval = TimeSpan.FromMilliseconds(50) });
+
+ // Another job of the workspace waits (nothing here runs it): the move is refused.
+ var copy = await engine.EnqueueAsync(JobKind.WorkspaceCopy, [Guid.CreateVersion7()], "copy", null, cancellationToken: context.Cancellation);
+ var survey = new WorkspaceMover(from, to).Survey();
+ await engine.StartAsync(context.Cancellation);
+ var refused = await engine.EnqueueAsync(WorkspaceJobs.Move(from, to, survey.Fingerprint), cancellationToken: context.Cancellation);
+ var failed = await WaitAsync(db, refused.Id);
+ Assert.Equal(JobState.Failed, failed.State);
+ Assert.Equal(Loc.L("Errors.Workspace.JobsRunning"), failed.Error);
+ Same(before, Contents(from));
+
+ await engine.CancelAsync(copy.Id, context.Cancellation);
+ var job = await engine.EnqueueAsync(WorkspaceJobs.Move(from, to, survey.Fingerprint), cancellationToken: context.Cancellation);
+ var done = await WaitAsync(db, job.Id);
+ Assert.Equal(JobState.Done, done.State, done.Error ?? done.LogTail);
+ Assert.SequenceEqual([(survey.From, survey.To)], told);
+ Assert.Equal(ids.Count, new WorkspaceStore(to).List().Count);
+ Assert.False(Directory.Exists(from));
+ Assert.Contains(Loc.L("Archive.Log.WorkspaceMoved", survey.To, 2, survey.Files), done.LogTail);
+ }
+
+ [Test]
+ public async Task AMoveCancelledWhilePausedIsUndone()
+ {
+ var (from, _) = Workspace(projects: 2);
+ var before = Contents(from);
+ var to = Path.Combine(context.CreateTempDirectory("target"), "moved");
+ // A move stopped half way, as a pause leaves it.
+ using var stop = CancellationTokenSource.CreateLinkedTokenSource(context.Cancellation);
+ var mover = new WorkspaceMover(from, to) { SameVolume = true, Cut = (step, _) => stop.Cancel() };
+ var fingerprint = mover.Survey().Fingerprint;
+ await Assert.ThrowsAsync(() => mover.MoveAsync(fingerprint, cancellationToken: stop.Token));
+ Assert.NotEqual(before.Count, Contents(from).Count);
+
+ await using var db = await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(context.CreateTempDirectory("db"), "chronos.db")), context.Cancellation);
+ var handler = new WorkspaceMoveJobHandler(db, new WorkspaceJobOptions(new ProcessingOptions(), () => false))
+ {
+ Movers = p => new WorkspaceMover(p.From, p.To) { SameVolume = true },
+ };
+ var request = WorkspaceJobs.Move(from, to, fingerprint);
+ await using var engine = new JobEngine(db, [handler]);
+ var job = await engine.EnqueueAsync(request, cancellationToken: context.Cancellation) with { State = JobState.Cancelled };
+ await handler.CancelledAsync(job, context.Cancellation);
+ var deadline = DateTime.UtcNow + TimeSpan.FromSeconds(TestTiming.Budget(20));
+ while (WorkspaceMover.HasJournal(from) && DateTime.UtcNow < deadline) await Task.Delay(20, context.Cancellation);
+
+ Assert.False(WorkspaceMover.HasJournal(from));
+ Same(before, Contents(from));
+ Assert.False(Directory.Exists(to));
+ }
+
+ ///
+ /// A workspace with projects (a working state, media with an empty folder, versions, the
+ /// lease), its manifest and a trash entry.
+ ///
+ private (string Root, List Ids) Workspace(int projects)
+ {
+ var root = Path.Combine(context.CreateTempDirectory("ws"), "workspace");
+ _ = new WorkspaceStore(root);
+ var ids = new List();
+ for (var i = 0; i < projects; i++)
+ {
+ var id = Guid.CreateVersion7();
+ ids.Add(id);
+ var folder = Path.Combine(root, id.ToString("N"));
+ Directory.CreateDirectory(Path.Combine(folder, "media", "proxies"));
+ Directory.CreateDirectory(Path.Combine(folder, "media", "empty"));
+ Directory.CreateDirectory(Path.Combine(folder, "versions"));
+ File.WriteAllText(Path.Combine(folder, WorkspaceProject.BundleFile), "{\"project\": " + i + "}");
+ for (var f = 0; f < 3; f++) File.WriteAllBytes(Path.Combine(folder, "media", "proxies", $"{f}.jpg"), RandomNumberGenerator.GetBytes(4096 + f * 1000));
+ File.WriteAllText(Path.Combine(folder, "versions", "0001.json"), "{}");
+ File.WriteAllText(Path.Combine(folder, ".lock.lease"), "held by nobody");
+ }
+ var trash = Path.Combine(root, ".trash", "removed-1");
+ Directory.CreateDirectory(trash);
+ File.WriteAllText(Path.Combine(trash, "kept.json"), "{}");
+ return (root, ids);
+ }
+
+ /// Every file under by its relative name, with its SHA-256; a move's journal is not counted.
+ private static Dictionary Contents(string root) =>
+ Directory.Exists(root)
+ ? Directory.EnumerateFiles(root, "*", SearchOption.AllDirectories).Where(f => Path.GetFileName(f) != WorkspaceMover.JournalFile)
+ .ToDictionary(f => Path.GetRelativePath(root, f).Replace('\\', '/'), f => Convert.ToHexStringLower(SHA256.HashData(File.ReadAllBytes(f))))
+ : [];
+
+ /// Both hold the same files with the same contents.
+ private static void Same(Dictionary expected, Dictionary actual)
+ {
+ Assert.SequenceEqual(expected.Keys.Order(StringComparer.Ordinal), actual.Keys.Order(StringComparer.Ordinal));
+ foreach (var (name, sha) in expected) Assert.Equal(sha, actual[name], name);
+ }
+
+ private static bool IsLease(string name) => name.EndsWith(".lease", StringComparison.Ordinal);
+
+ private async Task WaitAsync(ChronosDatabase db, Guid jobId)
+ {
+ var deadline = DateTime.UtcNow + TimeSpan.FromSeconds(TestTiming.Budget(60));
+ while (true)
+ {
+ var job = await db.Jobs.GetAsync(jobId, context.Cancellation);
+ if (job is { State: JobState.Done or JobState.Failed or JobState.Cancelled }) return job;
+ if (DateTime.UtcNow > deadline) Assert.Fail($"Job {jobId} still {job?.State}");
+ await Task.Delay(20, context.Cancellation);
+ }
+ }
+}