diff --git a/src/Chronos.App/Editor/LocalSequenceSource.cs b/src/Chronos.App/Editor/LocalSequenceSource.cs
index 77abdcb7..aaa07f4b 100644
--- a/src/Chronos.App/Editor/LocalSequenceSource.cs
+++ b/src/Chronos.App/Editor/LocalSequenceSource.cs
@@ -179,8 +179,9 @@ public sealed class LocalSequenceSource : ISequenceSource
// it too: moved since the read, the project goes to the new folder once the editor read the sequence there,
// and the folder it left is never created again.
if (row.FramesVersion != framesVersion || row.Folder != relativeFolder) throw new FramesChangedException(Loc.L("Editor.Error.FramesArriving"));
- // Moved by another index of the archive (a server's Reorganize), which this index finds at its next scan.
- if (!Directory.Exists(folder.Folder)) throw Missing();
+ // Moved by another index of the archive (a server's Reorganize), which this index finds at its next scan; the folder
+ // it left may hold another sequence that index moved into it since.
+ if (!SequenceFolders.Holds(folder, _sequenceId)) throw Missing();
var stored = ReadProject(row, folder);
var merged = ProjectMerge.SameValues(stored, basis) ? project : ProjectMerge.Merge(basis, project, stored);
var json = merged.ToJson();
diff --git a/src/Chronos.Data/Archiving/ArchiveImages.cs b/src/Chronos.Data/Archiving/ArchiveImages.cs
index e9c7d6f9..9587ce05 100644
--- a/src/Chronos.Data/Archiving/ArchiveImages.cs
+++ b/src/Chronos.Data/Archiving/ArchiveImages.cs
@@ -168,7 +168,8 @@ public sealed class ArchiveImages
/// frame's (proxies carry it, so the proxy counts as current and cannot belong to another photo) and whose size is
/// the policy's (), written atomically under the sequence's lease into its folder as the index has
/// it then: a Reorganize moves the folder under that lease, and the folder it left is never created again (one another
- /// index moved, which this index finds at its next scan, takes nothing: ).
+ /// index moved, which this index finds at its next scan, takes nothing, nor does that folder when it holds another
+ /// sequence now: ).
///
/// The archive is offline or read-only.
/// Another writer held the sequence for longer than the lease wait.
@@ -191,7 +192,7 @@ public sealed class ArchiveImages
{
if (await _db.Sequences.GetAsync(sequence.Id, cancellationToken).ConfigureAwait(false) is not { } row) return ProxyStoreResult.Gone;
var folder = paths.Sequence(row.Folder);
- if (!Directory.Exists(folder.Folder)) return ProxyStoreResult.Gone;
+ if (!SequenceFolders.Holds(folder, row.Id)) return ProxyStoreResult.Gone;
Directory.CreateDirectory(folder.Proxies);
var path = folder.Proxy(frame.Index);
AtomicFile.WriteAllBytes(path, jpeg);
@@ -226,6 +227,8 @@ public sealed class ArchiveImages
{
var folder = await SequenceWriter.FolderAsync(_db, paths, sequence, cancellationToken).ConfigureAwait(false);
manifest = ManifestStore.ReadSequence(folder.ManifestPath);
+ // Another sequence's folder now (another index moved this one away and that one in): its pack is never opened.
+ if (manifest.Id != sequence.Id) throw new InvalidOperationException(Loc.L("Errors.Archive.FolderMoved"));
var companions = await GprCompanions.FindAsync(_db, archive, manifest.Frames, cancellationToken).ConfigureAwait(false);
using var pack = ThumbPackWriter.Open(folder.ThumbsPackPath);
for (var i = 0; i < startFrame && i < manifest.Frames.Count; i++)
@@ -298,8 +301,8 @@ public sealed class ArchiveImages
/// originals are decoded at once (), and a checkpoint still means that every frame before
/// it has its proxy written (). The pass works in batches (), each
/// under the thumbnail lease with the sequence's folder and sidecar read again; a folder that is not where the index
- /// has it (another index moved it, until this index's next scan) stops the pass with an
- /// , nothing written there.
+ /// has it (another index moved it, until this index's next scan), or that holds another sequence now, stops the pass
+ /// with an , nothing written there.
///
public async Task BuildProxiesAsync(Archive archive, Sequence sequence, bool force, int startFrame,
Func checkpoint, CancellationToken cancellationToken = default)
@@ -324,7 +327,7 @@ public sealed class ArchiveImages
_writer.Options.LeaseDuration, cancellationToken).ConfigureAwait(false))
{
var folder = await SequenceWriter.FolderAsync(_db, paths, sequence, cancellationToken).ConfigureAwait(false);
- if (!Directory.Exists(folder.Folder)) throw new InvalidOperationException(Loc.L("Errors.Archive.FolderMoved"));
+ if (!SequenceFolders.Holds(folder, sequence.Id)) throw new InvalidOperationException(Loc.L("Errors.Archive.FolderMoved"));
var read = ManifestStore.ReadSequence(folder.ManifestPath);
// Photos added, removed or renumbered since the last batch: what the earlier batches made may not be theirs.
if (manifest is not null && !SameFrames(read.Frames, manifest.Frames, names: false)) complete = false;
diff --git a/src/Chronos.Data/Archiving/ArchiveIndexer.cs b/src/Chronos.Data/Archiving/ArchiveIndexer.cs
index 845920b6..b85b400c 100644
--- a/src/Chronos.Data/Archiving/ArchiveIndexer.cs
+++ b/src/Chronos.Data/Archiving/ArchiveIndexer.cs
@@ -188,33 +188,32 @@ public sealed class ArchiveIndexer
///
/// The render rows of the archive that follow a sequence's folder from to ,
/// in the caller's transaction (). An export is a file, or
- /// a folder for an image sequence. It is at its old path still when it is there, the new path is not the same one (on a
- /// file system that ignores case it is, when only the case changed) and the old folder holds no other sequence now. The
- /// sequence's own exports inside the folder follow unless they are at the old path still and not at the new one:
- /// written there after the move by a writer that read the old folder, which created it again, so the row keeps naming
- /// where the export is. Another sequence's export follows only when it moved with the folder (at its new path and no
- /// longer at the old one). An export missing from both places follows if it is the sequence's own, and so does one whose
- /// old path is another sequence's: a sequence that moved into the old folder since brought an export of that name.
+ /// a folder for an image sequence. It is at its old path still when it is there and the new path is not the same one
+ /// (on a file system that ignores case it is, when only the case changed). The sequence's own exports inside the folder
+ /// follow unless they are at the old path still and not at the new one: written there after the move by a writer that
+ /// read the old folder, which created it again, so the row keeps naming where the export is. An export of its own
+ /// missing from both places follows, and so does one at its old path when the old folder holds another sequence now:
+ /// that sequence moved into it since and brought an export of that name. Another sequence's export follows only when it
+ /// moved with the folder (at its new path and no longer at the old one), and an export of the sequence the old folder
+ /// holds now never does: that one is in its own folder, whatever the moving sequence took along under the same name.
///
internal static Task RebaseRendersAsync(ChronosRepositories tx, Archive archive, Guid sequenceId, string from, string to,
CancellationToken cancellationToken)
{
var paths = new ArchivePaths(archive.RootPath);
- // Read once, and only for an export found at its old path.
- bool? taken = null;
- return tx.Renders.RebaseFolderAsync(archive.Id, sequenceId, from, to, (before, after, own) =>
+ // The sequence the old folder holds now, when another one: read once, and only when a row asks.
+ var holder = new Lazy(() => SequenceFolders.OtherSequence(paths.Sequence(from), sequenceId), LazyThreadSafetyMode.None);
+ return tx.Renders.RebaseFolderAsync(archive.Id, sequenceId, from, to, (before, after, owner) =>
{
+ var own = owner == sequenceId;
+ if (!own && owner == holder.Value) return false;
var moved = Path.Exists(paths.FromRelative(after));
var behind = !string.Equals(before, after, StringComparison.OrdinalIgnoreCase) && Path.Exists(paths.FromRelative(before))
- && !(taken ??= TakenByAnother(paths.Sequence(from), sequenceId));
+ && !(own && holder.Value is not null);
return own ? moved || !behind : moved && !behind;
}, cancellationToken);
}
- /// Whether is another sequence's now: its sidecar names another id.
- private static bool TakenByAnother(SequencePaths folder, Guid sequenceId) =>
- File.Exists(folder.ManifestPath) && SequenceTrash.SidecarId(folder.ManifestPath) is { } id && id != sequenceId;
-
///
/// Remembers the current stamps of a folder whose sidecar and index were just updated together, so the next
/// incremental scan does not re-read what is already indexed.
diff --git a/src/Chronos.Data/Archiving/SequenceFolders.cs b/src/Chronos.Data/Archiving/SequenceFolders.cs
new file mode 100644
index 00000000..8a19d312
--- /dev/null
+++ b/src/Chronos.Data/Archiving/SequenceFolders.cs
@@ -0,0 +1,24 @@
+using Chronos.Core.Archiving;
+
+namespace Chronos.Data.Archiving;
+
+/// Whether a sequence is in the folder the index has for it, as writers that file into that folder ask.
+public static class SequenceFolders
+{
+ ///
+ /// Whether , the one the index has for sequence , holds it: the
+ /// folder is there and its sidecar, when it has one, names no other sequence. Another index of the archive that moved
+ /// the sequence away may have moved another one into the folder it left since; until this index's next scan finds both,
+ /// a writer of the sequence files nothing there, exactly as when the folder is missing, so none of its writes lands in
+ /// the other sequence's folder.
+ ///
+ public static bool Holds(SequencePaths folder, Guid sequenceId)
+ {
+ ArgumentNullException.ThrowIfNull(folder);
+ return Directory.Exists(folder.Folder) && OtherSequence(folder, sequenceId) is null;
+ }
+
+ /// The sequence other than whose sidecar holds; null when none does.
+ internal static Guid? OtherSequence(SequencePaths folder, Guid sequenceId) =>
+ File.Exists(folder.ManifestPath) && SequenceTrash.SidecarId(folder.ManifestPath) is { } id && id != sequenceId ? id : null;
+}
diff --git a/src/Chronos.Data/Processing/Jobs/RenderJobHandler.cs b/src/Chronos.Data/Processing/Jobs/RenderJobHandler.cs
index bfa63e57..3f7ce48a 100644
--- a/src/Chronos.Data/Processing/Jobs/RenderJobHandler.cs
+++ b/src/Chronos.Data/Processing/Jobs/RenderJobHandler.cs
@@ -22,7 +22,8 @@ namespace Chronos.Data.Processing.Jobs;
/// output is recorded at once (its row id derives from the job and the entry, so every attempt knows what is recorded).
/// Checkpoint: the entries recorded and the output being written, so a crashed attempt's leftovers are removed and only
/// unfinished entries render again. A failed entry fails the job after the others ran; retrying renders it alone. A
-/// sequence whose folder is not where the index has it (another index moved it, until this index's next scan) is refused.
+/// sequence whose folder is not where the index has it (another index moved it, until this index's next scan; the folder
+/// it left may hold another sequence now) is refused.
///
internal sealed class RenderJobHandler(ChronosDatabase db, ProcessingOptions options, FrameTiers tiers) : IJobHandler
{
@@ -42,8 +43,8 @@ internal sealed class RenderJobHandler(ChronosDatabase db, ProcessingOptions opt
ArchiveVolume.EnsureWritable(paths);
var folder = paths.Sequence(sequence.Folder);
// A folder another index moved is found by this index's next scan. Until then nothing renders: its photos would all be
- // stand-ins, and its outputs would create the old folder again.
- if (!Directory.Exists(folder.Folder)) throw new InvalidOperationException(Loc.L("Errors.Archive.FolderMoved"));
+ // stand-ins, and its outputs would create the old folder again, or land among the exports of a sequence moved into it.
+ if (!SequenceFolders.Holds(folder, sequence.Id)) throw new InvalidOperationException(Loc.L("Errors.Archive.FolderMoved"));
// A server writes only inside its archive (BRIEF ยง14.2): an export folder chosen on a client means nothing there.
if (options.Host == EncoderHost.Server) export = export with { Folder = null };
var project = (parameters.SettingsJson is { } embedded ? ProjectStore.Parse(embedded) : ProjectStore.Read(sequence, folder)) with { Export = export };
diff --git a/src/Chronos.Data/Processing/SequenceAnalyser.cs b/src/Chronos.Data/Processing/SequenceAnalyser.cs
index 45451e87..d6720e82 100644
--- a/src/Chronos.Data/Processing/SequenceAnalyser.cs
+++ b/src/Chronos.Data/Processing/SequenceAnalyser.cs
@@ -359,14 +359,15 @@ internal sealed class SequenceAnalyser(ChronosDatabase db, ProcessingOptions opt
}
///
- /// The sequence lock, taken while , where the pass reads the frames, is still there: a
- /// Reorganize, of this process or another sharing the archive, moves the folder under that lock's lease.
+ /// The sequence lock, taken while , where the pass reads the frames, still holds the sequence: a
+ /// Reorganize, of this process or another sharing the archive, moves the folder under that lock's lease, and another one
+ /// may move another sequence into the folder it left.
///
/// The folder moved since the pass read the sequence.
private async Task InPlaceAsync(ArchivePaths paths, Sequence sequence, SequencePaths folder, CancellationToken cancellationToken)
{
var held = await writer.LockAsync(paths, sequence.Id, cancellationToken).ConfigureAwait(false);
- if (Directory.Exists(folder.Folder)) return held;
+ if (SequenceFolders.Holds(folder, sequence.Id)) return held;
await held.DisposeAsync().ConfigureAwait(false);
throw new FolderMovedException();
}
diff --git a/src/Chronos.Data/Repositories/RenderRepository.cs b/src/Chronos.Data/Repositories/RenderRepository.cs
index 40bf460e..8d427c29 100644
--- a/src/Chronos.Data/Repositories/RenderRepository.cs
+++ b/src/Chronos.Data/Repositories/RenderRepository.cs
@@ -57,9 +57,9 @@ public sealed class RenderRepository
/// into the old folder. Outputs elsewhere (absolute paths, other folders) stay as they are.
///
/// Whether the render at the first archive-relative path follows to the second one; the third
- /// argument says whether it is one of the sequence's own.
+ /// argument is the sequence it is an export of.
/// Only paths still under change, so repeating it after a crash is harmless.
- public async Task RebaseFolderAsync(Guid archiveId, Guid sequenceId, string oldFolder, string newFolder, Func follows,
+ public async Task RebaseFolderAsync(Guid archiveId, Guid sequenceId, string oldFolder, string newFolder, Func follows,
CancellationToken cancellationToken = default)
{
ArgumentNullException.ThrowIfNull(follows);
@@ -75,9 +75,8 @@ public sealed class RenderRepository
foreach (var (id, owner, path) in under)
{
var to = newFolder.Length == 0 ? path[prefix.Length..] : newFolder + path[oldFolder.Length..];
- var own = owner == sequenceId;
- var taken = own && under.Any(o => o.SequenceId != sequenceId && string.Equals(o.Path, path, StringComparison.Ordinal));
- if (!taken && !follows(path, to, own)) continue;
+ var taken = owner == sequenceId && under.Any(o => o.SequenceId != sequenceId && string.Equals(o.Path, path, StringComparison.Ordinal));
+ if (!taken && !follows(path, to, owner)) continue;
rebased += await _db.ExecuteAsync("UPDATE renders SET output_path = $2 WHERE id = $1", [id, to], cancellationToken).ConfigureAwait(false);
}
return rebased;
diff --git a/src/Chronos.Data/Sync/SyncService.cs b/src/Chronos.Data/Sync/SyncService.cs
index 8ff1ab76..21ff2c02 100644
--- a/src/Chronos.Data/Sync/SyncService.cs
+++ b/src/Chronos.Data/Sync/SyncService.cs
@@ -754,9 +754,10 @@ public sealed class SyncService
if (await positions.ToLocalAsync(payload.SettingsJson, local.SettingsVersion, cancellationToken).ConfigureAwait(false) is not { } current) return null;
var row = current.Local;
// The folder too: a Reorganize moves it and its row under this lease. One another index moved is found by the next
- // scan; nothing is written until then, so the folder it left is not created again.
+ // scan; nothing is written until then, so the folder it left is not created again, nor written in when it holds
+ // another sequence now.
var folder = paths.Sequence(row.Folder);
- if (!Directory.Exists(folder.Folder)) return null;
+ if (!SequenceFolders.Holds(folder, row.Id)) return null;
payload = payload with { SettingsJson = current.SettingsJson };
var metadata = !payload.SameMetadata(SyncPayload.Of(row));
var settings = !SyncRules.SameSettings(payload.SettingsJson, row.SettingsJson);
@@ -808,7 +809,8 @@ public sealed class SyncService
/// "Save both": this PC's project is kept next to project.json as project.this-pc-<local time>.json
/// before the server's replaces it; returns that file. Written under the sequence's lease into its folder as the index
/// has it then: a Reorganize may have moved it while the server was asked, and the folder it left is never created again.
- /// Null, with nothing written, when the sequence is not in that folder (another index moved it; the next scan finds it).
+ /// Null, with nothing written, when the sequence is not in that folder (another index moved it, and maybe another
+ /// sequence into it; the next scan finds them, ).
///
private async Task SaveCopyAsync(Sequence local, CancellationToken cancellationToken)
{
@@ -820,7 +822,7 @@ public sealed class SyncService
await using (await _writer.LockAsync(paths, local.Id, cancellationToken).ConfigureAwait(false))
{
var folder = await SequenceWriter.FolderAsync(_db, paths, local, cancellationToken).ConfigureAwait(false);
- if (!Directory.Exists(folder.Folder)) return null;
+ if (!SequenceFolders.Holds(folder, local.Id)) return null;
Directory.CreateDirectory(folder.MetaDirectory);
path = Path.Combine(folder.MetaDirectory, SavedCopyName(DateTime.Now));
AtomicFile.WriteAllText(path, SyncRules.NormalizeSettings(local.SettingsJson));
@@ -831,7 +833,8 @@ public sealed class SyncService
///
/// Whether the sequence is not in the folder the index has for it now, on an archive that is there: another index moved
- /// it, and this index's next scan finds it. Read without the lease, to tell why a resolution wrote nothing.
+ /// it (and maybe another sequence into that folder), and this index's next scan finds it. Read without the lease, to
+ /// tell why a resolution wrote nothing.
///
private async Task FolderMovedAsync(Sequence local, CancellationToken cancellationToken)
{
@@ -839,13 +842,14 @@ public sealed class SyncService
|| await _db.Archives.GetAsync(row.ArchiveId, cancellationToken).ConfigureAwait(false) is not { } archive)
return false;
var paths = new ArchivePaths(archive.RootPath);
- return Directory.Exists(paths.Root) && !Directory.Exists(paths.Sequence(row.Folder).Folder);
+ return Directory.Exists(paths.Root) && !SequenceFolders.Holds(paths.Sequence(row.Folder), row.Id);
}
///
/// Deletes a "Save both" copy of a version the user did not keep from the sequence's folder as the index has it now: a
/// Reorganize may have moved the folder, the copy with it, since the copy was written. Best effort: a copy that cannot
- /// be reached (the folder gone, the sequence busy, the archive offline) stays, as one more copy of this PC's version.
+ /// be reached (the folder gone or another sequence's now, the sequence busy, the archive offline) stays, as one more
+ /// copy of this PC's version.
///
private async Task DeleteCopyAsync(Sequence local, string saved, CancellationToken cancellationToken)
{
@@ -857,7 +861,8 @@ public sealed class SyncService
await using (await _writer.LockAsync(paths, local.Id, cancellationToken).ConfigureAwait(false))
{
var folder = await SequenceWriter.FolderAsync(_db, paths, local, cancellationToken).ConfigureAwait(false);
- if (Directory.Exists(folder.MetaDirectory)) File.Delete(Path.Combine(folder.MetaDirectory, Path.GetFileName(saved)));
+ if (SequenceFolders.Holds(folder, local.Id) && Directory.Exists(folder.MetaDirectory))
+ File.Delete(Path.Combine(folder.MetaDirectory, Path.GetFileName(saved)));
}
}
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException)
diff --git a/src/Chronos.Data/Sync/SyncTransfers.cs b/src/Chronos.Data/Sync/SyncTransfers.cs
index 5b60780d..99e7c9a4 100644
--- a/src/Chronos.Data/Sync/SyncTransfers.cs
+++ b/src/Chronos.Data/Sync/SyncTransfers.cs
@@ -379,12 +379,13 @@ internal sealed class SyncTransfers(SyncService sync)
// Filed under the sequence's lease into its folder as the index has it then, as a server files a render: a
// Reorganize may have moved it since the sequence was read, and moves the row's path along when it moves it later.
// One another index moved is found by this index's next scan; until then nothing is filed (the download stays
- // staged for the next attempt), so the folder it left is not created again.
+ // staged for the next attempt), so the folder it left is not created again, nor filed into when it holds another
+ // sequence now.
var filed = await sync.Archives.UnderLeaseAsync(local, async row =>
{
if (row is null) throw new InvalidOperationException(Loc.L("Errors.Sync.LocalMissing"));
var folder = paths.Sequence(row.Folder);
- if (!Directory.Exists(folder.Folder)) return false;
+ if (!SequenceFolders.Holds(folder, row.Id)) return false;
Directory.CreateDirectory(folder.Exports);
var target = Unique(folder.Exports, name);
File.Move(part, target);
diff --git a/src/Chronos.Server/Storage/RenderStore.cs b/src/Chronos.Server/Storage/RenderStore.cs
index 6fb03fa5..d5a7aed1 100644
--- a/src/Chronos.Server/Storage/RenderStore.cs
+++ b/src/Chronos.Server/Storage/RenderStore.cs
@@ -1,3 +1,4 @@
+using Chronos.Core.Archiving;
using Chronos.Core.IO;
using Chronos.Core.Localization;
using Chronos.Core.Model;
@@ -20,8 +21,9 @@ public sealed class RenderStore(ChronosDatabase db, ServerArchive archive, TimeP
/// path along when it moves it later. Null when the sequence left the index or has no folder in the archive yet; nothing
/// is moved then.
///
- /// The sequence is not in the folder the index has (another index moved it):
- /// nothing is moved, and the filing can be done again once this index's next scan found the folder.
+ /// The sequence is not in the folder the index has (another index moved it, and
+ /// maybe another sequence into that folder): nothing is moved, and the filing can be done again once this index's next
+ /// scan found the folder.
public Task CommitAsync(Sequence sequence, string stagedFile, RenderResultRequest output, string producedBy, CancellationToken cancellationToken) =>
CommitAsync(sequence, stagedFile, output, producedBy, Guid.CreateVersion7(), cancellationToken);
@@ -33,8 +35,9 @@ public sealed class RenderStore(ChronosDatabase db, ServerArchive archive, TimeP
{
if (row is null || string.IsNullOrEmpty(row.Folder) || ArchivePathGuard.Resolve(archive.Root, row.Folder.TrimEnd('/') + "/exports") is not { } exports)
return null;
- // A folder another index moved is found by this index's next scan; until then nothing is filed, so it is not created again.
- if (!Directory.Exists(Path.GetDirectoryName(exports))) throw new FolderMovedException();
+ // A folder another index moved is found by this index's next scan; until then nothing is filed, so it is not created
+ // again, nor filed among the exports of another sequence that index moved into it since.
+ if (!SequenceFolders.Holds(new ArchivePaths(archive.Root).Sequence(row.Folder), row.Id)) throw new FolderMovedException();
Directory.CreateDirectory(exports);
var target = Unique(exports, output.FileName);
File.Move(stagedFile, target);
diff --git a/tests/Chronos.App.Tests/Editor/ProjectStoreTests.cs b/tests/Chronos.App.Tests/Editor/ProjectStoreTests.cs
index 40a7d8fa..6539be00 100644
--- a/tests/Chronos.App.Tests/Editor/ProjectStoreTests.cs
+++ b/tests/Chronos.App.Tests/Editor/ProjectStoreTests.cs
@@ -289,6 +289,33 @@ public sealed class ProjectStoreTests(TestContext context)
}
}
+ [Test]
+ public async Task ASaveNeverWritesIntoAnotherSequenceMovedIntoTheFolder()
+ {
+ var (db, sequenceId, root) = await ArchiveAsync(4);
+ await using (db)
+ {
+ await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null,
+ new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) });
+ var content = await source.LoadAsync(context.Cancellation);
+
+ // A server sharing the archive moved the folder away, then another sequence into the folder it left; this index
+ // finds both at its next scan.
+ var paths = new ArchivePaths(root);
+ Directory.Move(paths.Sequence("Synthetic").Folder, paths.Sequence("Moved").Folder);
+ var stranger = paths.Sequence("Synthetic");
+ Directory.CreateDirectory(stranger.MetaDirectory);
+ ManifestStore.WriteSequence(stranger.ManifestPath, ManifestStore.ReadSequence(paths.Sequence("Moved").ManifestPath) with { Id = Guid.NewGuid() });
+ const string theirs = """{"exposure":{"deflickerWindow":{"isAuto":false,"manual":7}}}""";
+ await File.WriteAllTextAsync(stranger.ProjectPath, theirs, context.Cancellation);
+ var gone = await Assert.ThrowsAsync(() => source.SaveProjectAsync(content.Project with { HeroFrame = 1 }, content.Project, context.Cancellation));
+
+ Assert.Equal(Loc.L("Editor.Error.Missing"), gone.Message);
+ Assert.Equal(theirs, await File.ReadAllTextAsync(stranger.ProjectPath, context.Cancellation), "the other sequence's project is untouched");
+ Assert.Equal(content.Sequence.SettingsVersion, (await db.Sequences.GetAsync(sequenceId))!.SettingsVersion, "nothing recorded");
+ }
+ }
+
[Test]
public async Task JobsGoToTheEngine()
{
diff --git a/tests/Chronos.Data.Tests/Archiving/ArchiveFixture.cs b/tests/Chronos.Data.Tests/Archiving/ArchiveFixture.cs
index 63c31841..a75fb906 100644
--- a/tests/Chronos.Data.Tests/Archiving/ArchiveFixture.cs
+++ b/tests/Chronos.Data.Tests/Archiving/ArchiveFixture.cs
@@ -123,6 +123,13 @@ internal sealed class ArchiveFixture : IAsyncDisposable
return (path, bytes.Length, Convert.ToHexStringLower(SHA256.HashData(bytes)));
}
+ /// Every file under with the hash of its content, in path order: what a test compares to tell that nothing there changed.
+ public static List FilesOf(string folder) =>
+ [
+ .. Directory.EnumerateFiles(folder, "*", SearchOption.AllDirectories).Order(StringComparer.Ordinal)
+ .Select(p => $"{Path.GetRelativePath(folder, p).Replace('\\', '/')} {Convert.ToHexStringLower(SHA256.HashData(File.ReadAllBytes(p)))}"),
+ ];
+
public async ValueTask DisposeAsync()
{
foreach (var owned in _owned) await owned.DisposeAsync();
diff --git a/tests/Chronos.Data.Tests/Archiving/MassRenameTests.cs b/tests/Chronos.Data.Tests/Archiving/MassRenameTests.cs
index e1cc6dbd..86ee6a6b 100644
--- a/tests/Chronos.Data.Tests/Archiving/MassRenameTests.cs
+++ b/tests/Chronos.Data.Tests/Archiving/MassRenameTests.cs
@@ -356,31 +356,38 @@ public sealed class MassRenameTests(TestContext context)
[Test]
public async Task AnExportNeverNamesTheOneAnotherSequenceBroughtIntoItsOldFolder()
{
- // The new folder is scanned after "inbox/a", then before it.
- foreach (var template in new[] { "moved/{date}", "done/{date}" })
+ // The new folder is scanned after "inbox/a", then before it. "inbox/a" and "inbox/c" each have an export of the
+ // same name: the one of "inbox/a" gone, both there, or the one of "inbox/c" gone.
+ var cases = from template in new[] { "moved/{date}", "done/{date}" }
+ from files in new[] { (A: false, C: true), (A: true, C: true), (A: true, C: false) }
+ select (template, files.A, files.C);
+ foreach (var (template, a, c) in cases)
{
+ var label = $"{template}, a {(a ? "there" : "gone")}, c {(c ? "there" : "gone")}";
await using var fx = await CreateAsync(context);
var ids = await PopulateAsync(fx);
- // The export of "inbox/a" is gone; "inbox/c" has one of the same name.
List renders =
[
- await RenderAsync(fx, ids[0], "inbox/a/exports/Clip.mp4", write: false),
- await RenderAsync(fx, ids[2], "inbox/c/exports/Clip.mp4"),
+ await RenderAsync(fx, ids[0], "inbox/a/exports/Clip.mp4", write: a),
+ await RenderAsync(fx, ids[2], "inbox/c/exports/Clip.mp4", write: c),
];
+ if (a) await File.WriteAllTextAsync(fx.Paths.FromRelative("inbox/a/exports/Clip.mp4"), "a", fx.Ct);
+ if (c) await File.WriteAllTextAsync(fx.Paths.FromRelative("inbox/c/exports/Clip.mp4"), "c", fx.Ct);
var (server, archive) = await fx.OtherWriterAsync();
- // The other index moves "inbox/a", then "inbox/c" into the folder it left, its export along.
+ // The other index moves "inbox/a", then "inbox/c" into the folder it left, their exports along.
var first = await server.PlanRenameAsync(archive.Id, [ids[0]], template, null, fx.Ct);
await server.ApplyRenameAsync(first, null, fx.Ct);
await server.ApplyRenameAsync(await server.PlanRenameAsync(archive.Id, [ids[2]], "inbox/a", null, fx.Ct), null, fx.Ct);
- // The first sequence's row follows its folder, missing there too, and never names the other one's file.
+ // Each row follows its own sequence's folder, its file there or missing there too, and never names the other one's.
await fx.ScanAsync();
string[] expected = [first.Steps.Single().ToFolder + "/exports/Clip.mp4", "inbox/a/exports/Clip.mp4"];
- Assert.SequenceEqual(expected, await OutputsAsync(fx, renders), template);
- Assert.FileExists(fx.Paths.FromRelative(expected[1]));
+ Assert.SequenceEqual(expected, await OutputsAsync(fx, renders), label);
+ if (a) Assert.Equal("a", await File.ReadAllTextAsync(fx.Paths.FromRelative(expected[0]), fx.Ct), label);
+ if (c) Assert.Equal("c", await File.ReadAllTextAsync(fx.Paths.FromRelative(expected[1]), fx.Ct), label);
Assert.Equal(0, (await fx.ScanAsync()).Indexed);
- Assert.SequenceEqual(expected, await OutputsAsync(fx, renders), template);
+ Assert.SequenceEqual(expected, await OutputsAsync(fx, renders), label);
}
}
diff --git a/tests/Chronos.Data.Tests/Archiving/ProxyTests.cs b/tests/Chronos.Data.Tests/Archiving/ProxyTests.cs
index 0673dd94..5bdd18bf 100644
--- a/tests/Chronos.Data.Tests/Archiving/ProxyTests.cs
+++ b/tests/Chronos.Data.Tests/Archiving/ProxyTests.cs
@@ -117,6 +117,33 @@ public sealed class ProxyTests(TestContext context)
Assert.SequenceEqual(proxy, await File.ReadAllBytesAsync(moved.Proxy(0), fx.Ct));
}
+ [Test]
+ public async Task ImagesOfAFolderAnotherSequenceTookAreNotWrittenThere()
+ {
+ await using var fx = await CreateAsync(context);
+ var (sequence, frames) = await HeifSequenceAsync(fx);
+ Photos.WriteSeries(Path.Combine(fx.Paths.Root, "inbox", "other"), Start.AddDays(3), 2, firstSeed: 70);
+ await fx.ScanAsync();
+ var stranger = (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id, fx.Ct)).Single(l => l.Folder == "inbox/other").Id;
+ var images = fx.Service.Images;
+ var (server, archive) = await fx.OtherWriterAsync();
+ await server.ApplyRenameAsync(await server.PlanRenameAsync(archive.Id, [sequence.Id], "moved/{date}", null, fx.Ct), null, fx.Ct);
+ await server.ApplyRenameAsync(await server.PlanRenameAsync(archive.Id, [stranger], sequence.Folder, null, fx.Ct), null, fx.Ct);
+ var folder = fx.Paths.Sequence(sequence.Folder).Folder;
+ var before = FilesOf(folder);
+
+ // This index still has the sequence in the folder the other sequence holds now: a proxy sent, a proxy pass and a
+ // thumbnail pass write nothing there.
+ Assert.Equal(ProxyStoreResult.Gone, await images.StoreProxyAsync(fx.Archive, sequence, frames[0], Proxy(frames[0].CapturedAt!.Value, 2), fx.Ct));
+ foreach (var pass in new Func>[]
+ {
+ () => images.BuildProxiesAsync(fx.Archive, sequence, force: false, 0, (_, _) => ValueTask.CompletedTask, fx.Ct),
+ () => images.BuildThumbnailsAsync(fx.Archive, sequence, force: true, 0, (_, _) => ValueTask.CompletedTask, fx.Ct),
+ })
+ Assert.Equal(Loc.L("Errors.Archive.FolderMoved"), (await Assert.ThrowsAsync(pass)).Message);
+ Assert.SequenceEqual(before, FilesOf(folder));
+ }
+
[Test]
public async Task AProxyPassLetsAnotherProcessReorganizeBetweenItsBatches()
{
diff --git a/tests/Chronos.Data.Tests/Processing/RenderJobTests.cs b/tests/Chronos.Data.Tests/Processing/RenderJobTests.cs
index 3e30bbe8..b60e4f99 100644
--- a/tests/Chronos.Data.Tests/Processing/RenderJobTests.cs
+++ b/tests/Chronos.Data.Tests/Processing/RenderJobTests.cs
@@ -9,6 +9,7 @@ using Chronos.Core.Project;
using Chronos.Core.Video;
using Chronos.Data.Jobs;
using Chronos.Data.Processing;
+using Chronos.Data.Tests.Archiving;
using Chronos.Testing;
namespace Chronos.Data.Tests.Processing;
@@ -154,6 +155,27 @@ public sealed class RenderJobTests(TestContext context)
Assert.False(Directory.Exists(left));
}
+ [Test]
+ public async Task ARenderNeverWritesIntoAnotherSequenceMovedIntoItsFolder()
+ {
+ await using var fx = await ProcessingFixture.CreateAsync(context);
+ var sequence = await fx.AddAsync(Scene());
+ var stranger = await fx.AddAsync(Scene(), "Other");
+ var (server, archive) = await fx.Archive.OtherWriterAsync();
+ await server.ApplyRenameAsync(await server.PlanRenameAsync(archive.Id, [sequence.Id], "Moved/{date}", null, fx.Ct), null, fx.Ct);
+ await server.ApplyRenameAsync(await server.PlanRenameAsync(archive.Id, [stranger.Id], sequence.Folder, null, fx.Ct), null, fx.Ct);
+ var folder = fx.Folder(sequence).Folder;
+ var before = ArchiveFixture.FilesOf(folder);
+ await fx.StartEngineAsync();
+
+ // A server sharing the archive moved the folder away and the other sequence into it; this index has not scanned since.
+ var job = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64));
+ var failed = await fx.WaitForAsync(job.Id, JobState.Failed);
+ Assert.Equal(Loc.L("Errors.Archive.FolderMoved"), failed.Error);
+ Assert.SequenceEqual(before, ArchiveFixture.FilesOf(folder), "the other sequence's files are untouched");
+ Assert.Empty(await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct));
+ }
+
[Test]
public async Task AFrameThatNoLongerDecodesIsReplacedByItsNeighbourAndLeftOutNextTime()
{
diff --git a/tests/Chronos.Data.Tests/Sync/SyncServiceTests.cs b/tests/Chronos.Data.Tests/Sync/SyncServiceTests.cs
index a7817b2c..174f505b 100644
--- a/tests/Chronos.Data.Tests/Sync/SyncServiceTests.cs
+++ b/tests/Chronos.Data.Tests/Sync/SyncServiceTests.cs
@@ -530,6 +530,47 @@ public sealed class SyncServiceTests(TestContext context)
"the moved project is this PC's version");
}
+ [Test]
+ public async Task TakeServerAndSaveBothWriteNothingIntoAnotherSequenceMovedIntoTheFolder()
+ {
+ const string strangers = """{"exposure":{"deflickerWindow":{"isAuto":false,"manual":7}}}""";
+ foreach (var resolution in new[] { SyncResolution.TakeServer, SyncResolution.SaveBoth })
+ {
+ await using var f = await SyncFixture.CreateAsync(context);
+ var (local, remote) = await ConflictAsync(f);
+ var stranger = await f.LocalAsync("Stranger", f.NewPhotos(2), strangers);
+ var folder = f.Archive.Paths.Sequence(local.Folder);
+
+ // Another index moves the folder away while the server's version is read, then another sequence (first parked
+ // elsewhere: its folder is the same name with a number) into the folder it left; this index has scanned neither.
+ var (other, archive) = await f.Archive.OtherWriterAsync();
+ List? before = null;
+ f.Remote.OnceBeforeManifest = async () =>
+ {
+ foreach (var (id, template) in new[] { (local.Id, "moved/{title}"), (stranger.Id, "parked/{title}"), (stranger.Id, local.Folder) })
+ await other.ApplyRenameAsync(await other.PlanRenameAsync(archive.Id, [id], template, null, f.Ct), null, f.Ct);
+ before = ArchiveFixture.FilesOf(folder.Folder);
+ };
+ var refused = await Assert.ThrowsAsync(() => f.Sync.ResolveAsync(f.Remote, remote.Id, resolution, f.Ct));
+ Assert.Equal(Loc.L("Errors.Archive.FolderMoved"), refused.Message, $"{resolution}: the user hears to try again after the next scan");
+
+ // Neither version went into the other sequence's folder, nor replaced this PC's where the sequence is.
+ Assert.Equal(stranger.Id, SequenceTrash.SidecarId(folder.ManifestPath), "the other sequence holds the folder");
+ Assert.SequenceEqual(before!, ArchiveFixture.FilesOf(folder.Folder), $"{resolution}: the other sequence's files are untouched");
+ Assert.True(SyncRules.SameSettings(SyncFixture.Window41, (await f.Db.Sequences.GetAsync(local.Id, f.Ct))!.SettingsJson), "nothing applied");
+ var moved = f.Archive.Paths.Sequence("moved/Holy grail");
+ Assert.True(SyncRules.SameSettings(SyncFixture.Window41, await File.ReadAllTextAsync(moved.ProjectPath, f.Ct)), "the moved project is this PC's version");
+ Assert.Empty(Directory.GetFiles(moved.MetaDirectory, SyncService.SavedCopyPattern));
+
+ // Chosen again once this index's scan found both, it is done where the sequence is now.
+ await f.Archive.ScanAsync();
+ var copy = await f.Sync.ResolveAsync(f.Remote, remote.Id, resolution, f.Ct);
+ Assert.True(SyncRules.SameSettings(SyncFixture.Window33, await File.ReadAllTextAsync(moved.ProjectPath, f.Ct)), resolution.ToString());
+ Assert.Equal(resolution == SyncResolution.SaveBoth, copy is not null && Path.GetDirectoryName(copy) == moved.MetaDirectory);
+ Assert.True(SyncRules.SameSettings(strangers, await File.ReadAllTextAsync(folder.ProjectPath, f.Ct)), "the other sequence keeps its own");
+ }
+ }
+
[Test]
public async Task KeepMineRefusesWhenTheServerChangedAfterTheConflictWasShown()
{
diff --git a/tests/Chronos.Server.Tests/Api/ReorganizeTests.cs b/tests/Chronos.Server.Tests/Api/ReorganizeTests.cs
index 730e5c9a..ceb41b6c 100644
--- a/tests/Chronos.Server.Tests/Api/ReorganizeTests.cs
+++ b/tests/Chronos.Server.Tests/Api/ReorganizeTests.cs
@@ -170,6 +170,41 @@ public sealed class ReorganizeTests(TestContext context)
Assert.Empty(await server.Database.Renders.ListBySequenceAsync(id));
}
+ [Test]
+ public async Task AnExportIsNeverFiledAmongThoseOfAnotherSequenceMovedIntoItsFolder()
+ {
+ await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
+ var (editor, _, _) = await server.UserAsync("alberto", "editor");
+ var id = (await Uploads.UploadAsync(editor, Photo(1), "IMG_0001.JPG", sessionKey: "roof")).SequenceId;
+ var other = (await Uploads.UploadAsync(editor, Photo(2), "IMG_0002.JPG", sessionKey: "cam")).SequenceId;
+ await UntilIdleAsync(server);
+ var sequence = (await server.Database.Sequences.GetAsync(id))!;
+ var stranger = (await server.Database.Sequences.GetAsync(other))!;
+
+ // A desktop sharing the archive moved the folder away, then the other sequence into the folder it left; this server's
+ // index still has both where they were.
+ var folder = Path.Combine(server.Options.ArchivePath, sequence.Folder);
+ Directory.Move(folder, Path.Combine(server.Options.ArchivePath, "elsewhere"));
+ Directory.Move(Path.Combine(server.Options.ArchivePath, stranger.Folder), folder);
+ var before = Files(folder);
+ var video = Uploads.Photo(4096, 31);
+ var staged = Path.Combine(context.CreateTempDirectory("staged"), "render.mp4");
+ await File.WriteAllBytesAsync(staged, video);
+ await Assert.ThrowsAsync(() => server.Services.GetRequiredService().CommitAsync(sequence, staged,
+ new RenderResultRequest("Roof - 4K.mp4", video.Length, Uploads.Sha(video), "4K HEVC", "hevc", 3840, 2160, 25, 4), "studio-pc", CancellationToken.None));
+
+ Assert.FileExists(staged);
+ Assert.SequenceEqual(before, Files(folder), "the other sequence's files are untouched");
+ Assert.Empty(await server.Database.Renders.ListBySequenceAsync(id));
+ }
+
+ /// Every file under with the hash of its content, in path order.
+ private static List Files(string folder) =>
+ [
+ .. Directory.EnumerateFiles(folder, "*", SearchOption.AllDirectories).Order(StringComparer.Ordinal)
+ .Select(p => $"{Path.GetRelativePath(folder, p).Replace('\\', '/')} {Uploads.Sha(File.ReadAllBytes(p))}"),
+ ];
+
[Test]
public async Task AReorganizeAsksForTheArchiveAndAValidRequest()
{