App.xaml.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using Windows.ApplicationModel.Activation;
using Coder.Desktop.App.Models;
using Coder.Desktop.App.Services;
using Coder.Desktop.App.ViewModels;
using Coder.Desktop.App.Views;
using Coder.Desktop.App.Views.Pages;
using Coder.Desktop.CoderSdk.Agent;
using Coder.Desktop.CoderSdk.Coder;
using Coder.Desktop.Vpn;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.UI.Xaml;
using Microsoft.Win32;
using Microsoft.Windows.AppLifecycle;
using Microsoft.Windows.AppNotifications;
using NetSparkleUpdater.Interfaces;
using Serilog;
using LaunchActivatedEventArgs = Microsoft.UI.Xaml.LaunchActivatedEventArgs;

namespace Coder.Desktop.App;

public partial class App : Application
{
    private const string MutagenControllerConfigSection = "MutagenController";
    private const string UpdaterConfigSection = "Updater";

#if !DEBUG
    private const string ConfigSubKey = @"SOFTWARE\Coder Desktop\App";
    private const string LogFilename = "app.log";
    private const string DefaultLogLevel = "Information";
#else
    private const string ConfigSubKey = @"SOFTWARE\Coder Desktop\DebugApp";
    private const string LogFilename = "debug-app.log";
    private const string DefaultLogLevel = "Debug";
#endif

    // HACK: This is exposed for dispatcher queue access. The notifier uses
    //       this to ensure action callbacks run in the UI thread (as
    //       activation events aren't in the main thread).
    public TrayWindow? TrayWindow;

    private readonly IServiceProvider _services;
    private readonly ILogger<App> _logger;
    private readonly IUriHandler _uriHandler;
    private readonly IUserNotifier _userNotifier;

    private bool _handleWindowClosed = true;

    public App()
    {
        var builder = Host.CreateApplicationBuilder();
        var configBuilder = builder.Configuration as IConfigurationBuilder;

        // Add config in increasing order of precedence: first builtin defaults, then HKLM, finally HKCU
        // so that the user's settings in the registry take precedence.
        AddDefaultConfig(configBuilder);
        configBuilder.Add(
            new RegistryConfigurationSource(Registry.LocalMachine, ConfigSubKey));
        configBuilder.Add(
            new RegistryConfigurationSource(
                Registry.CurrentUser,
                ConfigSubKey,
                // Block "Updater:" configuration from HKCU, so that updater
                // settings can only be set at the HKLM level.
                //
                // HACK: This isn't super robust, but the security risk is
                //       minor anyway. Malicious apps running as the user could
                //       likely override this setting by altering the memory of
                //       this app.
                UpdaterConfigSection + ":"));

        var services = builder.Services;

        // Logging
        builder.Services.AddSerilog((_, loggerConfig) =>
        {
            loggerConfig.ReadFrom.Configuration(builder.Configuration);
        });

        services.AddSingleton<ICoderApiClientFactory, CoderApiClientFactory>();
        services.AddSingleton<IAgentApiClientFactory, AgentApiClientFactory>();

        services.AddSingleton<ICredentialBackend>(_ =>
            new WindowsCredentialBackend(WindowsCredentialBackend.CoderCredentialsTargetName));
        services.AddSingleton<ICredentialManager, CredentialManager>();
        services.AddSingleton<IRpcController, RpcController>();
        services.AddSingleton<IHostnameSuffixGetter, HostnameSuffixGetter>();

        services.AddOptions<MutagenControllerConfig>()
            .Bind(builder.Configuration.GetSection(MutagenControllerConfigSection));
        services.AddSingleton<ISyncSessionController, MutagenController>();
        services.AddSingleton<IUserNotifier, UserNotifier>();
        services.AddSingleton<IRdpConnector, RdpConnector>();
        services.AddSingleton<IUriHandler, UriHandler>();

        services.AddOptions<UpdaterConfig>()
            .Bind(builder.Configuration.GetSection(UpdaterConfigSection));
        services.AddSingleton<IUpdaterUpdateAvailableViewModelFactory, UpdaterUpdateAvailableViewModelFactory>();
        services.AddSingleton<IUIFactory, CoderSparkleUIFactory>();
        services.AddSingleton<IUpdateController, SparkleUpdateController>();

        // SignInWindow views and view models
        services.AddTransient<SignInViewModel>();
        services.AddTransient<SignInWindow>();

        // FileSyncListWindow views and view models
        services.AddTransient<FileSyncListViewModel>();
        // FileSyncListMainPage is created by FileSyncListWindow.
        services.AddTransient<FileSyncListWindow>();

        // DirectoryPickerWindow views and view models are created by FileSyncListViewModel.

        // TrayWindow views and view models
        services.AddTransient<TrayWindowLoadingPage>();
        services.AddTransient<TrayWindowDisconnectedViewModel>();
        services.AddTransient<TrayWindowDisconnectedPage>();
        services.AddTransient<TrayWindowLoginRequiredViewModel>();
        services.AddTransient<TrayWindowLoginRequiredPage>();
        services.AddTransient<TrayWindowLoginRequiredViewModel>();
        services.AddTransient<TrayWindowLoginRequiredPage>();
        services.AddSingleton<IAgentAppViewModelFactory, AgentAppViewModelFactory>();
        services.AddSingleton<IAgentViewModelFactory, AgentViewModelFactory>();
        services.AddTransient<TrayWindowViewModel>();
        services.AddTransient<TrayWindowMainPage>();
        services.AddTransient<TrayWindow>();

        _services = services.BuildServiceProvider();
        _logger = _services.GetRequiredService<ILogger<App>>();
        _uriHandler = _services.GetRequiredService<IUriHandler>();
        _userNotifier = _services.GetRequiredService<IUserNotifier>();

        InitializeComponent();
    }

    public async Task ExitApplication()
    {
        _logger.LogDebug("exiting app");
        _handleWindowClosed = false;
        Exit();
        var syncController = _services.GetRequiredService<ISyncSessionController>();
        await syncController.DisposeAsync();
        var rpcController = _services.GetRequiredService<IRpcController>();
        // TODO: send a StopRequest if we're connected???
        await rpcController.DisposeAsync();
        Environment.Exit(0);
    }

    protected override void OnLaunched(LaunchActivatedEventArgs args)
    {
        _logger.LogInformation("new instance launched");

        // Prevent the TrayWindow from closing, just hide it.
        if (TrayWindow != null)
            throw new InvalidOperationException("OnLaunched was called multiple times? TrayWindow is already set");
        TrayWindow = _services.GetRequiredService<TrayWindow>();
        TrayWindow.Closed += (_, closedArgs) =>
        {
            if (!_handleWindowClosed) return;
            closedArgs.Handled = true;
            TrayWindow.AppWindow.Hide();
        };

        // Start connecting to the manager in the background.
        var rpcController = _services.GetRequiredService<IRpcController>();
        if (rpcController.GetState().RpcLifecycle == RpcLifecycle.Disconnected)
            // Passing in a CT with no cancellation is desired here, because
            // the named pipe open will block until the pipe comes up.
            _logger.LogDebug("reconnecting with VPN service");
        _ = rpcController.Reconnect(CancellationToken.None).ContinueWith(t =>
        {
            if (t.Exception != null)
            {
                _logger.LogError(t.Exception, "failed to connect to VPN service");
#if DEBUG
                Debug.WriteLine(t.Exception);
                Debugger.Break();
#endif
            }
        });

        // Load the credentials in the background.
        var credentialManagerCts = new CancellationTokenSource(TimeSpan.FromSeconds(15));
        var credentialManager = _services.GetRequiredService<ICredentialManager>();
        _ = credentialManager.LoadCredentials(credentialManagerCts.Token).ContinueWith(t =>
        {
            if (t.Exception != null)
            {
                _logger.LogError(t.Exception, "failed to load credentials");
#if DEBUG
                Debug.WriteLine(t.Exception);
                Debugger.Break();
#endif
            }

            credentialManagerCts.Dispose();
        }, CancellationToken.None);

        // Initialize file sync.
        // We're adding a 5s delay here to avoid race conditions when loading the mutagen binary.
        _ = Task.Delay(5000).ContinueWith((_) =>
        {
            var syncSessionCts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
            var syncSessionController = _services.GetRequiredService<ISyncSessionController>();
            syncSessionController.RefreshState(syncSessionCts.Token).ContinueWith(
                t =>
                {
                    if (t.IsCanceled || t.Exception != null)
                    {
                        _logger.LogError(t.Exception, "failed to refresh sync state (canceled = {canceled})", t.IsCanceled);
                    }
                    syncSessionCts.Dispose();
                }, CancellationToken.None);
        });
    }

    public void OnActivated(object? sender, AppActivationArguments args)
    {
        switch (args.Kind)
        {
            case ExtendedActivationKind.Protocol:
                var protoArgs = args.Data as IProtocolActivatedEventArgs;
                if (protoArgs == null)
                {
                    _logger.LogWarning("URI activation with null data");
                    return;
                }

                // don't need to wait for it to complete.
                _uriHandler.HandleUri(protoArgs.Uri).ContinueWith(t =>
                {
                    if (t.Exception != null)
                    {
                        // don't log query params, as they contain secrets.
                        _logger.LogError(t.Exception,
                            "unhandled exception while processing URI coder://{authority}{path}",
                            protoArgs.Uri.Authority, protoArgs.Uri.AbsolutePath);
                    }
                });

                break;

            case ExtendedActivationKind.AppNotification:
                var notificationArgs = (args.Data as AppNotificationActivatedEventArgs)!;
                HandleNotification(null, notificationArgs);
                break;

            default:
                _logger.LogWarning("activation for {kind}, which is unhandled", args.Kind);
                break;
        }
    }

    public void HandleNotification(AppNotificationManager? sender, AppNotificationActivatedEventArgs args)
    {
        _logger.LogInformation("handled notification activation: {Argument}", args.Argument);
        _userNotifier.HandleActivation(args);
    }

    private static void AddDefaultConfig(IConfigurationBuilder builder)
    {
        var logPath = Path.Combine(
            Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
            "CoderDesktop",
            LogFilename);
        builder.AddInMemoryCollection(new Dictionary<string, string?>
        {
            [MutagenControllerConfigSection + ":MutagenExecutablePath"] = @"C:\mutagen.exe",

            ["Serilog:Using:0"] = "Serilog.Sinks.File",
            ["Serilog:MinimumLevel"] = DefaultLogLevel,
            ["Serilog:Enrich:0"] = "FromLogContext",
            ["Serilog:WriteTo:0:Name"] = "File",
            ["Serilog:WriteTo:0:Args:path"] = logPath,
            ["Serilog:WriteTo:0:Args:outputTemplate"] =
                "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {SourceContext} - {Message:lj}{NewLine}{Exception}",
            ["Serilog:WriteTo:0:Args:rollingInterval"] = "Day",

#if DEBUG
            ["Serilog:Using:1"] = "Serilog.Sinks.Debug",
            ["Serilog:Enrich:1"] = "FromLogContext",
            ["Serilog:WriteTo:1:Name"] = "Debug",
            ["Serilog:WriteTo:1:Args:outputTemplate"] =
                "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {SourceContext} - {Message:lj}{NewLine}{Exception}",
#endif
        });
    }
}