diff --git a/src/Titano.Data/Archiving/ArchiveIndexer.cs b/src/Titano.Data/Archiving/ArchiveIndexer.cs
index 5561c3d6..a85265da 100644
--- a/src/Titano.Data/Archiving/ArchiveIndexer.cs
+++ b/src/Titano.Data/Archiving/ArchiveIndexer.cs
@@ -130,10 +130,30 @@ public sealed class ArchiveIndexer
var paths = new ArchivePaths(archive.RootPath);
ArchiveVolume.EnsureWritable(paths);
var folder = paths.Sequence(sequence.Folder);
- var manifest = await _writer.UpdateAsync(paths, sequence.Id, sequence.Folder, m => SequenceAdopter.Reconcile(folder, m, cancellationToken),
- cancellationToken).ConfigureAwait(false);
- await SyncAsync(archive, folder, manifest, cancellationToken).ConfigureAwait(false);
- return manifest;
+ return await UpdateAndSyncAsync(archive, paths, folder, sequence.Id, m => SequenceAdopter.Reconcile(folder, m, cancellationToken), cancellationToken)
+ .ConfigureAwait(false);
+ }
+
+ ///
+ /// Applies to the sidecar (null writes nothing) and indexes the result, both under the sequence
+ /// lease. Frames inserted before indexed ones move the project's positions () without a
+ /// new settings version; an editor saving its project holds the same lease, so it reads them moved and merges onto
+ /// them rather than writing its old positions back.
+ ///
+ private async Task UpdateAndSyncAsync(Archive archive, ArchivePaths paths, SequencePaths sequence, Guid sequenceId,
+ Func edit, CancellationToken cancellationToken)
+ {
+ await using (await _writer.LockAsync(paths, sequenceId, cancellationToken).ConfigureAwait(false))
+ {
+ var manifest = SequenceWriter.ReadLocked(sequence, sequenceId);
+ if (edit(manifest) is { } updated)
+ {
+ ManifestStore.WriteSequence(sequence.ManifestPath, updated);
+ manifest = updated;
+ }
+ await SyncAsync(archive, sequence, manifest, cancellationToken).ConfigureAwait(false);
+ return manifest;
+ }
}
/// Indexes one folder; returns the sidecar bytes when they were read and not rewritten since (for the snapshot).
@@ -169,20 +189,33 @@ public sealed class ArchiveIndexer
}
if (reconcile || File.Exists(sequence.IngestJournalPath))
{
- var before = manifest;
// Photos added, gone or back: the light analysis no longer describes the frames, so the scan's follow-up runs it again.
- manifest = await _writer.UpdateAsync(paths, manifest.Id, folder.RelativeFolder,
+ manifest = await UpdateAndSyncAsync(archive, paths, sequence, manifest.Id,
m => SequenceAdopter.Reconcile(sequence, m, cancellationToken) is { } reconciled
? reconciled with { Status = reconciled.Status & ~SequenceStatus.AnalyzedLight }
: null,
cancellationToken).ConfigureAwait(false);
- if (!ReferenceEquals(before, manifest)) bytes = null;
+ bytes = null;
+ }
+ else if (await MayMovePositionsAsync(manifest, cancellationToken).ConfigureAwait(false))
+ {
+ // Another process changed the frames: the sidecar is read again under the lease the project moves under.
+ manifest = await UpdateAndSyncAsync(archive, paths, sequence, manifest.Id, _ => null, cancellationToken).ConfigureAwait(false);
+ bytes = null;
+ }
+ else
+ {
+ await SyncAsync(archive, sequence, manifest, cancellationToken).ConfigureAwait(false);
}
- await SyncAsync(archive, sequence, manifest, cancellationToken).ConfigureAwait(false);
locations.Set(manifest.Id, folder.RelativeFolder);
return bytes;
}
+ /// The index holds a project for this sequence and other frames than the sidecar: its positions may move.
+ private async Task MayMovePositionsAsync(SequenceManifest manifest, CancellationToken cancellationToken) =>
+ await _db.Sequences.GetAsync(manifest.Id, cancellationToken).ConfigureAwait(false) is { SettingsJson: not null } indexed
+ && indexed.FramesVersion != manifest.Versions.Frames;
+
/// A sidecar for a folder that has none; ids of a sequence the index already knew at this folder are kept.
private async Task AdoptAsync(SequencePaths sequence, Locations locations, CancellationToken cancellationToken)
{
diff --git a/tests/Titano.Data.Tests/Archiving/ArchiveIngestTests.cs b/tests/Titano.Data.Tests/Archiving/ArchiveIngestTests.cs
index a944c0d9..548f799c 100644
--- a/tests/Titano.Data.Tests/Archiving/ArchiveIngestTests.cs
+++ b/tests/Titano.Data.Tests/Archiving/ArchiveIngestTests.cs
@@ -298,4 +298,37 @@ public sealed class ArchiveIngestTests(TestContext context)
Assert.Contains("futureOption", settings);
Assert.True(JsonNode.DeepEquals(JsonNode.Parse(settings), JsonNode.Parse(File.ReadAllText(folder.ProjectPath))), "project.json mirrors the index");
}
+
+ [Test]
+ public async Task AScanMovesTheProjectPositionsOnlyBetweenProjectSaves()
+ {
+ await using var fx = await CreateAsync(context);
+ var late = await fx.Service.Ingest.CommitAsync(Request(fx, fx.Stage(Start.AddMinutes(1), 1)), fx.Ct);
+ await fx.Service.Ingest.CommitAsync(Request(fx, fx.Stage(Start.AddMinutes(2), 2)), fx.Ct);
+ var id = late.SequenceId;
+ var folder = fx.Paths.Sequence((await fx.Db.Sequences.GetAsync(id))!.Folder);
+ var version = (await fx.Db.Sequences.EditAsync(id, new SequenceEdit { SettingsJson = "{ \"excludedFrames\": [1] }" }, null, fx.Ct)).Sequence!.SettingsVersion;
+
+ // Another process files a photo captured before both into the sidecar; this index learns of it from a scan.
+ var photos = ArchiveScanner.PhotoDirectory(folder);
+ var stamp = Directory.GetLastWriteTimeUtc(photos);
+ File.WriteAllBytes(folder.File("originals/early.JPG"), Photos.Jpeg(Start, 3));
+ ManifestStore.WriteSequence(folder.ManifestPath, SequenceAdopter.Reconcile(folder, ManifestStore.ReadSequence(folder.ManifestPath), fx.Ct)!);
+ Directory.SetLastWriteTimeUtc(photos, stamp);
+
+ // An editor saving the project holds the sequence lease (LocalSequenceSource.SaveProjectAsync).
+ var save = await LeaseFile.AcquireAsync(fx.Paths.LocksDirectory, $"seq-{id:N}", "editor", TimeSpan.FromSeconds(5), cancellationToken: fx.Ct);
+ var scan = Task.Run(() => fx.ScanAsync());
+ await Task.Delay(500, fx.Ct);
+ Assert.False(scan.IsCompleted, "the scan waits for the save");
+ // The save stores the positions its editor knew, as of the frames before the scan.
+ Assert.Equal(SequenceEditOutcome.Updated,
+ (await fx.Db.Sequences.EditAsync(id, new SequenceEdit { SettingsJson = "{ \"excludedFrames\": [0, 1] }" }, version, fx.Ct)).Outcome);
+ save.Dispose();
+ Assert.Equal(1, (await scan).Indexed);
+
+ var row = (await fx.Db.Sequences.GetAsync(id))!;
+ Assert.Equal(3, row.FrameCount);
+ Assert.SequenceEqual([1, 2], ProjectSettings.FromJson(row.SettingsJson!).ExcludedFrames);
+ }
}