Files
Chronos/src/Chronos.Data/ChronosDatabase.cs
T
Alby96andClaude Opus 5.5 03b4d0ef60 feat(P2): videos library, verified video trash and copy job, render hashes and still jobs
Renders now record their SHA-256 and kind, so copies, deletes and restores can
be verified. The new videos library lists every render with paging and
filters, deletes into the archive trash after a dry run whose fingerprint must
still match (journalled, so a crash mid-move is settled on open), restores by id
refusing a tampered file, and a VideoCopy job copies renders hash-verified into
a videos folder outside the archive, never overwriting. A still job saves one
frame as an image through an interim Data-side path until P1's Core still API
lands. Batch exports keep the playback and routing uses the job's own export,
so a playback job needs settings format 3 and an older node never claims it.

Refs #21

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 02:27:37 +01:00

203 lines
8.8 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);
Projects = new ProjectRepository(access);
RenderCopies = new RenderCopyRepository(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>Projects of sequences and their versions (owner review 2, R8).</summary>
public ProjectRepository Projects { get; }
/// <summary>Verified copies of renders in videos folders (owner review 1, R9).</summary>
public RenderCopyRepository RenderCopies { 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);
}
}
}