Files
Chronos/src/Chronos.App/App.xaml.cs
T
Alby96andClaude Opus 5.5 af9eeaab9b
CI / Build and test (push) Successful in 7m0s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 6s
Release / Build, test and publish (push) Successful in 13m28s
CI / PostgreSQL 16 integration (push) Successful in 5m52s
CI / PostgreSQL 17 integration (push) Successful in 4m50s
CI / Docker image (push) Successful in 1m4s
Release / Server image (push) Successful in 1m35s
feat: owner review 2 phase 2: scheduled jobs and log settings (#10)
- Jobs > Scheduled on the desktop and the admin panel. Every timer that queued work is now a visible system schedule: archive scan, upload clean-up, index backup, job-history and audit clean-ups, desktop housekeeping. New actions: verify, thumbnails, proxies, analysis, maintenance, backup, clean-ups, reports.
- The scheduler: migration 0007, in-house recurrence, compare-and-set claim, catch-up, scan at start.
- Log settings: levels, retention, size parts, total limit, daily or hourly rotation, audit retention, diagnostics share; the server writes Debug/Trace to its files again; logging never fails a job.

Upgrade: CHRONOS_LOG_LEVEL set in an existing container locks both levels; migration 0007 is one-way.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
2026-10-27 11:19:26 +01:00

241 lines
11 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using System.Windows;
using System.Windows.Threading;
using Chronos.App.DesignTime;
using Chronos.App.Editor;
using Chronos.App.Infrastructure;
using Chronos.App.Shell;
using Chronos.Core.Diagnostics;
using Chronos.Ui.Mvvm;
using Chronos.Ui.Theming;
namespace Chronos.App;
/// <summary>
/// Chronos desktop client. Local mode starts here: settings and language before the first window, then the window,
/// then the index and the job engine (<see cref="AppServices"/>) off the UI thread. <c>--capture &lt;dir&gt;</c>
/// renders every screen with synthetic data in a throw-away data folder and exits. A file argument is a
/// <c>.chronos</c> project file (Explorer passes it on a double-click) opened once the index is open. One Chronos runs
/// per data folder: a second launch hands its file to the running one and exits, or, when the running one is closing,
/// waits for it to exit and starts with the file (<see cref="SingleInstance"/>).
/// </summary>
public partial class App : Application
{
/// <summary>How long a launch waits for a Chronos that is closing (it gives its services up to 10 s to stop).</summary>
private static readonly TimeSpan ClosingWait = TimeSpan.FromSeconds(30);
private readonly TaskCompletionSource _started = new(TaskCreationOptions.RunContinuationsAsynchronously);
private FileLogSink? _log;
private SingleInstance? _instance;
private bool _windowClosed;
public AppEnvironment Environment { get; private set; } = null!;
public AppSettings Settings { get; private set; } = null!;
public AppServices Services { get; private set; } = null!;
public static new App Current => (App)Application.Current;
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
var captureIndex = Array.IndexOf(e.Args, "--capture");
var capture = captureIndex >= 0;
// Capture never reads or writes the user's data folder.
Environment = capture ? AppEnvironment.ForCapture() : AppEnvironment.Detect();
// Settings › Advanced › Logs from the first line, which prunes the folder: also a launch that only hands over. The
// settings are read again once this launch owns the data folder, since a Chronos that was closing saves them on exit.
_log = AppLogging.Open(Environment.LogDirectory, capture ? new AppSettings() : AppSettings.Load(Environment.SettingsPath));
// Capture runs in CI: mirror the log to stderr so failures are visible in the job output.
Log.SetSink(capture ? new TeeLogSink(_log, new StderrLogSink()) : _log);
Log.Info("app", $"Chronos {AppServices.VersionText} starting; data at {Environment.DataDirectory}");
// Settings tells the user once the window is up.
if (Environment.PortableSyncRoot is { } portableIn) Log.Warning("app", $"This portable copy runs in the OneDrive folder {portableIn}: its data is kept outside it");
if (Environment.EarlierPortableData is { } earlier) Log.Warning("app", $"The data this portable copy kept in {earlier} before is left there and no longer used");
if (Environment.SyncedFolder is { } synced) Log.Warning("app", $"The data folder lies in the OneDrive folder {synced}: synchronisation may damage the index");
var projectFile = capture ? null : ProjectFileArgument(e.Args);
if (!capture)
{
_instance = SingleInstance.TryAcquire(Environment.DataDirectory);
if (_instance is null)
{
if (SingleInstance.HandOver(Environment.DataDirectory, projectFile is null ? [] : [projectFile]))
{
Log.Info("app", "Chronos already runs on this data folder; arguments handed over");
Shutdown();
return;
}
// No answer: the running Chronos is closing (it stops listening first). Start once it has exited.
_instance = SingleInstance.WaitForTurn(Environment.DataDirectory, ClosingWait);
if (_instance is null)
{
Log.Info("app", "Chronos already runs on this data folder and did not answer");
Shutdown();
return;
}
Log.Info("app", "The previous Chronos on this data folder has exited");
}
// From now on: a launch while the window and the index open is kept until the shell can take it.
_instance.Listen();
}
Settings = capture ? new AppSettings { Language = "en" } : AppSettings.Load(Environment.SettingsPath);
ApplyLogSettings();
UiLanguage.Apply(Settings.Language);
ThemeManager.Initialize(this, capture ? AppTheme.Dark : Settings.Theme);
AppResources.Merge(this);
DispatcherUnhandledException += OnUnhandledException;
AppDomain.CurrentDomain.UnhandledException += (_, args) => Log.Error("app", "Unhandled exception", args.ExceptionObject as Exception);
TaskScheduler.UnobservedTaskException += (_, args) =>
{
Log.Error("app", "Unobserved task exception", args.Exception);
args.SetObserved();
};
var dialogs = new AppDialogs();
Services = new AppServices(Environment, Settings, SaveSettings, dialogs);
SampleData? sample = capture ? SampleData.Configure(Services) : null;
var shell = new ShellViewModel(Services);
AsyncRelayCommand.Failed += ex => shell.ReportError(ex);
var window = new MainWindow(shell);
dialogs.Owner = window;
MainWindow = window;
if (capture)
{
var dir = captureIndex + 1 < e.Args.Length ? e.Args[captureIndex + 1] : "screenshots";
_ = ScreenCapture.RunAsync(window, shell, sample!, dir);
return;
}
// Closing the main window ends Chronos: later launches wait for it instead of handing over a file it cannot open.
window.Closed += (_, _) =>
{
_windowClosed = true;
_instance?.StopListening();
};
window.Show();
_instance?.Receive(args => Dispatcher.BeginInvoke(() => OnHandOver(shell, args)));
_ = StartAsync(shell, projectFile);
}
/// <summary>Opens the index and the job engine after the window is visible, fills the screens, then opens the project file given.</summary>
private async Task StartAsync(ShellViewModel shell, string? projectFile)
{
try
{
await Services.OpenAsync(Environment.DatabasePath);
await shell.StartAsync();
}
catch (Exception ex)
{
shell.ReportError(ex);
}
finally
{
_started.TrySetResult();
}
if (projectFile is not null) await OpenProjectFileAsync(shell, projectFile);
}
/// <summary>A later launch: its window comes to the front here, and its project file opens.</summary>
private void OnHandOver(ShellViewModel shell, IReadOnlyList<string> args)
{
if (_windowClosed)
{
Log.Warning("app", "A launch arrived while Chronos was closing; its arguments are ignored");
return;
}
if (MainWindow is { } window)
{
window.Show();
if (window.WindowState == WindowState.Minimized) window.WindowState = WindowState.Normal;
window.Activate();
}
if (ProjectFileArgument(args) is { } projectFile) _ = OpenProjectFileAsync(shell, projectFile);
}
/// <summary>Opens a project file once the index is open; failures become the usual one-sentence toast.</summary>
private async Task OpenProjectFileAsync(ShellViewModel shell, string path)
{
await _started.Task;
try
{
await new ProjectFiles(shell).OpenAsync(path);
}
catch (Exception ex)
{
shell.ReportError(ex);
}
}
/// <summary>The first argument that is not an option, as a full path (the hand-over crosses working folders).</summary>
private static string? ProjectFileArgument(IReadOnlyList<string> args)
{
if (args.FirstOrDefault(a => !a.StartsWith("--", StringComparison.Ordinal) && a.Length > 0) is not { } file) return null;
try
{
return System.IO.Path.GetFullPath(file);
}
catch (Exception ex) when (ex is ArgumentException or NotSupportedException or System.IO.PathTooLongException)
{
Log.Warning("app", $"Ignoring argument '{file}'", ex);
return null;
}
}
public void SaveSettings()
{
// A launch that handed over to the running Chronos reads the settings only for its log and never sets Settings.
if (Settings is null) return;
try
{
Settings.Save(Environment.SettingsPath);
}
catch (Exception ex) when (ex is System.IO.IOException or UnauthorizedAccessException)
{
Log.Warning("app", "Settings not saved", ex);
}
// Every settings change passes here, Settings › Advanced › Logs, its Reset and an imported file included.
ApplyLogSettings();
}
/// <summary>Settings › Advanced › Logs to the log files, from the next line on (owner review 2, R11).</summary>
private void ApplyLogSettings()
{
if (_log is not null) AppLogging.Apply(_log, Settings);
}
protected override void OnExit(ExitEventArgs e)
{
// The mutex stays until the services have stopped, so a launch now waits for this one to exit.
_instance?.StopListening();
SaveSettings();
if (MainWindow?.DataContext is ShellViewModel shell) shell.Dispose();
try
{
// Data and engine code continue on the thread pool, so waiting here cannot deadlock the dispatcher.
if (Services is not null && !Services.DisposeAsync().AsTask().Wait(TimeSpan.FromSeconds(10)))
Log.Warning("app", "Services did not stop within 10 s");
}
catch (AggregateException ex)
{
Log.Warning("app", "Services stopped with an error", ex);
}
_instance?.Dispose();
Log.Info("app", "Chronos exiting");
_log?.Dispose();
if (Environment.IsCapture) Environment.DeleteCaptureData();
base.OnExit(e);
}
private void OnUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
{
Log.Error("app", "Unhandled UI exception", e.Exception);
if (MainWindow?.DataContext is ShellViewModel shell)
{
shell.ReportError(e.Exception);
e.Handled = true;
}
}
}