diff --git a/src/MikrotikInstaller.App/App.xaml b/src/MikrotikInstaller.App/App.xaml index e84b68c..fb52baa 100644 --- a/src/MikrotikInstaller.App/App.xaml +++ b/src/MikrotikInstaller.App/App.xaml @@ -47,6 +47,9 @@ + + + diff --git a/src/MikrotikInstaller.App/ViewModels/MainViewModel.cs b/src/MikrotikInstaller.App/ViewModels/MainViewModel.cs index 0213942..e7211dd 100644 --- a/src/MikrotikInstaller.App/ViewModels/MainViewModel.cs +++ b/src/MikrotikInstaller.App/ViewModels/MainViewModel.cs @@ -24,6 +24,7 @@ public partial class MainViewModel : ObservableObject new WlanStepViewModel(_session), new FirewallStepViewModel(_session), new SummaryStepViewModel(_session), + new UpdateStepViewModel(_session), ]; foreach (var step in Steps) diff --git a/src/MikrotikInstaller.App/ViewModels/Steps/DeviceOverviewStepViewModel.cs b/src/MikrotikInstaller.App/ViewModels/Steps/DeviceOverviewStepViewModel.cs index 3e65947..9571eda 100644 --- a/src/MikrotikInstaller.App/ViewModels/Steps/DeviceOverviewStepViewModel.cs +++ b/src/MikrotikInstaller.App/ViewModels/Steps/DeviceOverviewStepViewModel.cs @@ -2,6 +2,7 @@ using CommunityToolkit.Mvvm.ComponentModel; using CommunityToolkit.Mvvm.Input; using MikrotikInstaller.Core.Connectivity; using MikrotikInstaller.Core.Devices; +using MikrotikInstaller.Core.Updates; namespace MikrotikInstaller.App.ViewModels.Steps; @@ -59,6 +60,11 @@ public partial class DeviceOverviewStepViewModel : WizardStepViewModelBase var device = await DeviceDiscoveryService.DiscoverAsync(_session.Client); Device = device; _session.Device = device; + + // Läuft im Hintergrund weiter, ohne die Navigation zu blockieren — ein frisches Gerät + // hat an dieser Stelle im Assistenten meist noch keinen Internetzugang, die Prüfung + // schlägt dann einfach fehl (kein Fehlerzustand) und wird nach dem Anwenden wiederholt. + _ = CheckForUpdatesInBackgroundAsync(_session.Client); } catch (RouterOsException ex) { @@ -70,4 +76,9 @@ public partial class DeviceOverviewStepViewModel : WizardStepViewModelBase IsLoading = false; } } + + private async Task CheckForUpdatesInBackgroundAsync(IRouterOsClient client) + { + _session.UpdateInfo = await RouterOsUpdateService.CheckForUpdatesAsync(client); + } } diff --git a/src/MikrotikInstaller.App/ViewModels/Steps/SummaryStepViewModel.cs b/src/MikrotikInstaller.App/ViewModels/Steps/SummaryStepViewModel.cs index ccd069e..62f1265 100644 --- a/src/MikrotikInstaller.App/ViewModels/Steps/SummaryStepViewModel.cs +++ b/src/MikrotikInstaller.App/ViewModels/Steps/SummaryStepViewModel.cs @@ -5,6 +5,7 @@ using MikrotikInstaller.Core.Backup; using MikrotikInstaller.Core.Configuration; using MikrotikInstaller.Core.Connectivity; using MikrotikInstaller.Core.Export; +using MikrotikInstaller.Core.Updates; using Wpf.Ui.Controls; namespace MikrotikInstaller.App.ViewModels.Steps; @@ -38,8 +39,11 @@ public partial class SummaryStepViewModel : WizardStepViewModelBase private string? _errorMessage; [ObservableProperty] + [NotifyPropertyChangedFor(nameof(CanGoNext))] private bool _isFinished; + public override bool CanGoNext => IsFinished; + [ObservableProperty] private string? _backupName; @@ -114,6 +118,10 @@ public partial class SummaryStepViewModel : WizardStepViewModelBase ProgressText = null; IsFinished = true; + + // Jetzt sollte Internet stehen (falls WAN eingerichtet wurde) — Update-Prüfung für den + // folgenden Schritt im Hintergrund wiederholen, blockiert den Abschluss hier nicht. + _ = RecheckUpdatesInBackgroundAsync(_session.Client); } catch (RouterOsException ex) { @@ -169,6 +177,11 @@ public partial class SummaryStepViewModel : WizardStepViewModelBase } } + private async Task RecheckUpdatesInBackgroundAsync(IRouterOsClient client) + { + _session.UpdateInfo = await RouterOsUpdateService.CheckForUpdatesAsync(client); + } + private IReadOnlyList GetAllActions() => (_session.WanActions ?? []) .Concat(_session.LanActions ?? []) diff --git a/src/MikrotikInstaller.App/ViewModels/Steps/UpdateStepViewModel.cs b/src/MikrotikInstaller.App/ViewModels/Steps/UpdateStepViewModel.cs new file mode 100644 index 0000000..df537de --- /dev/null +++ b/src/MikrotikInstaller.App/ViewModels/Steps/UpdateStepViewModel.cs @@ -0,0 +1,136 @@ +using CommunityToolkit.Mvvm.ComponentModel; +using CommunityToolkit.Mvvm.Input; +using MikrotikInstaller.Core.Connectivity; +using MikrotikInstaller.Core.Updates; + +namespace MikrotikInstaller.App.ViewModels.Steps; + +/// +/// Letzter, optionaler Schritt: zeigt, ob eine neuere RouterOS-Version verfügbar ist, und kann sie +/// auf Wunsch installieren. Komplett optional — der Assistent gilt bereits mit dem vorherigen Schritt +/// als abgeschlossen. +/// +public partial class UpdateStepViewModel : WizardStepViewModelBase +{ + private readonly WizardSession _session; + + public UpdateStepViewModel(WizardSession session) + : base( + title: "RouterOS-Update", + description: "Falls eine neuere RouterOS-Version verfügbar ist, kannst du sie hier optional installieren. Das ist kein Muss — dein Gerät ist bereits fertig eingerichtet.") + { + _session = session; + } + + [ObservableProperty] + [NotifyPropertyChangedFor(nameof(ShowCheckFailed))] + [NotifyPropertyChangedFor(nameof(ShowUpToDate))] + [NotifyPropertyChangedFor(nameof(ShowUpdateAvailable))] + private bool _isChecking; + + [ObservableProperty] + [NotifyPropertyChangedFor(nameof(ShowCheckFailed))] + [NotifyPropertyChangedFor(nameof(ShowUpToDate))] + [NotifyPropertyChangedFor(nameof(ShowUpdateAvailable))] + private bool _isCheckSuccessful; + + [ObservableProperty] + [NotifyPropertyChangedFor(nameof(ShowUpToDate))] + [NotifyPropertyChangedFor(nameof(ShowUpdateAvailable))] + private bool _isUpdateAvailable; + + [ObservableProperty] + private string? _installedVersion; + + [ObservableProperty] + private string? _latestVersion; + + [ObservableProperty] + private bool _confirmReboot; + + [ObservableProperty] + private bool _isUpdating; + + [ObservableProperty] + [NotifyPropertyChangedFor(nameof(ShowUpToDate))] + [NotifyPropertyChangedFor(nameof(ShowUpdateAvailable))] + private bool _isUpdateStarted; + + [ObservableProperty] + private string? _errorMessage; + + public bool ShowCheckFailed => !IsChecking && !IsCheckSuccessful; + + public bool ShowUpToDate => !IsChecking && IsCheckSuccessful && !IsUpdateAvailable && !IsUpdateStarted; + + public bool ShowUpdateAvailable => !IsChecking && IsCheckSuccessful && IsUpdateAvailable && !IsUpdateStarted; + + public override Task OnActivatedAsync() + { + ApplyInfo(_session.UpdateInfo); + return Task.CompletedTask; + } + + private void ApplyInfo(RouterOsUpdateInfo? info) + { + IsCheckSuccessful = info?.IsCheckSuccessful ?? false; + IsUpdateAvailable = info?.IsUpdateAvailable ?? false; + InstalledVersion = string.IsNullOrWhiteSpace(info?.InstalledVersion) ? null : info.InstalledVersion; + LatestVersion = info?.LatestVersion; + StartUpdateCommand.NotifyCanExecuteChanged(); + } + + [RelayCommand] + private async Task RecheckAsync() + { + if (_session.Client is null) + { + return; + } + + IsChecking = true; + ErrorMessage = null; + + try + { + var info = await RouterOsUpdateService.CheckForUpdatesAsync(_session.Client); + _session.UpdateInfo = info; + ApplyInfo(info); + } + finally + { + IsChecking = false; + } + } + + private bool CanStartUpdate => IsUpdateAvailable && ConfirmReboot && !IsUpdating && !IsUpdateStarted; + + partial void OnConfirmRebootChanged(bool value) => StartUpdateCommand.NotifyCanExecuteChanged(); + + [RelayCommand(CanExecute = nameof(CanStartUpdate))] + private async Task StartUpdateAsync() + { + if (_session.Client is null) + { + return; + } + + IsUpdating = true; + ErrorMessage = null; + + try + { + await RouterOsUpdateService.StartUpdateAsync(_session.Client); + IsUpdateStarted = true; + } + catch (RouterOsException ex) + { + ErrorMessage = ex.Message; + } + finally + { + IsUpdating = false; + StartUpdateCommand.NotifyCanExecuteChanged(); + } + } +} diff --git a/src/MikrotikInstaller.App/ViewModels/WizardSession.cs b/src/MikrotikInstaller.App/ViewModels/WizardSession.cs index fc8a7e2..2858944 100644 --- a/src/MikrotikInstaller.App/ViewModels/WizardSession.cs +++ b/src/MikrotikInstaller.App/ViewModels/WizardSession.cs @@ -1,6 +1,7 @@ using MikrotikInstaller.Core.Configuration; using MikrotikInstaller.Core.Connectivity; using MikrotikInstaller.Core.Devices; +using MikrotikInstaller.Core.Updates; namespace MikrotikInstaller.App.ViewModels; @@ -44,6 +45,12 @@ public sealed class WizardSession public FirewallSettings? FirewallSettings { get; set; } + /// + /// Ergebnis der letzten Update-Prüfung. Wird zuerst in der Geräte-Erkennung versucht (funktioniert + /// nur, wenn das Gerät schon Internetzugang hat) und nach erfolgreichem Anwenden erneut versucht. + /// + public RouterOsUpdateInfo? UpdateInfo { get; set; } + public async Task DisposeClientAsync() { if (Client is not null) diff --git a/src/MikrotikInstaller.App/Views/Steps/UpdateStepView.xaml b/src/MikrotikInstaller.App/Views/Steps/UpdateStepView.xaml new file mode 100644 index 0000000..ad626dd --- /dev/null +++ b/src/MikrotikInstaller.App/Views/Steps/UpdateStepView.xaml @@ -0,0 +1,68 @@ + + + + + + + + + + + + Es konnte nicht geprüft werden, ob ein Update verfügbar ist. Das liegt meist daran, dass dein Gerät (noch) keinen Internetzugang hat. + + + + + + + + + + + + + + + + + + + + + + Beim Update startet dein Gerät automatisch neu. Das dauert normalerweise ein bis zwei Minuten, in denen dein Netzwerk kurz nicht erreichbar ist. In seltenen Fällen (z. B. Stromausfall während des Updates) kann ein Update fehlschlagen. + + + + + + + + + + + + + + + Das Update wurde gestartet. + + + Dein Gerät lädt die neue Version herunter und startet danach automatisch neu. Das dauert normalerweise ein bis zwei Minuten. + + + + + + diff --git a/src/MikrotikInstaller.App/Views/Steps/UpdateStepView.xaml.cs b/src/MikrotikInstaller.App/Views/Steps/UpdateStepView.xaml.cs new file mode 100644 index 0000000..7f0c110 --- /dev/null +++ b/src/MikrotikInstaller.App/Views/Steps/UpdateStepView.xaml.cs @@ -0,0 +1,11 @@ +using System.Windows.Controls; + +namespace MikrotikInstaller.App.Views.Steps; + +public partial class UpdateStepView : UserControl +{ + public UpdateStepView() + { + InitializeComponent(); + } +} diff --git a/src/MikrotikInstaller.Core.Tests/Updates/RouterOsUpdateServiceTests.cs b/src/MikrotikInstaller.Core.Tests/Updates/RouterOsUpdateServiceTests.cs new file mode 100644 index 0000000..d1dcb6e --- /dev/null +++ b/src/MikrotikInstaller.Core.Tests/Updates/RouterOsUpdateServiceTests.cs @@ -0,0 +1,62 @@ +using MikrotikInstaller.Core.Updates; + +namespace MikrotikInstaller.Core.Tests.Updates; + +public class RouterOsUpdateServiceTests +{ + [Fact] + public async Task CheckForUpdatesAsync_UpdateAvailable_ReturnsIsUpdateAvailableTrue() + { + var responses = new Queue>>(); + responses.Enqueue([new Dictionary { ["status"] = "New version is available", ["installed-version"] = "7.10", ["latest-version"] = "7.15.2" }]); + var client = new SequencedRouterOsClient(responses); + + var info = await RouterOsUpdateService.CheckForUpdatesAsync(client); + + Assert.True(info.IsCheckSuccessful); + Assert.True(info.IsUpdateAvailable); + Assert.Equal("7.10", info.InstalledVersion); + Assert.Equal("7.15.2", info.LatestVersion); + Assert.Equal(1, client.ExecuteCallCount); + } + + [Fact] + public async Task CheckForUpdatesAsync_AlreadyUpToDate_ReturnsIsUpdateAvailableFalse() + { + var responses = new Queue>>(); + responses.Enqueue([new Dictionary { ["status"] = "System is already up to date", ["installed-version"] = "7.15.2", ["latest-version"] = "7.15.2" }]); + var client = new SequencedRouterOsClient(responses); + + var info = await RouterOsUpdateService.CheckForUpdatesAsync(client); + + Assert.True(info.IsCheckSuccessful); + Assert.False(info.IsUpdateAvailable); + } + + [Fact] + public async Task CheckForUpdatesAsync_WaitsWhileStatusIsStillChecking() + { + var responses = new Queue>>(); + responses.Enqueue([new Dictionary { ["status"] = "Checking for updates..." }]); + responses.Enqueue([new Dictionary { ["status"] = "Checking for updates..." }]); + responses.Enqueue([new Dictionary { ["status"] = "System is already up to date", ["installed-version"] = "7.15.2", ["latest-version"] = "7.15.2" }]); + var client = new SequencedRouterOsClient(responses); + + var info = await RouterOsUpdateService.CheckForUpdatesAsync(client); + + Assert.True(info.IsCheckSuccessful); + Assert.Empty(responses); + } + + [Fact] + public async Task CheckForUpdatesAsync_NoInternet_ReturnsCheckFailed() + { + // Kein Eintrag jemals verfügbar (Gerät kann den Update-Server nicht erreichen). + var client = new SequencedRouterOsClient(new Queue>>()); + + var info = await RouterOsUpdateService.CheckForUpdatesAsync(client); + + Assert.False(info.IsCheckSuccessful); + Assert.False(info.IsUpdateAvailable); + } +} diff --git a/src/MikrotikInstaller.Core.Tests/Updates/SequencedRouterOsClient.cs b/src/MikrotikInstaller.Core.Tests/Updates/SequencedRouterOsClient.cs new file mode 100644 index 0000000..3a64b8b --- /dev/null +++ b/src/MikrotikInstaller.Core.Tests/Updates/SequencedRouterOsClient.cs @@ -0,0 +1,31 @@ +using MikrotikInstaller.Core.Connectivity; + +namespace MikrotikInstaller.Core.Tests.Updates; + +/// Test-Double, das bei GetAsync nacheinander vorbereitete Antworten liefert (simuliert Polling). +internal sealed class SequencedRouterOsClient(Queue>> responses) : IRouterOsClient +{ + public int ExecuteCallCount { get; private set; } + + public RouterOsProtocol Protocol => RouterOsProtocol.Rest; + + public Task>> GetAsync(string path, CancellationToken cancellationToken = default) => + Task.FromResult(responses.Count > 0 ? responses.Dequeue() : []); + + public Task AddAsync(string path, IReadOnlyDictionary parameters, CancellationToken cancellationToken = default) => + throw new NotSupportedException(); + + public Task SetAsync(string path, string id, IReadOnlyDictionary parameters, CancellationToken cancellationToken = default) => + throw new NotSupportedException(); + + public Task RemoveAsync(string path, string id, CancellationToken cancellationToken = default) => + throw new NotSupportedException(); + + public Task ExecuteAsync(string path, IReadOnlyDictionary? parameters = null, CancellationToken cancellationToken = default) + { + ExecuteCallCount++; + return Task.CompletedTask; + } + + public ValueTask DisposeAsync() => ValueTask.CompletedTask; +} diff --git a/src/MikrotikInstaller.Core/Connectivity/Demo/DemoRouterOsClient.cs b/src/MikrotikInstaller.Core/Connectivity/Demo/DemoRouterOsClient.cs index b402acb..72a61dc 100644 --- a/src/MikrotikInstaller.Core/Connectivity/Demo/DemoRouterOsClient.cs +++ b/src/MikrotikInstaller.Core/Connectivity/Demo/DemoRouterOsClient.cs @@ -91,5 +91,9 @@ public sealed class DemoRouterOsClient : IRouterOsClient new() { [".id"] = "*3", ["name"] = "ether3", ["type"] = "ether", ["running"] = "false", ["disabled"] = "false" }, new() { [".id"] = "*4", ["name"] = "wlan1", ["type"] = "wlan", ["running"] = "false", ["disabled"] = "true" }, ], + ["/system/package/update"] = + [ + new() { ["installed-version"] = "7.15.2", ["latest-version"] = "7.16.1", ["status"] = "New version is available" }, + ], }; } diff --git a/src/MikrotikInstaller.Core/Updates/RouterOsUpdateInfo.cs b/src/MikrotikInstaller.Core/Updates/RouterOsUpdateInfo.cs new file mode 100644 index 0000000..bc70e37 --- /dev/null +++ b/src/MikrotikInstaller.Core/Updates/RouterOsUpdateInfo.cs @@ -0,0 +1,15 @@ +namespace MikrotikInstaller.Core.Updates; + +/// +/// Ergebnis einer Update-Prüfung. ist false, wenn das Gerät +/// den MikroTik-Update-Server nicht erreichen konnte (z. B. weil noch kein Internetzugang eingerichtet +/// ist) — das ist beim allerersten Einrichtungsschritt der Normalfall, kein Fehler. +/// +public sealed record RouterOsUpdateInfo( + bool IsCheckSuccessful, + string InstalledVersion, + string? LatestVersion, + bool IsUpdateAvailable) +{ + public static RouterOsUpdateInfo CheckFailed() => new(false, string.Empty, null, false); +} diff --git a/src/MikrotikInstaller.Core/Updates/RouterOsUpdateService.cs b/src/MikrotikInstaller.Core/Updates/RouterOsUpdateService.cs new file mode 100644 index 0000000..6602a3c --- /dev/null +++ b/src/MikrotikInstaller.Core/Updates/RouterOsUpdateService.cs @@ -0,0 +1,57 @@ +using MikrotikInstaller.Core.Connectivity; + +namespace MikrotikInstaller.Core.Updates; + +/// +/// Prüft über die RouterOS-eigene Update-Funktion, ob eine neuere RouterOS-Version verfügbar ist, +/// und kann eine gefundene Aktualisierung anstoßen. Das Gerät braucht dafür funktionierenden +/// Internetzugang — schlägt die Prüfung fehl, wird das als "nicht geprüft werden konnte" behandelt, +/// nicht als Fehler. +/// +public static class RouterOsUpdateService +{ + private const int PollAttempts = 12; + private static readonly TimeSpan PollDelay = TimeSpan.FromMilliseconds(500); + + public static async Task CheckForUpdatesAsync(IRouterOsClient client, CancellationToken cancellationToken = default) + { + try + { + await client.ExecuteAsync("/system/package/update/check-for-updates", cancellationToken: cancellationToken); + + for (var attempt = 0; attempt < PollAttempts; attempt++) + { + await Task.Delay(PollDelay, cancellationToken); + + var rows = await client.GetAsync("/system/package/update", cancellationToken); + var row = rows.FirstOrDefault(); + if (row is null) + { + return RouterOsUpdateInfo.CheckFailed(); + } + + var status = row.GetValueOrDefault("status", string.Empty); + if (status.Contains("checking", StringComparison.OrdinalIgnoreCase)) + { + continue; + } + + var installed = row.GetValueOrDefault("installed-version", string.Empty); + var latest = row.GetValueOrDefault("latest-version"); + var isAvailable = !string.IsNullOrWhiteSpace(latest) + && !string.Equals(latest, installed, StringComparison.OrdinalIgnoreCase); + + return new RouterOsUpdateInfo(true, installed, latest, isAvailable); + } + + return RouterOsUpdateInfo.CheckFailed(); + } + catch (RouterOsException) + { + return RouterOsUpdateInfo.CheckFailed(); + } + } + + public static Task StartUpdateAsync(IRouterOsClient client, CancellationToken cancellationToken = default) => + client.ExecuteAsync("/system/package/update/install", cancellationToken: cancellationToken); +}