Files
Chronos/src/Titano.App/Editor/LocalSequenceSource.cs
T
Claude 9cbfaae10d feat(editor): accounts without the Edit right open server sequences read-only
The Server screen offers Open with proxies to viewers; the editor now shows the
sequence with every change disabled and the reason in the tooltips, the session
refuses edits, undo and Optimise, and the source refuses to store a change.
Render says when the account may not render on the server. The event listener
stops cleanly when the editor closes and a late progress event no longer
brings a finished job back to running.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
2026-10-03 16:43:47 +00:00

202 lines
9.4 KiB
C#

using System.IO;
using System.Text.Json;
using Titano.Core.Advice;
using Titano.Core.Analysis;
using Titano.Core.Analysis.Deep;
using Titano.Core.Archiving;
using Titano.Core.Diagnostics;
using Titano.Core.Imaging;
using Titano.Core.IO;
using Titano.Core.Localization;
using Titano.Core.Model;
using Titano.Core.Project;
using Titano.Data;
using Titano.Data.Archiving;
using Titano.Data.Archiving.Jobs;
using Titano.Data.Jobs;
using Titano.Data.Repositories;
namespace Titano.App.Editor;
/// <summary>
/// A sequence of an archive on this PC: rows from the index, originals decoded by the client's decoder chain, the
/// project in <c>.titano/project.json</c> mirrored in the index's settings column (with its hero frame, which the
/// Library shows), jobs on this PC's engine. Project writes follow the archive engine's protocol: under the sequence's
/// lease file (so the server and the job engine wait for it), file first (atomically), then the index with its settings
/// version as an optimistic check.
/// </summary>
public sealed class LocalSequenceSource : ISequenceSource
{
private const int PageSize = 1000;
private const int SaveAttempts = 3;
private const int JobsListed = 200;
private readonly TitanoDatabase _db;
private readonly Guid _sequenceId;
private readonly ImageDecoder _decoder;
private readonly JobEngine? _engine;
private readonly ArchiveServiceOptions _lease;
private string?[] _files = [];
private Guid[] _frameIds = [];
private ArchivePaths? _paths;
private SequencePaths? _folder;
public LocalSequenceSource(TitanoDatabase db, Guid sequenceId, ImageDecoder decoder, JobEngine? engine, ArchiveServiceOptions? lease = null)
{
_db = db;
_sequenceId = sequenceId;
_decoder = decoder;
_engine = engine;
_lease = lease ?? new ArchiveServiceOptions();
if (engine is not null) engine.JobChanged += OnJobChanged;
}
public bool IsRemote => false;
public bool IsReadOnly => false;
public event Action<Job>? JobChanged;
/// <summary>A save changed the frame the Library shows for the sequence: the stored row (any thread).</summary>
public event Action<Sequence>? HeroChanged;
public async Task<SequenceContent> LoadAsync(CancellationToken cancellationToken)
{
var sequence = await _db.Sequences.GetAsync(_sequenceId, cancellationToken) ?? throw Missing();
var archive = await _db.Archives.GetAsync(sequence.ArchiveId, cancellationToken) ?? throw Missing();
var frames = new List<Frame>();
while (true)
{
var page = await _db.Frames.ListBySequenceAsync(_sequenceId, frames.Count > 0 ? frames[^1].Index : -1, PageSize, cancellationToken);
frames.AddRange(page);
if (page.Count < PageSize) break;
}
var renders = await _db.Renders.ListBySequenceAsync(_sequenceId, cancellationToken);
return await Task.Run(() =>
{
var paths = new ArchivePaths(archive.RootPath);
var folder = paths.Sequence(sequence.Folder);
var files = new string?[frames.Count];
for (var i = 0; i < files.Length; i++)
{
if ((frames[i].Flags & FrameFlags.Missing) == 0) files[i] = paths.FromRelative(frames[i].RelativePath);
}
(_paths, _folder, _files, _frameIds) = (paths, folder, files, [.. frames.Select(f => f.Id)]);
var context = SequenceContext.FromFrames(frames);
return new SequenceContent(sequence, frames, ReadProject(sequence, folder), LightAnalyzer.Analyze(frames), ReadReport(folder, frames.Count),
context.SourceWidth, context.SourceHeight, folder.Exports, [.. renders.OrderByDescending(r => r.Created)], SavedCopies.List(folder.MetaDirectory));
}, cancellationToken);
}
public async ValueTask<ImageBuffer?> DecodeAsync(int index, int maxLongEdge, DecodePurpose purpose, CancellationToken cancellationToken)
{
if ((uint)index >= (uint)_files.Length || _files[index] is not { } file) return null;
return await Task.Run(() =>
{
try
{
// Thumbnails take an embedded preview when it is large enough (no RAW development for a filmstrip cell).
var request = new DecodeRequest(file, maxLongEdge, purpose, ForcePreview: purpose == DecodePurpose.Thumbnail);
return _decoder.Decode(request, cancellationToken)?.Pixels;
}
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
{
Log.Warning("editor", $"Frame {file} could not be read", ex);
return null;
}
}, cancellationToken);
}
public Task<ProjectSettings> SaveProjectAsync(ProjectSettings project, ProjectSettings basis, CancellationToken cancellationToken)
{
ArgumentNullException.ThrowIfNull(project);
ArgumentNullException.ThrowIfNull(basis);
var (paths, folder, frameIds) = (_paths, _folder, _frameIds);
if (paths is null || folder is null) throw new InvalidOperationException("LoadAsync first.");
return Task.Run(async () =>
{
ArchiveVolume.EnsureWritable(paths);
using var held = await LeaseFile.AcquireAsync(paths.LocksDirectory, $"seq-{_sequenceId:N}", _lease.Owner, _lease.LeaseWait, _lease.LeaseDuration,
cancellationToken);
for (var attempt = 1; ; attempt++)
{
var row = await _db.Sequences.GetAsync(_sequenceId, cancellationToken) ?? throw Missing();
var stored = ReadProject(row, folder);
var merged = ProjectMerge.SameValues(stored, basis) ? project : ProjectMerge.Merge(basis, project, stored);
var json = merged.ToJson();
if (json == stored.ToJson()) return merged;
AtomicFile.WriteAllText(folder.ProjectPath, json);
var edit = new SequenceEdit { SettingsJson = json, HeroFrameId = merged.HeroFrame == stored.HeroFrame ? null : HeroFrameId(merged, frameIds) };
var result = await _db.Sequences.EditAsync(_sequenceId, edit, row.SettingsVersion, cancellationToken);
switch (result.Outcome)
{
case SequenceEditOutcome.Updated:
if (result.Sequence is { } updated && updated.HeroFrameId != row.HeroFrameId) HeroChanged?.Invoke(updated);
return merged;
case SequenceEditOutcome.NotFound:
throw Missing();
// The settings moved in the index meanwhile (server API): merge again on top of them; the file follows the next write.
case SequenceEditOutcome.Conflict when attempt == SaveAttempts:
throw new IOException(Loc.L("Editor.Error.SaveConflict"));
}
}
}, cancellationToken);
}
public async Task<Guid> SubmitAsync(ArchiveJobRequest request, CancellationToken cancellationToken)
{
if (_engine is null) throw new InvalidOperationException(Loc.L("Editor.Error.NoEngine"));
var job = await _engine.EnqueueAsync(request, cancellationToken: cancellationToken);
return job.Id;
}
public async Task<IReadOnlyList<Job>> ListJobsAsync(CancellationToken cancellationToken) =>
(await _db.Jobs.ListAsync(null, JobsListed, null, cancellationToken)).Items;
public ValueTask DisposeAsync()
{
if (_engine is not null) _engine.JobChanged -= OnJobChanged;
return ValueTask.CompletedTask;
}
/// <summary>The settings in force: the index copy, else <c>project.json</c>, else defaults.</summary>
/// <exception cref="InvalidDataException">The settings are not a project or come from a newer Titano.</exception>
internal static ProjectSettings ReadProject(Sequence sequence, SequencePaths folder)
{
var json = sequence.SettingsJson ?? (File.Exists(folder.ProjectPath) ? File.ReadAllText(folder.ProjectPath) : null);
if (string.IsNullOrWhiteSpace(json)) return new ProjectSettings();
try
{
return ProjectSettings.FromJson(json);
}
catch (JsonException ex)
{
throw new InvalidDataException(Loc.L("Editor.Error.Project"), ex);
}
}
/// <summary>The frame of the project's hero, or <see cref="Guid.Empty"/> (the first frame shows) without one.</summary>
private static Guid HeroFrameId(ProjectSettings project, Guid[] frameIds) =>
project.HeroFrame is { } hero && (uint)hero < (uint)frameIds.Length ? frameIds[hero] : Guid.Empty;
/// <summary>The saved deep report when it describes the current frames.</summary>
private static DeepAnalysisReport? ReadReport(SequencePaths folder, int frameCount)
{
if (!File.Exists(folder.AnalysisPath)) return null;
try
{
var report = DeepAnalysisReport.Load(folder.AnalysisPath);
return report.FrameCount == frameCount ? report : null;
}
catch (Exception ex) when (ex is IOException or InvalidDataException or JsonException)
{
Log.Warning("editor", $"{folder.AnalysisPath} cannot be read", ex);
return null;
}
}
private void OnJobChanged(Job job) => JobChanged?.Invoke(job);
private static InvalidOperationException Missing() => new(Loc.L("Editor.Error.Missing"));
}