Owner review 2, R6: the web panel manages the library without editing it, so the engine and the server must delete single photos safely, keep them out of sync afterwards, and let an administrator restore or finally erase the trash. - Migration 0008: frame_removals (tombstones by sequence and SHA-256, reason, replacement); the sidecar gains "removed" (omitted when empty) and frames a reserved "source"; the indexer writes the tombstones on every sync, so a rebuild keeps them, and drops a hero frame that is gone. - FrameTrash: dry run (busy, frames changed, offline, would empty), delete under the sequence lease with a write-ahead journal that the next writer undoes after a crash, files to trash/photos/<seq>-<time>/originals with a record, sidecar without the frames plus tombstones, index sync clearing analyses, thumbnails and proxies, proxies renamed to follow their frames, follow-up jobs. Restore re-hashes every file, keeps mismatches in the trash, puts the same frame records back and drops their tombstones, or files the photos into a new sequence through the ingest when theirs is gone. - Project positions on vanished photos are translated by photo and wait as pending frames, so they come back with a restore. - Trash entries have a kind (sequence, photos, replaced); emptying is a dry run with a fingerprint and a new EmptyTrash job (18) that erases exactly the planned entries, refuses a stale plan and erases replaced originals only while their replacements still hash right. - Sync honours tombstones: nothing one side deleted is offered back, local files are never deleted, replaced photos count as their replacement; the server answers an upload of a tombstoned SHA-256 as already there. - Server: sequence thumbnail, photo delete, bulk delete/retag/jobs, trash list/restore/empty endpoints with their error messages; a verify of sequences now targets their archive (POST /jobs failed before). - Desktop trash dialog lists photo entries and empties the trash after a typed confirmation through the same job. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 35bb56690a1d69eae57153d036e1409201cd73f7)
195 lines
8.4 KiB
C#
195 lines
8.4 KiB
C#
using Chronos.Data.Migrations;
|
|
using Chronos.Data.Repositories;
|
|
using Chronos.Data.Sqlite;
|
|
|
|
namespace Chronos.Data;
|
|
|
|
/// <summary>The repositories of the Chronos schema, bound either to the database (one session per call) or to one transaction.</summary>
|
|
public abstract class ChronosRepositories
|
|
{
|
|
private protected ChronosRepositories(DbAccess access)
|
|
{
|
|
Archives = new ArchiveRepository(access);
|
|
Sequences = new SequenceRepository(access);
|
|
Frames = new FrameRepository(access);
|
|
Renders = new RenderRepository(access);
|
|
Jobs = new JobRepository(access);
|
|
MediaCards = new MediaCardRepository(access);
|
|
Users = new UserRepository(access);
|
|
Tokens = new TokenRepository(access);
|
|
RenderNodes = new RenderNodeRepository(access);
|
|
Settings = new SettingsRepository(access);
|
|
Tags = new TagRepository(access);
|
|
Audit = new AuditRepository(access);
|
|
Uploads = new UploadRepository(access);
|
|
Schedules = new ScheduleRepository(access);
|
|
FrameRemovals = new FrameRemovalRepository(access);
|
|
}
|
|
|
|
public ArchiveRepository Archives { get; }
|
|
public SequenceRepository Sequences { get; }
|
|
public FrameRepository Frames { get; }
|
|
public RenderRepository Renders { get; }
|
|
public JobRepository Jobs { get; }
|
|
public MediaCardRepository MediaCards { get; }
|
|
public UserRepository Users { get; }
|
|
public TokenRepository Tokens { get; }
|
|
public RenderNodeRepository RenderNodes { get; }
|
|
public SettingsRepository Settings { get; }
|
|
public TagRepository Tags { get; }
|
|
public AuditRepository Audit { get; }
|
|
public UploadRepository Uploads { get; }
|
|
|
|
/// <summary>Scheduled jobs (owner review 2, R10).</summary>
|
|
public ScheduleRepository Schedules { get; }
|
|
|
|
/// <summary>Tombstones of the photos removed from sequences (owner review 2, R6).</summary>
|
|
public FrameRemovalRepository FrameRemovals { get; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Entry point of the data layer: opens SQLite or PostgreSQL, migrates the schema and exposes the repositories.
|
|
/// Each repository call borrows a pooled session; use <see cref="BeginAsync"/> to group calls atomically.
|
|
/// </summary>
|
|
/// <example>
|
|
/// <code>
|
|
/// await using var db = await ChronosDatabase.OpenAsync(DatabaseOptions.Parse(connectionString), ct);
|
|
/// var page = await db.Sequences.ListAsync(new SequenceQuery { Year = 2026 }, ct);
|
|
/// await using var tx = await db.BeginAsync(ct);
|
|
/// await tx.Frames.InsertAsync(frame, ct);
|
|
/// await tx.Sequences.RefreshStatsAsync(frame.SequenceId, ct);
|
|
/// await tx.CommitAsync(ct);
|
|
/// </code>
|
|
/// </example>
|
|
public sealed class ChronosDatabase : ChronosRepositories, IAsyncDisposable
|
|
{
|
|
private ChronosDatabase(IDatabase database, int schemaVersion)
|
|
: base(new DbAccess(database))
|
|
{
|
|
Database = database;
|
|
SchemaVersion = schemaVersion;
|
|
}
|
|
|
|
/// <summary>The underlying engine, for raw sessions and engine-specific features (backups, LISTEN).</summary>
|
|
public IDatabase Database { get; }
|
|
|
|
public Dialect Dialect => Database.Dialect;
|
|
|
|
/// <summary>Schema version after migration.</summary>
|
|
public int SchemaVersion { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Opens the database and applies pending migrations. Throws <see cref="SchemaTooNewException"/> when a newer
|
|
/// build already migrated it.
|
|
/// </summary>
|
|
public static async Task<ChronosDatabase> OpenAsync(DatabaseOptions options, CancellationToken cancellationToken = default)
|
|
{
|
|
var database = DatabaseFactory.Open(options);
|
|
try
|
|
{
|
|
var version = await MigrationRunner.MigrateAsync(database, cancellationToken).ConfigureAwait(false);
|
|
return new ChronosDatabase(database, version);
|
|
}
|
|
catch
|
|
{
|
|
await database.DisposeAsync().ConfigureAwait(false);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
/// <summary>Starts a transaction whose repositories all run on it; dispose without committing to roll back.</summary>
|
|
public async Task<ChronosTransaction> BeginAsync(CancellationToken cancellationToken = default)
|
|
{
|
|
var session = await Database.OpenAsync(cancellationToken).ConfigureAwait(false);
|
|
try
|
|
{
|
|
return new ChronosTransaction(session, await session.BeginAsync(cancellationToken).ConfigureAwait(false));
|
|
}
|
|
catch
|
|
{
|
|
await session.DisposeAsync().ConfigureAwait(false);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
/// <summary>SQLite only: writes a <c>VACUUM INTO</c> copy into <paramref name="directory"/>, keeping the newest <paramref name="keep"/>.</summary>
|
|
public Task<string> BackupAsync(string directory, int keep = 3, CancellationToken cancellationToken = default) =>
|
|
AsSqlite().BackupAsync(directory, keep, cancellationToken);
|
|
|
|
/// <summary>SQLite only: replaces the database with a backup, then migrates it to this build's schema.</summary>
|
|
public async Task RestoreAsync(string backupPath, CancellationToken cancellationToken = default)
|
|
{
|
|
await AsSqlite().RestoreAsync(backupPath, cancellationToken).ConfigureAwait(false);
|
|
SchemaVersion = await MigrationRunner.MigrateAsync(Database, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// SQLite only: the size of the database file and the bytes its free pages hold, which <see cref="VacuumAsync"/> gives
|
|
/// back; null on PostgreSQL, whose autovacuum keeps the tables compact by itself.
|
|
/// </summary>
|
|
public async Task<IndexSpace?> SpaceAsync(CancellationToken cancellationToken = default)
|
|
{
|
|
if (Dialect != Dialect.Sqlite) return null;
|
|
await using var session = await Database.OpenAsync(cancellationToken).ConfigureAwait(false);
|
|
var pageSize = await session.ScalarAsync<long>("PRAGMA page_size", [], cancellationToken).ConfigureAwait(false);
|
|
var pages = await session.ScalarAsync<long>("PRAGMA page_count", [], cancellationToken).ConfigureAwait(false);
|
|
var free = await session.ScalarAsync<long>("PRAGMA freelist_count", [], cancellationToken).ConfigureAwait(false);
|
|
return new IndexSpace(pages * pageSize, free * pageSize);
|
|
}
|
|
|
|
/// <summary>
|
|
/// SQLite only: rewrites the database without its free pages (<c>VACUUM</c>, BRIEF §12.5 Maintenance). Writers wait
|
|
/// meanwhile; readers continue on the previous snapshot. Returns the space before and after.
|
|
/// </summary>
|
|
public async Task<(IndexSpace Before, IndexSpace After)> VacuumAsync(CancellationToken cancellationToken = default)
|
|
{
|
|
AsSqlite();
|
|
var before = (await SpaceAsync(cancellationToken).ConfigureAwait(false))!;
|
|
await using (var session = await Database.OpenAsync(cancellationToken).ConfigureAwait(false))
|
|
await session.ExecuteScriptAsync("VACUUM", cancellationToken).ConfigureAwait(false);
|
|
var after = (await SpaceAsync(cancellationToken).ConfigureAwait(false))!;
|
|
return (before, after);
|
|
}
|
|
|
|
public ValueTask DisposeAsync() => Database.DisposeAsync();
|
|
|
|
private SqliteDatabase AsSqlite() =>
|
|
Database as SqliteDatabase ?? throw new NotSupportedException("Backups of a PostgreSQL database are made with the server's own tools.");
|
|
}
|
|
|
|
/// <summary>Size of an SQLite index file and the bytes of its free pages (reclaimable by a vacuum).</summary>
|
|
public sealed record IndexSpace(long FileBytes, long ReclaimableBytes);
|
|
|
|
/// <summary>Repositories bound to one open transaction.</summary>
|
|
public sealed class ChronosTransaction : ChronosRepositories, IAsyncDisposable
|
|
{
|
|
private readonly IDbTransaction _transaction;
|
|
|
|
internal ChronosTransaction(IDbSession session, IDbTransaction transaction)
|
|
: base(new DbAccess(session))
|
|
{
|
|
Session = session;
|
|
_transaction = transaction;
|
|
}
|
|
|
|
/// <summary>The session the transaction runs on, for statements of your own inside it.</summary>
|
|
public IDbSession Session { get; }
|
|
|
|
public Task CommitAsync(CancellationToken cancellationToken = default) => _transaction.CommitAsync(cancellationToken);
|
|
|
|
public Task RollbackAsync(CancellationToken cancellationToken = default) => _transaction.RollbackAsync(cancellationToken);
|
|
|
|
/// <summary>Rolls back unless committed, and returns the session to the pool.</summary>
|
|
public async ValueTask DisposeAsync()
|
|
{
|
|
try
|
|
{
|
|
await _transaction.DisposeAsync().ConfigureAwait(false);
|
|
}
|
|
finally
|
|
{
|
|
await Session.DisposeAsync().ConfigureAwait(false);
|
|
}
|
|
}
|
|
}
|