Files
Chronos/src/Chronos.Data/Projects/ProjectService.cs
T
Alby96andClaude Opus 5.5 50e28fd63d fix: projects and the workspace copy follow phase 4's folder and conversion rules
Phase 5a was written on an early phase 4a state. On top of phase 4b it now
keeps the rules every writer of a sequence's folder follows, and keeps
project versions intact through Reorganize and conversions:

- ProjectService writes project sidecars, project.json and the settings
  only under the sequence's lease and only in a folder that holds the
  sequence (SequenceFolders.Holds). A folder another index moved away, or
  one another sequence was moved into, is refused with
  SequenceFolderMovedException: reads answer from the index, so no
  project is taken for gone, nothing is written into the other sequence's
  folder and the old folder is never created again. The home reports it
  as out of reach. Full scans and rebuilds reconcile projects the same
  way, and a failure there is logged instead of failing the scan.
- Stored versions park positions by photo and now follow the encodings a
  Replace conversion (or its undo) joined through the sequence's Replaced
  tombstones (PhotoAlias, HomePhotos): Main's mirror, renders of a
  version and workspace media place them on the converted frames.
  ProjectContent.Rebind/SameChoices name parked photos as the frames hold
  them now, so a conversion or a hash since is no "external" Main version
  and no spurious "Modified" in a workspace, and merges see one photo.
- The workspace copy job only reads the archive: it no longer runs the
  archive's proxy pass, makes missing proxies in the workspace, reads
  only a folder that holds the sequence, starts again when the folder
  moved or files were renamed during the copy, resumes from a checkpoint
  of its frames version, and refuses a workspace folder inside any
  library before it writes anything (Errors.Workspace.InsideLibrary).
  The working state keeps its positions by frame where frames stay.
- ArchiveProjectHome looks for a project or version the index does not
  know yet in the sequence's sidecars first (an index taken back from a
  backup, a sequence back from the trash), instead of calling it gone.

Tests cover the moved and taken folder, conversions in the archive and in
the workspace, the copy refusing a workspace in a library, resuming on
other frames, the alias lookup and the rebinding.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 10:14:39 +01:00

602 lines
35 KiB
C#

using System.Text.Json;
using System.Text.Json.Nodes;
using Chronos.Core.Archiving;
using Chronos.Core.Diagnostics;
using Chronos.Core.IO;
using Chronos.Core.Model;
using Chronos.Core.Project;
using Chronos.Data.Archiving;
using Chronos.Data.Repositories;
namespace Chronos.Data.Projects;
/// <summary>Why a project operation was refused (<see cref="ProjectException.Reason"/>).</summary>
public enum ProjectError
{
/// <summary>The sequence is not in the index.</summary>
SequenceNotFound,
/// <summary>The project (or the version named) does not exist, or was deleted.</summary>
NotFound,
/// <summary>The name is blank or longer than <see cref="ProjectService.MaxNameLength"/>.</summary>
InvalidName,
/// <summary>Another project of the sequence has that name (case does not count).</summary>
NameTaken,
/// <summary>The Main project cannot be deleted: it holds the sequence's own settings.</summary>
MainCannotBeDeleted,
}
/// <summary>A project operation was refused; nothing was written.</summary>
public sealed class ProjectException(ProjectError reason, string message) : InvalidOperationException(message)
{
public ProjectError Reason { get; } = reason;
}
/// <summary>What became of a version pushed to its home (<see cref="ProjectService.PushAsync"/>).</summary>
public enum PushOutcome
{
/// <summary>Stored as the project's new head (its parent was the head: a fast-forward).</summary>
Stored,
/// <summary>A version with that id is stored already (a push repeated after its answer was lost): nothing changed.</summary>
AlreadyStored,
/// <summary>The head moved since the version's parent: pull the head, replay the version on it and push again.</summary>
Diverged,
/// <summary>The settings do not match the content hash sent with them: nothing was stored.</summary>
HashMismatch,
/// <summary>The settings are of a newer format than this home reads: nothing was stored.</summary>
NewerFormat,
/// <summary>Not a version of this project: settings that are not portable (they name frames by position), or an id another project holds.</summary>
Invalid,
}
/// <summary>The answer to a push: the outcome, the version as stored (<see cref="PushOutcome.Stored"/>, <see cref="PushOutcome.AlreadyStored"/>) and the project's head.</summary>
public sealed record PushResult(PushOutcome Outcome, ProjectVersion? Version, ProjectVersion? Head);
/// <summary>
/// The frames of a sequence at its home, as project settings name them: their frames version, rows in index order and
/// photos (<see cref="FramePhotos"/>, for <see cref="ProjectContent"/>).
/// </summary>
public sealed record HomeFrames(int FramesVersion, IReadOnlyList<Frame> Frames, FramePhotos Photos);
/// <summary>
/// The projects of the sequences of this PC's archives (owner review 2, R8): the home side of a workspace's push and pull.
/// Every operation runs under the sequence's lease and first catches up: the sidecars into the index
/// (<see cref="ProjectIndexer"/>), the Main project made when the sequence has none (version 1, "imported" from the
/// sequence's settings), and settings another path wrote into the sequence since the last mirror appended to Main as an
/// "external" version (or merged with a push whose mirror a crash cut short). A version is written as a sidecar first
/// (immutable), then the project's record, then the index; a push to Main is also mirrored into the sequence's
/// <c>project.json</c> and settings (positions placed on its frames, through the settings version check), so the code
/// paths that read the sequence's settings keep working and only Main drives the hero frame the Library shows. Other
/// projects stay on this home: copies of a sequence linked to a server sync only its settings, i.e. Main.
/// </summary>
public sealed class ProjectService
{
/// <summary>The name of the project made for every sequence (the desktop shows it in the UI language).</summary>
public const string MainName = "Main";
public const int MaxNameLength = 60;
/// <summary>Frames read at once when a sequence's photos are gathered.</summary>
private const int PageSize = 1000;
/// <summary>How long a read waits for a sequence another writer holds before it answers from the index alone.</summary>
private static readonly TimeSpan ReadWait = TimeSpan.FromSeconds(3);
private readonly ChronosDatabase _db;
private readonly SequenceWriter _writer;
private readonly ProjectIndexer _indexer;
internal ProjectService(ChronosDatabase db, SequenceWriter writer)
{
_db = db;
_writer = writer;
_indexer = new ProjectIndexer(db);
}
/// <summary>The client name versions made here carry (the archive engine's lease owner).</summary>
public string ClientName => _writer.Options.Owner;
/// <summary>The live projects of a sequence, Main first; read from the index alone while the archive is offline.</summary>
/// <exception cref="ProjectException">The sequence is not in the index.</exception>
public async Task<IReadOnlyList<SequenceProject>> ListAsync(Guid sequenceId, CancellationToken cancellationToken = default)
{
await ReadAsync(sequenceId, cancellationToken).ConfigureAwait(false);
return await _db.Projects.ListBySequenceAsync(sequenceId, includeDeleted: false, cancellationToken).ConfigureAwait(false);
}
/// <summary>The sequence's Main project, made now (from its settings) when it has none.</summary>
/// <exception cref="ProjectException">The sequence is not in the index.</exception>
/// <exception cref="ArchiveOfflineException">The archive is offline and the index has no Main project yet.</exception>
public async Task<SequenceProject> MainAsync(Guid sequenceId, CancellationToken cancellationToken = default)
{
await ReadAsync(sequenceId, cancellationToken).ConfigureAwait(false);
if (await _db.Projects.GetMainAsync(sequenceId, cancellationToken).ConfigureAwait(false) is { } main) return main;
// The catch-up could not run (the archive offline, the sequence busy): it runs now, or says why it cannot.
return await UnderLeaseAsync(sequenceId, async (_, ct) => (await _db.Projects.GetMainAsync(sequenceId, ct).ConfigureAwait(false))!, cancellationToken)
.ConfigureAwait(false);
}
public Task<SequenceProject?> GetAsync(Guid projectId, CancellationToken cancellationToken = default) => _db.Projects.GetAsync(projectId, cancellationToken);
/// <summary>
/// A new project of the sequence named <paramref name="name"/>, whose first version (kind "imported") holds the settings of
/// <paramref name="fromVersionId"/> (a version of any project of the sequence), or of Main's head.
/// </summary>
/// <exception cref="ProjectException">Unknown sequence or version, or the name is invalid or taken.</exception>
public Task<SequenceProject> CreateAsync(Guid sequenceId, string name, Guid? fromVersionId = null, string? author = null,
CancellationToken cancellationToken = default)
{
var trimmed = ValidName(name);
return UnderLeaseAsync(sequenceId, async (context, ct) =>
{
await EnsureNameFreeAsync(sequenceId, null, trimmed, ct).ConfigureAwait(false);
ProjectVersion source;
if (fromVersionId is { } from)
{
source = await _db.Projects.GetVersionAsync(from, ct).ConfigureAwait(false) is { } version
&& await _db.Projects.GetAsync(version.ProjectId, ct).ConfigureAwait(false) is { SequenceId: var owner } && owner == sequenceId
? version
: throw new ProjectException(ProjectError.NotFound, $"Version {from} is not a version of sequence {sequenceId}.");
}
else
{
var main = (await _db.Projects.GetMainAsync(sequenceId, ct).ConfigureAwait(false))!;
source = (await _db.Projects.GetVersionAsync(main.HeadVersionId!.Value, ct).ConfigureAwait(false))!;
}
var now = DateTimeOffset.UtcNow;
var project = new SequenceProject
{
Id = Guid.CreateVersion7(),
SequenceId = sequenceId,
Name = trimmed,
CreatedBy = author,
CreatedAt = now,
UpdatedAt = now,
};
var first = new ProjectVersion
{
Id = Guid.CreateVersion7(),
ProjectId = project.Id,
Number = 1,
Kind = ProjectVersionKind.Imported,
Author = author,
ClientName = ClientName,
SettingsJson = source.SettingsJson,
ContentHash = source.ContentHash,
SettingsFormat = source.SettingsFormat,
FramesVersion = source.FramesVersion,
CreatedAt = now,
StoredAt = now,
};
return await AddProjectAsync(context.Folder, project, first, ct).ConfigureAwait(false);
}, cancellationToken);
}
/// <summary>Gives a project another name.</summary>
/// <exception cref="ProjectException">Unknown project, or the name is invalid or taken.</exception>
public async Task<SequenceProject> RenameAsync(Guid projectId, string name, CancellationToken cancellationToken = default)
{
var trimmed = ValidName(name);
var project = await LiveAsync(projectId, cancellationToken).ConfigureAwait(false);
return await UnderLeaseAsync(project.SequenceId, async (context, ct) =>
{
var current = await LiveAsync(projectId, ct).ConfigureAwait(false);
if (current.Name == trimmed) return current;
await EnsureNameFreeAsync(current.SequenceId, projectId, trimmed, ct).ConfigureAwait(false);
var renamed = current with { Name = trimmed, UpdatedAt = DateTimeOffset.UtcNow };
ProjectSidecars.WriteRecord(context.Folder.ProjectRecordPath(projectId), ProjectRecord.Of(renamed));
await _db.Projects.UpdateAsync(renamed, ct).ConfigureAwait(false);
return renamed;
}, cancellationToken).ConfigureAwait(false);
}
/// <summary>
/// Deletes a project: its record says so, its folder moves to <c>.chronos/projects/.trash</c> (kept, never erased by
/// Chronos) and it leaves the listing.
/// </summary>
/// <exception cref="ProjectException">Unknown project, or the Main project.</exception>
public async Task DeleteAsync(Guid projectId, CancellationToken cancellationToken = default)
{
var project = await LiveAsync(projectId, cancellationToken).ConfigureAwait(false);
if (project.IsMain) throw new ProjectException(ProjectError.MainCannotBeDeleted, "The Main project cannot be deleted.");
await UnderLeaseAsync(project.SequenceId, async (context, ct) =>
{
var current = await LiveAsync(projectId, ct).ConfigureAwait(false);
var now = DateTimeOffset.UtcNow;
var deleted = current with { DeletedAt = now, UpdatedAt = now };
ProjectSidecars.WriteRecord(context.Folder.ProjectRecordPath(projectId), ProjectRecord.Of(deleted));
Directory.CreateDirectory(context.Folder.ProjectsTrashDirectory);
Directory.Move(context.Folder.ProjectDirectory(projectId),
Path.Combine(context.Folder.ProjectsTrashDirectory, projectId.ToString("N") + "-" + now.UtcTicks.ToString(System.Globalization.CultureInfo.InvariantCulture)));
await _db.Projects.UpdateAsync(deleted, ct).ConfigureAwait(false);
return true;
}, cancellationToken).ConfigureAwait(false);
}
/// <summary>One page of a project's history, newest first: the versions numbered below <paramref name="beforeNumber"/> (from the head when null).</summary>
/// <exception cref="ProjectException">Unknown project.</exception>
public async Task<IReadOnlyList<ProjectVersion>> HistoryAsync(Guid projectId, int? beforeNumber = null, int limit = 50, CancellationToken cancellationToken = default)
{
var project = await KnownAsync(projectId, cancellationToken).ConfigureAwait(false);
await ReadAsync(project.SequenceId, cancellationToken).ConfigureAwait(false);
return await _db.Projects.ListVersionsAsync(projectId, beforeNumber, limit, cancellationToken).ConfigureAwait(false);
}
/// <summary>The versions numbered above <paramref name="afterNumber"/>, oldest first: what a workspace pulls.</summary>
/// <exception cref="ProjectException">Unknown project.</exception>
public async Task<IReadOnlyList<ProjectVersion>> VersionsAfterAsync(Guid projectId, int afterNumber, int limit = 100, CancellationToken cancellationToken = default)
{
var project = await KnownAsync(projectId, cancellationToken).ConfigureAwait(false);
await ReadAsync(project.SequenceId, cancellationToken).ConfigureAwait(false);
return await _db.Projects.ListVersionsAfterAsync(projectId, afterNumber, limit, cancellationToken).ConfigureAwait(false);
}
/// <summary>A version by id; null when the index has none.</summary>
public Task<ProjectVersion?> GetVersionAsync(Guid versionId, CancellationToken cancellationToken = default) =>
_db.Projects.GetVersionAsync(versionId, cancellationToken);
/// <summary>The newest version of a project, after catching up.</summary>
/// <exception cref="ProjectException">Unknown project.</exception>
public async Task<ProjectVersion> HeadAsync(Guid projectId, CancellationToken cancellationToken = default)
{
var project = await KnownAsync(projectId, cancellationToken).ConfigureAwait(false);
await ReadAsync(project.SequenceId, cancellationToken).ConfigureAwait(false);
project = await KnownAsync(projectId, cancellationToken).ConfigureAwait(false);
return await _db.Projects.GetVersionAsync(project.HeadVersionId ?? Guid.Empty, cancellationToken).ConfigureAwait(false)
?? throw new ProjectException(ProjectError.NotFound, $"Project {projectId} has no version.");
}
/// <summary>
/// Stores <paramref name="version"/> (made in a workspace from its <see cref="ProjectVersion.ParentId"/>) as the
/// project's new head when its parent is the head: its number is the head's plus one, whatever it says. Repeated with
/// the id of a stored version, it answers as the first time. Its settings must be portable (positions parked by photo)
/// and match their content hash. A version of Main is mirrored into the sequence's settings.
/// </summary>
/// <exception cref="ProjectException">Unknown project.</exception>
public async Task<PushResult> PushAsync(Guid projectId, ProjectVersion version, CancellationToken cancellationToken = default)
{
ArgumentNullException.ThrowIfNull(version);
var project = await LiveAsync(projectId, cancellationToken).ConfigureAwait(false);
return await UnderLeaseAsync(project.SequenceId, async (context, ct) =>
{
var current = await LiveAsync(projectId, ct).ConfigureAwait(false);
var head = await _db.Projects.GetVersionAsync(current.HeadVersionId ?? Guid.Empty, ct).ConfigureAwait(false);
if (await _db.Projects.GetVersionAsync(version.Id, ct).ConfigureAwait(false) is { } existing)
{
return existing.ProjectId == projectId && string.Equals(existing.ContentHash, version.ContentHash, StringComparison.OrdinalIgnoreCase)
? new PushResult(PushOutcome.AlreadyStored, existing, head)
: new PushResult(PushOutcome.Invalid, null, head);
}
if (!ProjectContent.Verifies(version.SettingsJson, version.ContentHash)) return new PushResult(PushOutcome.HashMismatch, null, head);
var format = ProjectContent.FormatOf(version.SettingsJson);
if (format > ProjectSettings.CurrentVersion) return new PushResult(PushOutcome.NewerFormat, null, head);
if (!IsPortable(version.SettingsJson)) return new PushResult(PushOutcome.Invalid, null, head);
if (version.ParentId != current.HeadVersionId) return new PushResult(PushOutcome.Diverged, null, head);
var stored = version with
{
ProjectId = projectId,
Number = current.HeadNumber + 1,
ContentHash = version.ContentHash.ToLowerInvariant(),
SettingsFormat = format,
StoredAt = DateTimeOffset.UtcNow,
};
current = await AppendAsync(context.Folder, current, stored, ct).ConfigureAwait(false);
if (current.IsMain) await MirrorAsync(context, current, stored, ct).ConfigureAwait(false);
return new PushResult(PushOutcome.Stored, stored, stored);
}, cancellationToken).ConfigureAwait(false);
}
/// <summary>The frames of a sequence as they are indexed now, with its frames version.</summary>
/// <exception cref="ProjectException">The sequence is not in the index.</exception>
public async Task<HomeFrames> FramesAsync(Guid sequenceId, CancellationToken cancellationToken = default)
{
for (var attempt = 0; ; attempt++)
{
var before = await _db.Sequences.GetAsync(sequenceId, cancellationToken).ConfigureAwait(false) ?? throw SequenceMissing(sequenceId);
var frames = await LoadFramesAsync(sequenceId, cancellationToken).ConfigureAwait(false);
var after = await _db.Sequences.GetAsync(sequenceId, cancellationToken).ConfigureAwait(false) ?? throw SequenceMissing(sequenceId);
if (after.FramesVersion == before.FramesVersion || attempt == 2) return new HomeFrames(after.FramesVersion, frames.Frames, frames.Photos);
}
}
/// <summary>
/// Catches the sequence's projects up under its lease (see the class remarks) before a read; the index alone answers while
/// the archive is offline or the sequence busy for longer than the lease wait.
/// </summary>
private async Task ReadAsync(Guid sequenceId, CancellationToken cancellationToken)
{
try
{
await UnderLeaseAsync(sequenceId, (_, _) => Task.FromResult(true), cancellationToken, ReadWait).ConfigureAwait(false);
}
catch (Exception ex) when (ex is ArchiveOfflineException or LeaseUnavailableException or SequenceFolderMovedException)
{
Log.Info("projects", $"The projects of sequence {sequenceId} are read from the index: {ex.Message}");
}
}
/// <summary>
/// Runs <paramref name="work"/> under the sequence's lease, after catching its projects up, in the folder the index has
/// for the sequence as read under the lease (a Reorganize moves it under the same lease), which must hold it.
/// </summary>
/// <exception cref="SequenceFolderMovedException">
/// The folder does not hold the sequence (another index of the archive moved it, maybe another sequence in): nothing is
/// read from it or written into it, so no project is taken for gone and no file lands in another sequence's folder.
/// </exception>
private async Task<T> UnderLeaseAsync<T>(Guid sequenceId, Func<LeaseContext, CancellationToken, Task<T>> work, CancellationToken cancellationToken,
TimeSpan? wait = null)
{
var sequence = await _db.Sequences.GetAsync(sequenceId, cancellationToken).ConfigureAwait(false) ?? throw SequenceMissing(sequenceId);
var archive = await _db.Archives.GetAsync(sequence.ArchiveId, cancellationToken).ConfigureAwait(false) ?? throw SequenceMissing(sequenceId);
var paths = new ArchivePaths(archive.RootPath);
ArchiveVolume.EnsureWritable(paths);
await using (await _writer.LockAsync(paths, sequenceId, wait, cancellationToken).ConfigureAwait(false))
{
var row = await _db.Sequences.GetAsync(sequenceId, cancellationToken).ConfigureAwait(false) ?? throw SequenceMissing(sequenceId);
var folder = paths.Sequence(row.Folder);
if (!SequenceFolders.Holds(folder, sequenceId)) throw new SequenceFolderMovedException();
var context = new LeaseContext(folder, row);
await CatchUpAsync(context, cancellationToken).ConfigureAwait(false);
return await work(context, cancellationToken).ConfigureAwait(false);
}
}
/// <summary>The sidecars into the index, the Main project made, and Main in step with the sequence's settings.</summary>
private async Task CatchUpAsync(LeaseContext context, CancellationToken cancellationToken)
{
await _indexer.ReconcileAsync(context.Folder, context.Row.Id, cancellationToken).ConfigureAwait(false);
var main = await _db.Projects.GetMainAsync(context.Row.Id, cancellationToken).ConfigureAwait(false);
if (main?.HeadVersionId is null)
{
await MakeMainAsync(context, main, cancellationToken).ConfigureAwait(false);
return;
}
if (main.MirroredVersionId == main.HeadVersionId && main.MirroredSettingsVersion == context.Row.SettingsVersion) return;
var head = (await _db.Projects.GetVersionAsync(main.HeadVersionId.Value, cancellationToken).ConfigureAwait(false))!;
var frames = await LoadFramesAsync(context.Row.Id, cancellationToken).ConfigureAwait(false);
if (CurrentPortable(context, frames.Photos) is not { } current)
{
// Settings no Chronos can read (or of a newer one): left as they are, recorded as seen.
await _db.Projects.SetMirroredAsync(main.Id, main.HeadVersionId, context.Row.SettingsVersion, cancellationToken).ConfigureAwait(false);
return;
}
// The head parks its photos as the frames held them when it was made: a conversion or a hash since names them anew.
var sameAsHead = ProjectContent.SameChoices(head.SettingsJson, current, frames.Photos);
if (main.MirroredVersionId == main.HeadVersionId || main.MirroredVersionId is null)
{
// Only the sequence's settings version moved (settings another path wrote, or only its title or tags), or the index
// was rebuilt and knows no mirror: settings that differ from the head are its newest state.
var latest = sameAsHead ? head : await AppendDerivedAsync(context, main, head, current, ProjectVersionKind.External, cancellationToken).ConfigureAwait(false);
await _db.Projects.SetMirroredAsync(main.Id, latest.Id, context.Row.SettingsVersion, cancellationToken).ConfigureAwait(false);
return;
}
// The head is newer than the mirror: a push whose mirror a crash (or a settings edit at the same moment) cut short.
if (sameAsHead)
{
await _db.Projects.SetMirroredAsync(main.Id, head.Id, context.Row.SettingsVersion, cancellationToken).ConfigureAwait(false);
return;
}
var mirrored = await _db.Projects.GetVersionAsync(main.MirroredVersionId.Value, cancellationToken).ConfigureAwait(false);
if (main.MirroredSettingsVersion == context.Row.SettingsVersion || mirrored is null || ProjectContent.SameChoices(mirrored.SettingsJson, current, frames.Photos))
{
// Nobody changed the settings since the last mirror: the mirror completes.
await MirrorAsync(context, main, head, cancellationToken).ConfigureAwait(false);
return;
}
// Both moved: the settings written meanwhile merge with the head (the version made in a workspace wins where both changed),
// each photo named as the frames hold it now so the same photo merges as one.
var merged = ProjectMerge.Merge(ProjectMerge.Read(ProjectContent.Rebind(mirrored.SettingsJson, frames.Photos)),
ProjectMerge.Read(ProjectContent.Rebind(head.SettingsJson, frames.Photos)), ProjectMerge.Read(ProjectContent.Rebind(current, frames.Photos)));
var version = await AppendDerivedAsync(context, main, head, ProjectContent.Canonical(merged.ToJson()), ProjectVersionKind.Merge, cancellationToken)
.ConfigureAwait(false);
main = (await _db.Projects.GetAsync(main.Id, cancellationToken).ConfigureAwait(false))!;
await MirrorAsync(context, main, version, cancellationToken).ConfigureAwait(false);
}
/// <summary>The Main project of a sequence that has none (or one without versions): version 1 from the sequence's settings.</summary>
private async Task MakeMainAsync(LeaseContext context, SequenceProject? existing, CancellationToken cancellationToken)
{
var frames = await LoadFramesAsync(context.Row.Id, cancellationToken).ConfigureAwait(false);
var portable = CurrentPortable(context, frames.Photos) ?? ProjectContent.ToPortable(new ProjectSettings(), frames.Photos);
var now = DateTimeOffset.UtcNow;
var project = existing ?? new SequenceProject
{
Id = Guid.CreateVersion7(),
SequenceId = context.Row.Id,
Name = await FreeMainNameAsync(context.Row.Id, cancellationToken).ConfigureAwait(false),
IsMain = true,
CreatedAt = now,
UpdatedAt = now,
};
var first = NewVersion(project.Id, null, project.HeadNumber + 1, ProjectVersionKind.Imported, portable, context.Row.FramesVersion, now);
if (existing is null)
{
await AddProjectAsync(context.Folder, project with { MirroredSettingsVersion = context.Row.SettingsVersion, MirroredVersionId = first.Id }, first,
cancellationToken).ConfigureAwait(false);
}
else
{
var updated = await AppendAsync(context.Folder, existing, first, cancellationToken).ConfigureAwait(false);
await _db.Projects.SetMirroredAsync(updated.Id, first.Id, context.Row.SettingsVersion, cancellationToken).ConfigureAwait(false);
}
}
/// <summary>"Main", or "Main (2)"… when a project of that name exists already (one made before the sequence had its Main).</summary>
private async Task<string> FreeMainNameAsync(Guid sequenceId, CancellationToken cancellationToken)
{
var names = (await _db.Projects.ListBySequenceAsync(sequenceId, includeDeleted: false, cancellationToken).ConfigureAwait(false))
.Select(p => p.Name).ToHashSet(StringComparer.OrdinalIgnoreCase);
var name = MainName;
for (var n = 2; names.Contains(name); n++) name = $"{MainName} ({n})";
return name;
}
/// <summary>The portable form of the sequence's settings in force (index, else <c>project.json</c>, else defaults); null when unreadable or newer.</summary>
private static string? CurrentPortable(LeaseContext context, FramePhotos photos)
{
var json = context.Row.SettingsJson ?? (File.Exists(context.Folder.ProjectPath) ? AtomicFile.ReadAllText(context.Folder.ProjectPath) : null)
?? new ProjectSettings().ToJson();
try
{
if (ProjectContent.FormatOf(json) > ProjectSettings.CurrentVersion) return null;
return ProjectContent.ToPortable(json, photos);
}
catch (JsonException ex)
{
Log.Warning("projects", $"The settings of sequence {context.Row.Id} cannot be read", ex);
return null;
}
}
/// <summary>A version made here (catch-up or merge) appended to Main.</summary>
private async Task<ProjectVersion> AppendDerivedAsync(LeaseContext context, SequenceProject main, ProjectVersion head, string portable, ProjectVersionKind kind,
CancellationToken cancellationToken)
{
var version = NewVersion(main.Id, head.Id, main.HeadNumber + 1, kind, portable, context.Row.FramesVersion, DateTimeOffset.UtcNow);
await AppendAsync(context.Folder, main, version, cancellationToken).ConfigureAwait(false);
return version;
}
private ProjectVersion NewVersion(Guid projectId, Guid? parentId, int number, ProjectVersionKind kind, string portable, int framesVersion, DateTimeOffset now) => new()
{
Id = Guid.CreateVersion7(),
ProjectId = projectId,
ParentId = parentId,
Number = number,
Kind = kind,
ClientName = ClientName,
SettingsJson = portable,
ContentHash = ProjectContent.Hash(portable),
SettingsFormat = ProjectContent.FormatOf(portable),
FramesVersion = framesVersion,
CreatedAt = now,
StoredAt = now,
};
/// <summary>A new project with its first version: sidecars (version, then record), then both rows in one transaction.</summary>
private async Task<SequenceProject> AddProjectAsync(SequencePaths folder, SequenceProject project, ProjectVersion first, CancellationToken cancellationToken)
{
var withHead = project with { HeadVersionId = first.Id, HeadNumber = first.Number };
ProjectSidecars.WriteVersion(folder.VersionPath(project.Id, first.Number, first.Id), first);
ProjectSidecars.WriteRecord(folder.ProjectRecordPath(project.Id), ProjectRecord.Of(withHead));
await using var tx = await _db.BeginAsync(cancellationToken).ConfigureAwait(false);
await tx.Projects.InsertAsync(withHead with { HeadVersionId = null, HeadNumber = 0 }, cancellationToken).ConfigureAwait(false);
await tx.Projects.InsertVersionAsync(first, cancellationToken).ConfigureAwait(false);
await tx.Projects.UpdateAsync(withHead, cancellationToken).ConfigureAwait(false);
await tx.CommitAsync(cancellationToken).ConfigureAwait(false);
return withHead;
}
/// <summary>A version appended to a project: its sidecar, the record's head, then the version row and the head in one transaction.</summary>
private async Task<SequenceProject> AppendAsync(SequencePaths folder, SequenceProject project, ProjectVersion version, CancellationToken cancellationToken)
{
var now = DateTimeOffset.UtcNow;
var advanced = project with { HeadVersionId = version.Id, HeadNumber = version.Number, UpdatedAt = now };
ProjectSidecars.WriteVersion(folder.VersionPath(project.Id, version.Number, version.Id), version);
ProjectSidecars.WriteRecord(folder.ProjectRecordPath(project.Id), ProjectRecord.Of(advanced));
await using var tx = await _db.BeginAsync(cancellationToken).ConfigureAwait(false);
await tx.Projects.InsertVersionAsync(version, cancellationToken).ConfigureAwait(false);
if (!await tx.Projects.AdvanceHeadAsync(project.Id, project.HeadNumber, version.Id, version.Number, now, cancellationToken).ConfigureAwait(false))
throw new IOException($"The head of project {project.Id} moved in the index while its lease was held.");
await tx.CommitAsync(cancellationToken).ConfigureAwait(false);
return advanced;
}
/// <summary>
/// Writes Main's <paramref name="version"/> into the sequence: its positions placed on the sequence's frames, then
/// <c>project.json</c> and the index's settings (and hero frame) with the settings version as the check. Recorded as
/// mirrored when the index took it; a settings edit that won the race is caught up by the next operation (merged).
/// </summary>
private async Task MirrorAsync(LeaseContext context, SequenceProject main, ProjectVersion version, CancellationToken cancellationToken)
{
var frames = await LoadFramesAsync(context.Row.Id, cancellationToken).ConfigureAwait(false);
var placed = ProjectSettings.FromJson(ProjectContent.Place(version.SettingsJson, frames.Photos));
var json = placed.ToJson();
Directory.CreateDirectory(context.Folder.MetaDirectory);
AtomicFile.WriteAllText(context.Folder.ProjectPath, json);
var hero = placed.HeroFrame is { } index && (uint)index < (uint)frames.Frames.Count ? frames.Frames[index].Id : Guid.Empty;
var result = await _db.Sequences.EditAsync(context.Row.Id, new SequenceEdit { SettingsJson = json, HeroFrameId = hero }, context.Row.SettingsVersion,
context.Row.FramesVersion, cancellationToken).ConfigureAwait(false);
if (result is { Outcome: SequenceEditOutcome.Updated, Sequence: { } updated })
{
context.Row = updated;
await _db.Projects.SetMirroredAsync(main.Id, version.Id, updated.SettingsVersion, cancellationToken).ConfigureAwait(false);
}
else
{
Log.Info("projects", $"The settings of sequence {context.Row.Id} changed while version {version.Number} of Main was mirrored; merged next time");
}
}
/// <summary>Whether settings name no frame by position (every position parked by photo).</summary>
private static bool IsPortable(string json)
{
try
{
return JsonNode.Parse(json, new JsonNodeOptions { PropertyNameCaseInsensitive = true }) is JsonObject project
&& project["excludedFrames"] is null or JsonArray { Count: 0 }
&& project["heroFrame"] is null
&& (project["camera"] is not JsonObject camera || camera["keyframes"] is null or JsonArray { Count: 0 });
}
catch (Exception ex) when (ex is JsonException or ArgumentException)
{
return false;
}
}
private async Task<(IReadOnlyList<Frame> Frames, FramePhotos Photos)> LoadFramesAsync(Guid sequenceId, CancellationToken cancellationToken)
{
var frames = new List<Frame>();
for (var after = -1; ;)
{
var page = await _db.Frames.ListBySequenceAsync(sequenceId, after, PageSize, cancellationToken).ConfigureAwait(false);
frames.AddRange(page);
if (page.Count < PageSize) break;
after = page[^1].Index;
}
// With the encodings conversions joined: a version parked on a photo before its file was converted still finds its frame.
return (frames, HomePhotos.Of(frames, await HomePhotos.AliasesAsync(_db, sequenceId, cancellationToken).ConfigureAwait(false)));
}
private async Task EnsureNameFreeAsync(Guid sequenceId, Guid? projectId, string name, CancellationToken cancellationToken)
{
var projects = await _db.Projects.ListBySequenceAsync(sequenceId, includeDeleted: false, cancellationToken).ConfigureAwait(false);
if (projects.Any(p => p.Id != projectId && string.Equals(p.Name, name, StringComparison.OrdinalIgnoreCase)))
throw new ProjectException(ProjectError.NameTaken, $"Sequence {sequenceId} has a project named '{name}'.");
}
private static string ValidName(string name)
{
var trimmed = name?.Trim() ?? string.Empty;
return trimmed.Length is > 0 and <= MaxNameLength && !trimmed.Any(char.IsControl)
? trimmed
: throw new ProjectException(ProjectError.InvalidName, "A project name has 1 to 60 characters.");
}
private async Task<SequenceProject> KnownAsync(Guid projectId, CancellationToken cancellationToken) =>
await _db.Projects.GetAsync(projectId, cancellationToken).ConfigureAwait(false)
?? throw new ProjectException(ProjectError.NotFound, $"Project {projectId} does not exist.");
private async Task<SequenceProject> LiveAsync(Guid projectId, CancellationToken cancellationToken) =>
await KnownAsync(projectId, cancellationToken).ConfigureAwait(false) is { DeletedAt: null } project
? project
: throw new ProjectException(ProjectError.NotFound, $"Project {projectId} was deleted.");
private static ProjectException SequenceMissing(Guid sequenceId) => new(ProjectError.SequenceNotFound, $"Sequence {sequenceId} is not in the index.");
/// <summary>The sequence as read under its lease (the mirror moves its settings version) and its folder.</summary>
private sealed class LeaseContext(SequencePaths folder, Sequence row)
{
public SequencePaths Folder { get; } = folder;
public Sequence Row { get; set; } = row;
}
}