Third fix round of owner review 2, phase 4a (Reorganize), cross-cutting items. - Server render filing now runs under the sequence lease, so it can meet a busy sequence or an offline archive. Both completions (client render uploads and render-node results) used to answer 500 and leave the upload stuck in Committing until a restart. They now answer 503 sequence_busy or archive_offline, which clients retry. The upload goes back to receiving with its part file and the node keeps its job (UploadService.ReceiveAgainAsync). - Save both: when this PC's copy cannot be written (another index moved the folder), the server's version is no longer applied, even if this index's scan relocates the row before the apply would run. A copy that has to be dropped is deleted from where the folder is now, as a best effort. - Export rebase on a folder move (scan and Reorganize): the sequence's own export follows the folder unless its file is still at the old path and not at the new one. A file written into a re-created old folder therefore keeps a row that finds it, so the file is never stranded. - A render job refuses to start when its folder is not where the index has it, which also stops it from re-creating the old folder. Renders fetched by sync are now filed under the sequence lease into the current folder, or not at all (new string Errors.Archive.FolderMoved, en and it). - The proxy pass holds the thumbnail lease one batch at a time (a quarter of the lease wait), then lets it go for longer than a waiter's poll and reads the folder and sidecar again. Before, another process's Reorganize, sequence deletion or pack compaction could wait out its lease wait and fail. Updated the stale comments on that lease and ARCHITECTURE.md to match. Tests cover each fix, and each new test fails with its fix reverted. Also covered: proxy store and pass in a moved folder, RenderStore with the folder gone, Take server with the folder moved, and an editor save with the folder moved. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 811509d32a118ed50ad10d47d4b002e534da9d77)
410 lines
22 KiB
C#
410 lines
22 KiB
C#
using System.IO;
|
|
using Chronos.App.Editor;
|
|
using Chronos.Core.Archiving;
|
|
using Chronos.Core.Codecs.Jpeg;
|
|
using Chronos.Core.Imaging;
|
|
using Chronos.Core.Imaging.Decoders;
|
|
using Chronos.Core.Localization;
|
|
using Chronos.Core.Metadata;
|
|
using Chronos.Core.Model;
|
|
using Chronos.Core.Project;
|
|
using Chronos.Data;
|
|
using Chronos.Data.Archiving;
|
|
using Chronos.Data.Jobs;
|
|
using Chronos.Data.Processing;
|
|
using Chronos.Data.Repositories;
|
|
using Chronos.Testing;
|
|
|
|
namespace Chronos.App.Tests.Editor;
|
|
|
|
/// <summary>Project merges, and the local source over a real SQLite index and archive folder.</summary>
|
|
public sealed class ProjectStoreTests(TestContext context)
|
|
{
|
|
[Test]
|
|
public void AMemberOnlyTheyChangedIsKept()
|
|
{
|
|
var basis = new ProjectSettings();
|
|
var ours = basis with { Exposure = basis.Exposure with { ExposureOffsetEv = 0.5 } };
|
|
var theirs = basis with { HeroFrame = 12 };
|
|
var merged = ProjectMerge.Merge(basis, ours, theirs);
|
|
Assert.Equal(0.5, merged.Exposure.ExposureOffsetEv);
|
|
Assert.Equal(12, merged.HeroFrame);
|
|
}
|
|
|
|
[Test]
|
|
public void AdviceMergesIntoAManualValueOfTheSameSetting()
|
|
{
|
|
var basis = new ProjectSettings();
|
|
var ours = basis with { Exposure = basis.Exposure with { Deflicker = basis.Exposure.Deflicker.WithManual(true) } };
|
|
var theirs = basis with { Exposure = basis.Exposure with { Deflicker = basis.Exposure.Deflicker.WithAdvice(false, "Advisor.Reason.Deflicker.Off") } };
|
|
var merged = ProjectMerge.Merge(basis, ours, theirs).Exposure.Deflicker;
|
|
Assert.False(merged.IsAuto, "the user's manual choice stays");
|
|
Assert.True(merged.Manual);
|
|
Assert.True(merged.HasAdvice, "the new advice is stored next to it");
|
|
Assert.Equal("Advisor.Reason.Deflicker.Off", merged.ReasonKey);
|
|
}
|
|
|
|
[Test]
|
|
public void WhenBothChangedAValueTheEditorWins()
|
|
{
|
|
var basis = new ProjectSettings();
|
|
var merged = ProjectMerge.Merge(basis, basis with { HeroFrame = 3 }, basis with { HeroFrame = 9 });
|
|
Assert.Equal(3, merged.HeroFrame);
|
|
}
|
|
|
|
[Test]
|
|
public async Task TheLocalSourceReadsDecodesSavesAndQueues()
|
|
{
|
|
var (db, sequenceId, root) = await ArchiveAsync(12);
|
|
await using (db)
|
|
{
|
|
var options = new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) };
|
|
await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null, options);
|
|
var content = await source.LoadAsync(context.Cancellation);
|
|
Assert.Equal(12, content.Count);
|
|
Assert.Equal(96, content.SourceWidth);
|
|
Assert.Equal(64, content.SourceHeight);
|
|
Assert.Null(content.Deep, "not analysed yet");
|
|
Assert.NotNull(content.ExportsFolder);
|
|
Assert.Contains("exports", content.ExportsFolder!);
|
|
|
|
using (var frame = await source.DecodeAsync(3, 32, DecodePurpose.Thumbnail, context.Cancellation))
|
|
{
|
|
Assert.NotNull(frame);
|
|
Assert.LessOrEqual(Math.Max(frame!.Width, frame.Height), 32);
|
|
}
|
|
Assert.Null(await source.DecodeAsync(99, 32, DecodePurpose.Thumbnail, context.Cancellation));
|
|
|
|
// A save writes project.json and the index row together.
|
|
var edited = content.Project with { HeroFrame = 4, Exposure = content.Project.Exposure with { ExposureOffsetEv = 0.3 } };
|
|
var stored = await source.SaveProjectAsync(edited, content.Project, context.Cancellation);
|
|
Assert.True(ProjectMerge.SameValues(edited, stored));
|
|
var projectPath = Path.Combine(root, "Synthetic", ".chronos", "project.json");
|
|
Assert.FileExists(projectPath);
|
|
Assert.Equal(edited.ToJson(), File.ReadAllText(projectPath));
|
|
var row = await db.Sequences.GetAsync(sequenceId);
|
|
Assert.Equal(edited.ToJson(), row!.SettingsJson);
|
|
|
|
// Someone else changes the settings meanwhile (the server API): both edits survive the next save.
|
|
var theirs = stored with { Camera = stored.Camera with { OffsetY = 0.25 } };
|
|
await db.Sequences.EditAsync(sequenceId, new SequenceEdit { SettingsJson = theirs.ToJson() }, row.SettingsVersion);
|
|
var mine = stored with { HeroFrame = 7 };
|
|
var merged = await source.SaveProjectAsync(mine, stored, context.Cancellation);
|
|
Assert.Equal(7, merged.HeroFrame);
|
|
Assert.Equal(0.25, merged.Camera.OffsetY);
|
|
Assert.Equal(merged.ToJson(), File.ReadAllText(projectPath));
|
|
Assert.Equal(merged.ToJson(), (await db.Sequences.GetAsync(sequenceId))!.SettingsJson);
|
|
|
|
var reloaded = await source.LoadAsync(context.Cancellation);
|
|
Assert.True(ProjectMerge.SameValues(merged, reloaded.Project), "the index copy is read back");
|
|
|
|
await Assert.ThrowsAsync<InvalidOperationException>(() => source.SubmitAsync(ProcessingJobs.DeepAnalysis([sequenceId]), context.Cancellation));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task SetHeroReachesTheLibraryThumbnail()
|
|
{
|
|
var (db, sequenceId, root) = await ArchiveAsync(6);
|
|
await using (db)
|
|
{
|
|
await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null,
|
|
new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) });
|
|
var changed = new List<Sequence>();
|
|
source.HeroChanged += changed.Add;
|
|
var content = await source.LoadAsync(context.Cancellation);
|
|
var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20));
|
|
await using (session)
|
|
{
|
|
Assert.True(session.SetHero(4));
|
|
Assert.True(await session.FlushAsync());
|
|
Assert.Equal(content.Frames[4].Id, (await db.Sequences.GetAsync(sequenceId))!.HeroFrameId, "the index names the hero frame");
|
|
Assert.Equal(content.Frames[4].Id, Assert.Contains(changed, _ => true).HeroFrameId, "the Library is told");
|
|
|
|
session.Edit(p => p with { Exposure = p.Exposure with { ExposureOffsetEv = 0.2 } });
|
|
Assert.True(await session.FlushAsync());
|
|
Assert.Count(1, changed);
|
|
|
|
Assert.True(session.Undo());
|
|
Assert.True(session.Undo());
|
|
Assert.True(await session.FlushAsync());
|
|
Assert.Null((await db.Sequences.GetAsync(sequenceId))!.HeroFrameId, "undoing Set hero brings back the first frame");
|
|
Assert.Count(2, changed);
|
|
}
|
|
|
|
// "Save both" copies kept by a sync conflict are listed with the sequence.
|
|
File.WriteAllText(Path.Combine(root, "Synthetic", ".chronos", "project.this-pc-20261003-142200.json"), new ProjectSettings().ToJson());
|
|
Assert.Equal(new DateTime(2026, 10, 3, 14, 22, 0), Assert.Contains((await source.LoadAsync(context.Cancellation)).SavedCopies, _ => true).SavedAt);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task AnEditorOpenWhileEarlierPhotosArriveSavesOnTheFramesTheUserChose()
|
|
{
|
|
var (db, sequenceId, root) = await ArchiveAsync(10);
|
|
await using (db)
|
|
{
|
|
var options = new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) };
|
|
await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null, options);
|
|
var content = await source.LoadAsync(context.Cancellation);
|
|
var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20));
|
|
await using (session)
|
|
{
|
|
Assert.True(session.SetExcluded([5], true));
|
|
Assert.True(session.SetHero(6));
|
|
Assert.True(await session.FlushAsync());
|
|
|
|
// Three photos taken before the others are found in the folder (a sync download, an import or a scan
|
|
// inserts them the same way): the index moves the stored positions with their frames.
|
|
await InsertEarlierAsync(db, root, content, options, 3);
|
|
var moved = ProjectSettings.FromJson((await db.Sequences.GetAsync(sequenceId))!.SettingsJson!);
|
|
Assert.SequenceEqual([8], moved.ExcludedFrames);
|
|
Assert.Equal(9, moved.HeroFrame);
|
|
|
|
// The editor still shows the ten frames it read; the user excludes the eighth of them.
|
|
Assert.Equal(10, session.Content.Count);
|
|
Assert.True(session.SetExcluded([7], true));
|
|
Assert.True(await session.FlushAsync());
|
|
|
|
Assert.Equal(13, session.Content.Count, "the frames were read again before the save");
|
|
Assert.SequenceEqual([8, 10], session.Project.ExcludedFrames);
|
|
Assert.Equal(9, session.Project.HeroFrame);
|
|
var row = (await db.Sequences.GetAsync(sequenceId))!;
|
|
var stored = ProjectSettings.FromJson(row.SettingsJson!);
|
|
var frames = session.Content.Frames;
|
|
Assert.SequenceEqual([content.Frames[5].Id, content.Frames[7].Id], stored.ExcludedFrames.Select(i => frames[i].Id), "the photos the user chose");
|
|
Assert.Equal(content.Frames[6].Id, frames[stored.HeroFrame!.Value].Id);
|
|
Assert.Equal(content.Frames[6].Id, row.HeroFrameId);
|
|
Assert.Equal(row.SettingsJson, File.ReadAllText(Path.Combine(root, "Synthetic", ".chronos", "project.json")));
|
|
|
|
// Undo takes back the user's last step on the new frames too.
|
|
Assert.True(session.Undo());
|
|
Assert.True(await session.FlushAsync());
|
|
Assert.SequenceEqual([8], ProjectSettings.FromJson((await db.Sequences.GetAsync(sequenceId))!.SettingsJson!).ExcludedFrames);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task ARenderAfterEarlierPhotosArriveEmbedsTheFramesTheUserChose()
|
|
{
|
|
var (db, sequenceId, root) = await ArchiveAsync(10);
|
|
await using (db)
|
|
{
|
|
var options = new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) };
|
|
await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null, options);
|
|
var content = await source.LoadAsync(context.Cancellation);
|
|
var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20));
|
|
await using (session)
|
|
{
|
|
Assert.True(session.SetExcluded([5], true));
|
|
Assert.True(await session.FlushAsync());
|
|
Assert.True(await source.FramesCurrentAsync(context.Cancellation));
|
|
|
|
// Earlier photos arrive while the editor is open; the user renders without another edit.
|
|
await InsertEarlierAsync(db, root, content, options, 3);
|
|
Assert.False(await source.FramesCurrentAsync(context.Cancellation));
|
|
await session.EnsureFramesAsync(context.Cancellation);
|
|
var request = session.RenderRequests(session.Project.Export)[0];
|
|
|
|
Assert.True(await source.FramesCurrentAsync(context.Cancellation));
|
|
Assert.Equal(13, session.Content.Count);
|
|
var embedded = ProjectSettings.FromJson(ProcessingJobs.ReadRender(request.ParametersJson).Parameters.SettingsJson!);
|
|
Assert.SequenceEqual([content.Frames[5].Id], embedded.ExcludedFrames.Select(i => session.Content.Frames[i].Id), "the photo the user excluded");
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task AnEditorOpenWhileAReorganizeMovesItsFolderSavesWhereTheSequenceIsNow()
|
|
{
|
|
var (db, sequenceId, root) = await ArchiveAsync(6);
|
|
await using (db)
|
|
{
|
|
var options = new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) };
|
|
await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null, options);
|
|
var content = await source.LoadAsync(context.Cancellation);
|
|
var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20));
|
|
await using (session)
|
|
{
|
|
Assert.True(session.SetHero(2));
|
|
Assert.True(await session.FlushAsync());
|
|
|
|
// Only the folder template changed: the Reorganize moves the folder and keeps the frames version.
|
|
var service = new ArchiveService(db, options);
|
|
var plan = await service.PlanRenameAsync(content.Sequence.ArchiveId, [sequenceId], "Moved/{title}", null, context.Cancellation);
|
|
await service.ApplyRenameAsync(plan, null, context.Cancellation);
|
|
var moved = new ArchivePaths(root).Sequence(plan.Steps.Single().ToFolder);
|
|
Assert.Equal(content.Sequence.FramesVersion, (await db.Sequences.GetAsync(sequenceId))!.FramesVersion);
|
|
Assert.False(await source.FramesCurrentAsync(context.Cancellation), "the files are no longer where the editor read them");
|
|
|
|
session.Edit(p => p with { Exposure = p.Exposure with { ExposureOffsetEv = 0.4 } });
|
|
Assert.True(await session.FlushAsync());
|
|
|
|
var row = (await db.Sequences.GetAsync(sequenceId))!;
|
|
Assert.Equal(0.4, ProjectSettings.FromJson(row.SettingsJson!).Exposure.ExposureOffsetEv);
|
|
Assert.Equal(row.SettingsJson, File.ReadAllText(moved.ProjectPath), "the moved folder's project has the edit");
|
|
Assert.False(Directory.Exists(Path.Combine(root, "Synthetic")), "the folder it left is not created again");
|
|
Assert.True(await source.FramesCurrentAsync(context.Cancellation));
|
|
Assert.Equal(moved.Exports, session.Content.ExportsFolder);
|
|
using var frame = await source.DecodeAsync(1, 32, DecodePurpose.Thumbnail, context.Cancellation);
|
|
Assert.NotNull(frame, "the frames are read where they are now");
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task ASaveThatDoesNotReachTheIndexThrows()
|
|
{
|
|
var (db, sequenceId, _) = 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);
|
|
Assert.True(await db.Sequences.DeleteAsync(sequenceId));
|
|
var gone = await Assert.ThrowsAsync<EditorException>(() => source.SaveProjectAsync(content.Project with { HeroFrame = 1 }, content.Project, context.Cancellation));
|
|
Assert.Equal(Loc.L("Editor.Error.Missing"), gone.Message, "the toast shows the editor's own sentence");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task ASaveAfterAnotherIndexMovedTheFolderWritesNothing()
|
|
{
|
|
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; this index finds it there at its next scan.
|
|
var left = Path.Combine(root, "Synthetic");
|
|
Directory.Move(left, Path.Combine(root, "Moved"));
|
|
var gone = await Assert.ThrowsAsync<EditorException>(() => source.SaveProjectAsync(content.Project with { HeroFrame = 1 }, content.Project, context.Cancellation));
|
|
|
|
Assert.Equal(Loc.L("Editor.Error.Missing"), gone.Message);
|
|
Assert.False(Directory.Exists(left), "the folder it left is not created again");
|
|
Assert.Equal(content.Sequence.SettingsVersion, (await db.Sequences.GetAsync(sequenceId))!.SettingsVersion, "nothing recorded");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task JobsGoToTheEngine()
|
|
{
|
|
var (db, sequenceId, _) = await ArchiveAsync(4);
|
|
await using (db)
|
|
{
|
|
await using var engine = new JobEngine(db, [], new JobEngineOptions { WorkerId = "test" });
|
|
await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), engine);
|
|
var content = await source.LoadAsync(context.Cancellation);
|
|
var session = new EditorSession(source, content, []);
|
|
var id = await session.SubmitAsync(session.AnalysisRequest(), context.Cancellation);
|
|
var job = await db.Jobs.GetAsync(id);
|
|
Assert.Equal(JobKind.DeepAnalyse, job!.Kind);
|
|
Assert.Equal(JobState.Queued, job.State);
|
|
Assert.SequenceEqual([sequenceId], job.TargetIds);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public async Task AnUnreadableProjectIsReportedNotReplaced()
|
|
{
|
|
var (db, sequenceId, root) = await ArchiveAsync(4);
|
|
await using (db)
|
|
{
|
|
var path = Path.Combine(root, "Synthetic", ".chronos", "project.json");
|
|
File.WriteAllText(path, "{ not json");
|
|
await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null);
|
|
var unreadable = await Assert.ThrowsAsync<EditorException>(() => source.LoadAsync(context.Cancellation));
|
|
Assert.Equal(Loc.L("Editor.Error.Project"), unreadable.Message);
|
|
Assert.Equal("{ not json", File.ReadAllText(path));
|
|
|
|
// A project written by a newer Chronos reads the same, not as the parser's English sentence.
|
|
var newer = $"{{\"version\":{ProjectSettings.CurrentVersion + 1}}}";
|
|
File.WriteAllText(path, newer);
|
|
Assert.Equal(Loc.L("Editor.Error.Project"), (await Assert.ThrowsAsync<EditorException>(() => source.LoadAsync(context.Cancellation))).Message);
|
|
Assert.Equal(newer, File.ReadAllText(path));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes <paramref name="count"/> photos taken before the sequence's first frame into its folder and scans the
|
|
/// archive: they are inserted in front, and the index moves the stored positions with their frames.
|
|
/// </summary>
|
|
private async Task InsertEarlierAsync(ChronosDatabase db, string root, SequenceContent content, ArchiveServiceOptions options, int count)
|
|
{
|
|
var sequence = EditorFixture.Sequence(count);
|
|
var first = content.Frames[0].CapturedAt!.Value;
|
|
for (var i = 0; i < count; i++)
|
|
{
|
|
using var image = sequence.Render(i);
|
|
var exif = ExifWriter.BuildJpegApp1(sequence.Metadata[i] with { CapturedAt = first.AddMinutes(i - count) });
|
|
File.WriteAllBytes(Path.Combine(root, "Synthetic", $"EARLY_{i + 1}.JPG"),
|
|
JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 90, App1Segments = [exif[4..]] }));
|
|
}
|
|
var archive = (await db.Archives.GetAsync(content.Sequence.ArchiveId, context.Cancellation))!;
|
|
await new ArchiveService(db, options).Indexer.ScanAsync(archive, ScanMode.Full, null, _ => ValueTask.CompletedTask, context.Cancellation);
|
|
}
|
|
|
|
/// <summary>A temporary archive with one adopted folder of synthetic JPEGs, indexed.</summary>
|
|
/// <summary>
|
|
/// A decode superseded by a newer edit (R4, owner review 1): the caller sees a cancellation, never an unreadable frame,
|
|
/// and the provider's cancellation stays inside the source's own task.
|
|
/// </summary>
|
|
[Test]
|
|
public async Task ACancelledDecodeIsACancellationNotAnUnreadableFrame()
|
|
{
|
|
var (db, sequenceId, _) = await ArchiveAsync(4);
|
|
await using (db)
|
|
{
|
|
var entered = new TaskCompletionSource();
|
|
var blocking = new ImageDecoder([new BlockingProvider(entered)]);
|
|
var options = new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) };
|
|
await using var source = new LocalSequenceSource(db, sequenceId, blocking, null, options);
|
|
await source.LoadAsync(context.Cancellation);
|
|
using var cts = new CancellationTokenSource();
|
|
var decode = source.DecodeAsync(1, 64, DecodePurpose.Proxy, cts.Token).AsTask();
|
|
await entered.Task.WaitAsync(TimeSpan.FromSeconds(10));
|
|
await cts.CancelAsync();
|
|
await Assert.ThrowsAsync<OperationCanceledException>(() => decode);
|
|
}
|
|
}
|
|
|
|
/// <summary>Decodes nothing until its token is cancelled, then throws the cancellation, as WIC does between bands.</summary>
|
|
private sealed class BlockingProvider(TaskCompletionSource entered) : IImageDecoderProvider
|
|
{
|
|
public string Name => "blocking";
|
|
public DecodeTier? TierFor(ImageFileFormat format) => DecodeTier.Native;
|
|
|
|
public DecodedImage? Decode(DecodeRequest request, CancellationToken cancellationToken = default)
|
|
{
|
|
entered.TrySetResult();
|
|
cancellationToken.WaitHandle.WaitOne(TimeSpan.FromSeconds(10));
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private async Task<(ChronosDatabase Db, Guid SequenceId, string Root)> ArchiveAsync(int frames)
|
|
{
|
|
var directory = context.CreateTempDirectory("editor");
|
|
var root = Path.Combine(directory, "archive");
|
|
var db = await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(directory, "index.db")));
|
|
var service = new ArchiveService(db, new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) });
|
|
var archive = await service.CreateAsync(root, "Test");
|
|
var sequence = EditorFixture.Sequence(frames);
|
|
var folder = Path.Combine(root, "Synthetic");
|
|
Directory.CreateDirectory(folder);
|
|
for (var i = 0; i < sequence.Count; i++)
|
|
{
|
|
using var image = sequence.Render(i);
|
|
var exif = ExifWriter.BuildJpegApp1(sequence.Metadata[i]);
|
|
File.WriteAllBytes(Path.Combine(folder, $"IMG_{i + 1:0000}.JPG"), JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 90, App1Segments = [exif[4..]] }));
|
|
}
|
|
await service.Indexer.ScanAsync(archive, ScanMode.Full, null, _ => ValueTask.CompletedTask, context.Cancellation);
|
|
var location = (await db.Sequences.ListLocationsAsync(archive.Id, context.Cancellation)).Single();
|
|
return (db, location.Id, root);
|
|
}
|
|
}
|