diff --git a/src/Titano.App/Infrastructure/AppServices.cs b/src/Titano.App/Infrastructure/AppServices.cs index 699422bf..d4f3c278 100644 --- a/src/Titano.App/Infrastructure/AppServices.cs +++ b/src/Titano.App/Infrastructure/AppServices.cs @@ -3,6 +3,7 @@ using System.IO; using System.Net.Http; using System.Reflection; using Titano.App.About; +using Titano.App.Archiving; using Titano.App.Import; using Titano.App.Jobs; using Titano.App.Library; @@ -32,13 +33,13 @@ namespace Titano.App.Infrastructure; /// managed encoders), the one of this PC with the handlers of , /// thumbnails, the server session, the render node, the encoder and format inventories, the update check and the sync /// with the signed-in server (). Started after the window shows, stopped when the app exits. The -/// last archive is reopened at start and rescanned every (Settings › Archive; BRIEF §7: -/// polling, no file-system watchers). Jobs follow Settings › Rendering and Analysis from the next one on (memory -/// budget, quality profile, analysis parameters through ; parallelism as the engine's -/// workers). The render node runs while the user offers this PC () and a -/// server session is open (never in capture mode). Renders and the render node use hardware encoders as Settings › -/// Rendering allows (). Disposal never needs the UI thread, -/// which waits for it. +/// archive at Settings › Archive's folder is reopened at start and rescanned every , as is one +/// chosen later (BRIEF §7: polling, no file-system watchers). Jobs follow Settings › Rendering and Analysis from the +/// next one on (memory budget, quality profile, analysis parameters through ; parallelism +/// as the engine's workers). The render node runs while the user offers this PC () +/// and a server session is open (never in capture mode). Renders and the render node use hardware encoders as +/// Settings › Rendering allows (). Disposal never needs the UI +/// thread, which waits for it. /// public sealed class AppServices : IAsyncDisposable { @@ -228,7 +229,7 @@ public sealed class AppServices : IAsyncDisposable Devices.Start(); var database = Database; _backups = Task.Run(() => DatabaseBackups.RunDailyAsync(database, Environment.BackupDirectory, null, _stopping.Token)); - if (Settings.LastArchivePath is { Length: > 0 } root) _polling = PollAsync(root, _stopping.Token); + _polling = PollAsync(_stopping.Token); } /// Uses an already open index (capture, tests) instead of opening one; sample data keeps the engine stopped. @@ -258,35 +259,89 @@ public sealed class AppServices : IAsyncDisposable if (Database is not null) await Database.DisposeAsync().ConfigureAwait(false); } - /// Reopens the last archive (relinking a moved one, finishing interrupted renames) and rescans it periodically, - /// off the UI thread (disposal waits for it there). - private async Task PollAsync(string root, CancellationToken ct) + /// The period of the rescans while they run (Settings › Archive › Rescan every); null before the index opens. + internal TimeSpan? PollingPeriod => _pollTimer?.Period; + + /// + /// One rescan of the polling, off the UI thread: the archive the Import and Archive screens work on + /// (, the one at Settings › Archive's folder) first takes the settings another process + /// sharing it wrote into its archive.json (also on a read-only share), then gets an incremental scan while it is + /// online. Returns that archive; null when the index holds none. + /// + internal Task RescanAsync(CancellationToken ct = default) => Task.Run(async () => { + if (Database is not { } db || Archives is not { } archives) return null; + var archive = CurrentArchive.Pick(await db.Archives.ListAsync(ct).ConfigureAwait(false), Settings.LastArchivePath); + if (archive is null) return null; + var availability = ArchiveService.GetAvailability(archive); + if (availability != ArchiveAvailability.Offline) await archives.RefreshSettingsAsync(archive.Id, ct).ConfigureAwait(false); + if (availability == ArchiveAvailability.Online) await QueueScanAsync(archive, full: false, ct).ConfigureAwait(false); + return archive; + }, ct); + + /// + /// Rescans the archive now and every () until the app exits, which + /// waits for it on the UI thread. Each rescan follows the archive folder: one chosen on the first run, in Settings or + /// by a relink is rescanned from the next tick on, the one before no longer. The archive at the folder of the start is + /// first reopened (a moved one relinked, interrupted renames finished), at each tick until its archive.json is there + /// (an unplugged drive), unless the folder changed meanwhile: whatever changed it opened the new archive. + /// + private async Task PollAsync(CancellationToken ct) + { + var reopen = Settings.LastArchivePath is { Length: > 0 } start ? start : null; + // Settings › Archive changes the period of this timer (ApplyJobSettings). + using var timer = _pollTimer = new PeriodicTimer(ScanInterval); try { - if (Archives is null) return; - var archive = await Task.Run(() => Archives.OpenAsync(root, ct), ct).ConfigureAwait(false); - // Settings › Archive changes the period of this timer (ApplyJobSettings). - using var timer = _pollTimer = new PeriodicTimer(ScanInterval); do { - if (ArchiveService.GetAvailability(archive) == ArchiveAvailability.Online) await QueueScanAsync(archive, full: false, ct).ConfigureAwait(false); + if (reopen is not null + && (!string.Equals(reopen, Settings.LastArchivePath, StringComparison.OrdinalIgnoreCase) || await ReopenAsync(reopen, ct).ConfigureAwait(false))) + reopen = null; + try + { + await RescanAsync(ct).ConfigureAwait(false); + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException or DatabaseException or ArgumentException) + { + // The next tick tries again (a share that dropped, an archive removed from the index meanwhile). + Log.Warning("archive", "The archive could not be rescanned", ex); + } } while (await timer.WaitForNextTickAsync(ct).ConfigureAwait(false)); } catch (OperationCanceledException) when (ct.IsCancellationRequested) { } - catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException or DatabaseException) - { - Log.Warning("archive", $"The archive at {root} could not be opened", ex); - } finally { _pollTimer = null; } } + /// + /// Registers the archive at again as at open; false while its archive.json is not there. A + /// damaged or newer one is not tried again: the archive the index holds at the folder is still rescanned. + /// + private async Task ReopenAsync(string root, CancellationToken ct) + { + if (Archives is not { } archives) return true; + try + { + return await Task.Run(async () => + { + if (!File.Exists(new ArchivePaths(root).ManifestPath)) return false; + await archives.OpenAsync(root, ct).ConfigureAwait(false); + return true; + }, ct).ConfigureAwait(false); + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException or DatabaseException or NewerFormatException) + { + Log.Warning("archive", $"The archive at {root} could not be opened", ex); + return true; + } + } + /// /// A restore staged in Settings › Advanced replaces the index file before the index is opened, so it also recovers an /// index that no longer opens (). diff --git a/src/Titano.Data/Archiving/ArchiveService.cs b/src/Titano.Data/Archiving/ArchiveService.cs index 562d9e42..ddd1fce3 100644 --- a/src/Titano.Data/Archiving/ArchiveService.cs +++ b/src/Titano.Data/Archiving/ArchiveService.cs @@ -147,17 +147,31 @@ public sealed class ArchiveService : IJobHandlerProvider public async Task GetSettingsAsync(Guid archiveId, CancellationToken cancellationToken = default) { var archive = await LoadArchiveAsync(archiveId, cancellationToken).ConfigureAwait(false); - var paths = new ArchivePaths(archive.RootPath); - try + return TryReadManifest(archive) is { } manifest + ? ArchiveSettings.Of(manifest) + : new ArchiveSettings(archive.Name, new LayoutTemplates { Folder = archive.FolderTemplate, File = archive.FileTemplate }, + new ProxyPolicy { LongEdge = archive.ProxyLongEdge }, new ThumbnailPolicy()); + } + + /// + /// The settings in the archive's archive.json, with its index row brought up to them when another process + /// sharing the archive changed the file (a server's admin panel, another PC's Settings): imports and uploads take their + /// templates and proxy size from that row. Null while the file cannot be read (offline, damaged, newer, of another + /// archive): the row stays as it is, and only 's stand-ins are known. + /// + public async Task RefreshSettingsAsync(Guid archiveId, CancellationToken cancellationToken = default) + { + var archive = await LoadArchiveAsync(archiveId, cancellationToken).ConfigureAwait(false); + if (TryReadManifest(archive) is not { } manifest) return null; + if (manifest.Name != archive.Name || manifest.LayoutTemplates.Folder != archive.FolderTemplate || manifest.LayoutTemplates.File != archive.FileTemplate + || manifest.ProxyPolicy.LongEdge != archive.ProxyLongEdge) { - if (File.Exists(paths.ManifestPath)) return ArchiveSettings.Of(ManifestStore.ReadArchive(paths.ManifestPath)); + // Read without the settings lease, as at open: an edit made meanwhile writes its own row, and the next refresh + // settles a file that changes again. + await RegisterAsync(new ArchivePaths(archive.RootPath), manifest, cancellationToken).ConfigureAwait(false); + Log.Info("archive", $"Settings of {archive.RootPath} changed elsewhere: {manifest.LayoutTemplates.Folder} · {manifest.LayoutTemplates.File}, proxies {manifest.ProxyPolicy.LongEdge}"); } - catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException) - { - Log.Warning("archive", $"The settings of {paths.Root} cannot be read; the index's are used", ex); - } - return new ArchiveSettings(archive.Name, new LayoutTemplates { Folder = archive.FolderTemplate, File = archive.FileTemplate }, - new ProxyPolicy { LongEdge = archive.ProxyLongEdge }, new ThumbnailPolicy()); + return ArchiveSettings.Of(manifest); } /// @@ -325,6 +339,24 @@ public sealed class ArchiveService : IJobHandlerProvider return archive; } + /// The archive's archive.json; null (logged) while it cannot be read or when it belongs to another archive. + private static ArchiveManifest? TryReadManifest(Archive archive) + { + var paths = new ArchivePaths(archive.RootPath); + try + { + if (!File.Exists(paths.ManifestPath)) return null; + var manifest = ManifestStore.ReadArchive(paths.ManifestPath); + if (manifest.Id == archive.Id) return manifest; + Log.Warning("archive", $"{paths.ManifestPath} belongs to archive {manifest.Id}, not {archive.Id}; the index's settings are used"); + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException or NewerFormatException) + { + Log.Warning("archive", $"The settings of {paths.Root} cannot be read; the index's are used", ex); + } + return null; + } + private async Task LoadArchiveAsync(Guid archiveId, CancellationToken cancellationToken) => await _db.Archives.GetAsync(archiveId, cancellationToken).ConfigureAwait(false) ?? throw new ArgumentException($"Unknown archive {archiveId}.", nameof(archiveId)); diff --git a/src/Titano.Server/Storage/ArchivePolling.cs b/src/Titano.Server/Storage/ArchivePolling.cs index fe5bb2e4..739d6451 100644 --- a/src/Titano.Server/Storage/ArchivePolling.cs +++ b/src/Titano.Server/Storage/ArchivePolling.cs @@ -10,9 +10,11 @@ namespace Titano.Server.Storage; /// Polls the archive (BRIEF §7: by modification time and size, no file-system watchers): an incremental scan at start /// and every while the archive is online, so photos already in an adopted folder and sequences /// another writer adds (a desktop sharing the archive, files copied in by hand) are indexed without an administrator's -/// rescan. A scan or rebuild of the archive that is waiting, running or paused is not queued again. +/// rescan. Settings such a writer changed in archive.json reach the index first, so uploads and the admin panel follow +/// them. A scan or rebuild of the archive that is waiting, running or paused is not queued again. /// -public sealed class ArchivePolling(TitanoDatabase db, ServerArchive archive, JobEngineHost jobs, TimeProvider time, ILogger logger) +public sealed class ArchivePolling(TitanoDatabase db, ServerArchive archive, ArchiveService archives, JobEngineHost jobs, TimeProvider time, + ILogger logger) : BackgroundService { /// The desktop's rhythm (it polls its archive the same way). @@ -26,6 +28,8 @@ public sealed class ArchivePolling(TitanoDatabase db, ServerArchive archive, Job if (!jobs.CanRun(JobKind.Scan)) return null; var current = archive.Current; if (ArchiveService.GetAvailability(current) != ArchiveAvailability.Online) return null; + if (await archives.RefreshSettingsAsync(current.Id, cancellationToken) is not null && await db.Archives.GetAsync(current.Id, cancellationToken) is { } row) + archive.Current = current = row; foreach (var kind in new[] { JobKind.Scan, JobKind.Rebuild }) { foreach (var state in Pending) diff --git a/tests/Titano.App.Tests/Infrastructure/AppServicesTests.cs b/tests/Titano.App.Tests/Infrastructure/AppServicesTests.cs index 7d442036..187a40b0 100644 --- a/tests/Titano.App.Tests/Infrastructure/AppServicesTests.cs +++ b/tests/Titano.App.Tests/Infrastructure/AppServicesTests.cs @@ -51,6 +51,53 @@ public sealed class AppServicesTests } } + /// BRIEF §7: polling follows the archive folder, also one chosen after the start (first run, Settings, relink). + [Test] + [WindowsOnly] + public void RescansFollowTheArchiveFolderChosenAfterTheStart() + { + var environment = AppEnvironment.ForCapture(); + try + { + SingleThreadedContext.Run(async () => + { + // The first run: the index opens before any archive folder is set. + var settings = new AppSettings { Language = "en" }; + var services = new AppServices(environment, settings, () => { }, new NoDialogs()); + try + { + await services.OpenAsync(environment.DatabasePath); + Assert.Null(await services.RescanAsync()); + // The rescans run all the same: Settings › Archive › Rescan every reaches them. + settings.ScanIntervalMinutes = 30; + services.SaveSettings(); + Assert.Equal(TimeSpan.FromMinutes(30), services.PollingPeriod); + + // The first-run dialog creates an archive: the next rescan is of it. + await services.ArchiveSetup.CreateAsync(Path.Combine(environment.DataDirectory, "first")); + Assert.Equal("first", (await services.RescanAsync())?.Name); + + // Settings › Archive moves to another archive: the next rescan is of that one, no longer of the first. + var second = Path.Combine(environment.DataDirectory, "second"); + await new ArchiveService(services.Database!).CreateAsync(second, "Second"); + settings.LastArchivePath = second; + services.SaveSettings(); + var rescanned = Assert.NotNull(await services.RescanAsync()); + Assert.Equal("Second", rescanned.Name); + Assert.Contains((await services.Database!.Jobs.ListAsync(null, JobKind.Scan)).Items, j => j.TargetIds.Contains(rescanned.Id)); + } + finally + { + Assert.True(services.DisposeAsync().AsTask().Wait(TimeSpan.FromSeconds(10)), "services stopped"); + } + }); + } + finally + { + environment.DeleteCaptureData(); + } + } + /// BRIEF §6.2: a restore staged in Settings › Advanced recovers an index that no longer opens. [Test] [WindowsOnly] diff --git a/tests/Titano.Data.Tests/Archiving/ArchiveSettingsTests.cs b/tests/Titano.Data.Tests/Archiving/ArchiveSettingsTests.cs index 258b2bd7..fe5ab3bb 100644 --- a/tests/Titano.Data.Tests/Archiving/ArchiveSettingsTests.cs +++ b/tests/Titano.Data.Tests/Archiving/ArchiveSettingsTests.cs @@ -114,6 +114,39 @@ public sealed class ArchiveSettingsTests(TestContext context) fx.Service.UpdateSettingsAsync(fx.Archive.Id, s => s with { Proxies = s.Proxies with { LongEdge = 2560 } }, fx.Ct)); var shown = await fx.Service.GetSettingsAsync(fx.Archive.Id, fx.Ct); Assert.Equal((1280, FrameImageRenderer.ThumbnailLongEdge), (shown.Proxies.LongEdge, shown.Thumbnails.LongEdge)); + // A refresh reports that only the index's stand-ins are known: the thumbnail size above is not the archive's. + Assert.Null(await fx.Service.RefreshSettingsAsync(fx.Archive.Id, fx.Ct)); + } + + [Test] + public async Task ARefreshBringsTheIndexUpToSettingsChangedElsewhere() + { + await using var fx = await ArchiveFixture.CreateAsync(context); + // Another process sharing the archive (a server's admin panel) changed archive.json: this index still has the old row. + var manifest = ManifestStore.ReadArchive(fx.Paths.ManifestPath); + ManifestStore.WriteArchive(fx.Paths.ManifestPath, manifest with + { + Name = "Shared", + LayoutTemplates = manifest.LayoutTemplates with { Folder = "{year}/{camera}" }, + ProxyPolicy = manifest.ProxyPolicy with { LongEdge = 2560 }, + ThumbnailPolicy = manifest.ThumbnailPolicy with { LongEdge = 480 }, + }); + Assert.Equal(fx.Archive.FolderTemplate, (await fx.Db.Archives.GetAsync(fx.Archive.Id, fx.Ct))!.FolderTemplate); + + var settings = Assert.NotNull(await fx.Service.RefreshSettingsAsync(fx.Archive.Id, fx.Ct)); + Assert.Equal(("{year}/{camera}", 2560, 480), (settings.Templates.Folder, settings.Proxies.LongEdge, settings.Thumbnails.LongEdge)); + var row = (await fx.Db.Archives.GetAsync(fx.Archive.Id, fx.Ct))!; + Assert.Equal(("Shared", "{year}/{camera}", 2560), (row.Name, row.FolderTemplate, row.ProxyLongEdge)); + + // The drive is unplugged: nothing is known beyond the index, which stays as it is. + File.Move(fx.Paths.ManifestPath, fx.Paths.ManifestPath + ".away"); + Assert.Null(await fx.Service.RefreshSettingsAsync(fx.Archive.Id, fx.Ct)); + Assert.Equal("{year}/{camera}", (await fx.Db.Archives.GetAsync(fx.Archive.Id, fx.Ct))!.FolderTemplate); + + // The folder now holds another archive: its settings are neither shown nor registered as this one's. + ManifestStore.WriteArchive(fx.Paths.ManifestPath, manifest with { Id = Guid.CreateVersion7(), Name = "Other" }); + Assert.Null(await fx.Service.RefreshSettingsAsync(fx.Archive.Id, fx.Ct)); + Assert.Equal("Shared", (await fx.Db.Archives.GetAsync(fx.Archive.Id, fx.Ct))!.Name); } [Test] diff --git a/tests/Titano.Server.Tests/Storage/ArchiveModuleTests.cs b/tests/Titano.Server.Tests/Storage/ArchiveModuleTests.cs index 9112850f..68520d42 100644 --- a/tests/Titano.Server.Tests/Storage/ArchiveModuleTests.cs +++ b/tests/Titano.Server.Tests/Storage/ArchiveModuleTests.cs @@ -102,6 +102,28 @@ public sealed class ArchiveModuleTests(TestContext context) await UntilIndexedAsync(server, archive.Id, "garden"); } + [Test] + public async Task SettingsADesktopChangedInArchiveJsonReachTheServerAtTheNextPoll() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + var archive = server.Services.GetRequiredService(); + // A desktop sharing the archive changed its folder template and proxy size in archive.json. + var path = new ArchivePaths(archive.Root).ManifestPath; + var manifest = ManifestStore.ReadArchive(path); + ManifestStore.WriteArchive(path, manifest with + { + LayoutTemplates = manifest.LayoutTemplates with { Folder = "{camera}/{date}" }, + ProxyPolicy = manifest.ProxyPolicy with { LongEdge = 2560 }, + }); + + await server.Services.GetRequiredService().PollAsync(context.Cancellation); + + // Uploads (the index row) and the admin panel (the served archive) follow it. + Assert.Equal(("{camera}/{date}", 2560), (archive.Current.FolderTemplate, archive.Current.ProxyLongEdge)); + var row = Assert.NotNull(await server.Database.Archives.GetAsync(archive.Id, context.Cancellation)); + Assert.Equal(("{camera}/{date}", 2560), (row.FolderTemplate, row.ProxyLongEdge)); + } + private static async Task UntilIndexedAsync(TestServer server, Guid archiveId, string folder) { var until = DateTime.UtcNow + TimeSpan.FromSeconds(30);