diff --git a/.github/workflows/prove.yml b/.github/workflows/prove.yml new file mode 100644 index 0000000..9cc48b0 --- /dev/null +++ b/.github/workflows/prove.yml @@ -0,0 +1,48 @@ +# Ogni pull request: si compila l'app e si fanno le prove, su Windows. Se sono rosse non si unisce. +# Il menu di Windows 11 (Zig) lo compila il flusso di rilascio: qui, se la DLL non c'è, quella prova esce da sola. +name: Prove + +on: + pull_request: + workflow_dispatch: + +jobs: + prove: + runs-on: windows-latest + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-dotnet@v4 + with: + dotnet-version: 10.0.x + + - uses: actions/setup-node@v4 + with: + node-version: 22 + + - name: FFmpeg + shell: pwsh + run: ./scripts/prendi-ffmpeg.ps1 + + - name: 7-Zip + shell: pwsh + run: ./scripts/prendi-7zip.ps1 + + - name: Interfaccia + shell: pwsh + working-directory: ui + run: | + if (-not (Test-Path node_modules)) { + npm ci --no-audit --no-fund + if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE } + } + npm run build + if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE } + + - name: App + shell: pwsh + run: dotnet build src/DaPConvertitore/DaPConvertitore.csproj -c Release -nologo + + - name: Prove + shell: pwsh + run: dotnet test test/DaPConvertitore.Prove -c Release -nologo diff --git a/.github/workflows/rilascio.yml b/.github/workflows/rilascio.yml index baa025c..3b60872 100644 --- a/.github/workflows/rilascio.yml +++ b/.github/workflows/rilascio.yml @@ -1,7 +1,7 @@ # Ogni volta che su main arriva una versione nuova (il di Directory.Build.props) GitHub fa le prove, # compila, impacchetta con Velopack e pubblica la release vX.Y.Z con Setup.exe, portatile e i pacchetti per gli -# aggiornamenti automatici. Le prove girano ma non fermano la release (come in DaProd Video): i runner di GitHub -# non hanno LibreOffice né le estensioni HEIF, quindi qualche prova lì può dire cose che sul PC vero non succedono. +# aggiornamenti automatici. Le prove devono passare: se sono rosse la release non esce. LibreOffice e le estensioni +# HEIF sui runner non ci sono: quelle prove, se il pezzo manca, escono da sole (non sono un fallimento). name: Rilascio on: @@ -61,17 +61,9 @@ jobs: run: ./scripts/compila-menu.ps1 - name: Prove - id: prove - continue-on-error: true shell: pwsh run: dotnet test test/DaPConvertitore.Prove -nologo - - name: Esito delle prove - if: steps.prove.outcome == 'failure' - shell: pwsh - run: | - Write-Host "::warning title=Prove::Qualche prova non è passata, guarda il passo Prove (la release esce lo stesso)" - - name: Pacchetto if: steps.versione.outputs.esiste == 'no' shell: pwsh diff --git a/CHANGELOG.md b/CHANGELOG.md index e25bf26..f7bf22a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,22 @@ Le novità di ogni versione, dette come stanno. La più nuova sta in alto. +## 2.2.6 — 3 novembre 2026 + +- **Le miniature dei documenti Word non vanno più in errore.** Disegnando la pagina si chiedeva «zero righe» di testo e Windows rifiutava + (nel registro, ArgumentOutOfRangeException, sei volte su un `.docx`). Ora si disegnano le righe che ci stanno. Vale anche per le diapositive. +- **«Scegli il personaggio» si chiude senza errore.** Chiudendo la finestrella, la chiusura richiamava se stessa e Windows rispondeva che la + finestra era già in chiusura (InvalidOperationException). +- **Gli aggiornamenti non si pestano i piedi, e un 403 di GitHub non è più un errore rosso.** Due controlli insieme litigavano per il + lucchetto di Velopack («Failed to acquire exclusive lock»): ora ne parte uno alla volta. Il controllo legge il file della release + (`releases.win.json`), non l'API di GitHub, che senza accesso si ferma dopo poche richieste. Se la rete manca, o se GitHub chiede comunque + di aspettare, si riprova più tardi (dopo un limite, dopo ore, non ogni 20 minuti) e nel registro non finisce come errore. L'avviso resta + nella barra in alto; dopo l'aggiornamento le novità si aprono da sole, come prima. +- **Spostare lo slider del peso di una foto non scrive più un errore.** La stima vecchia si ferma quando ne parte una nuova: era una + cancellazione normale e finiva nel registro come TaskCanceledException. +- **Trascinare un file dentro non può più far cadere il programma** se qualcosa va storto in quel passaggio. +- **Le prove fermano la release** se sono rosse, e ogni pull request le fa girare (prima partivano solo su main e un rosso non bloccava niente). + ## 2.2.5 — 29 ottobre 2026 - **App predefinite: ora si capisce cosa succede.** Windows applica la regola «apri tutto con DaProd» solo **all'accesso**: finché non ti diff --git a/Directory.Build.props b/Directory.Build.props index cd5e350..6f43db4 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -2,7 +2,7 @@ - 2.2.5 + 2.2.6 DaProd DaProdProduzioni DaP Convertitore diff --git a/src/DaPConvertitore.Motore/EccezioniPonte.cs b/src/DaPConvertitore.Motore/EccezioniPonte.cs new file mode 100644 index 0000000..46a865a --- /dev/null +++ b/src/DaPConvertitore.Motore/EccezioniPonte.cs @@ -0,0 +1,10 @@ +namespace DaP.Convertitore; + +/// +/// Cosa il ponte fra la pagina e il motore deve scrivere nel registro. +/// Una stima annullata perché ne è partita un'altra (lo slider della foto) non è un errore. +/// +public static class EccezioniPonte +{ + public static bool DaRegistro(Exception e) => e is not OperationCanceledException; +} diff --git a/src/DaPConvertitore.Motore/EsitoAggiornamento.cs b/src/DaPConvertitore.Motore/EsitoAggiornamento.cs new file mode 100644 index 0000000..11e9221 --- /dev/null +++ b/src/DaPConvertitore.Motore/EsitoAggiornamento.cs @@ -0,0 +1,50 @@ +using System.Net; +using System.Net.Http; + +namespace DaP.Convertitore; + +/// +/// Come è andato un controllo aggiornamenti. Il limite di GitHub e il lucchetto di Velopack +/// (due controlli insieme) non sono un guasto: si riprova più tardi, senza scriverli come errore. +/// +public static class EsitoAggiornamento +{ + public enum Tipo { Fatto, Presto, Tardi, Guasto } + + public static Tipo Di(Exception e) + { + Tipo? rete = null; + for (Exception? x = e; x is not null; x = x.InnerException) + { + var nome = x.GetType().Name; + var msg = x.Message ?? ""; + if (nome.Contains("AcquireLock", StringComparison.Ordinal) + || msg.Contains("exclusive lock", StringComparison.OrdinalIgnoreCase) + || msg.Contains(".velopack_lock", StringComparison.OrdinalIgnoreCase)) + return Tipo.Presto; + if (x is HttpRequestException http) + { + if (http.StatusCode is HttpStatusCode.Forbidden or HttpStatusCode.TooManyRequests) return Tipo.Tardi; + if (http.StatusCode is HttpStatusCode.NotFound) return Tipo.Guasto; + rete ??= Tipo.Presto; + } + if (msg.Contains("rate limit", StringComparison.OrdinalIgnoreCase) || ÈCodice(msg, 403) || ÈCodice(msg, 429)) + return Tipo.Tardi; + if (ÈCodice(msg, 404)) return Tipo.Guasto; + if (nome is "SocketException" or "TimeoutException" or "WebException") rete ??= Tipo.Presto; + } + return rete ?? Tipo.Guasto; + } + + /// La riga nel registro, per i casi che non sono un errore dell'app. + public static string Nota(Tipo tipo) => tipo switch + { + Tipo.Tardi => "GitHub ha chiesto di aspettare, riprovo più tardi", + Tipo.Presto => "lo riprovo fra un po' (rete o un altro controllo già in corso)", + Tipo.Fatto => "fatto", + _ => "è andato storto", + }; + + static bool ÈCodice(string msg, int codice) => + msg.Contains("status code", StringComparison.OrdinalIgnoreCase) && msg.Contains(codice.ToString(), StringComparison.Ordinal); +} diff --git a/src/DaPConvertitore.Motore/FonteAggiornamenti.cs b/src/DaPConvertitore.Motore/FonteAggiornamenti.cs new file mode 100644 index 0000000..a6ce56d --- /dev/null +++ b/src/DaPConvertitore.Motore/FonteAggiornamenti.cs @@ -0,0 +1,14 @@ +namespace DaP.Convertitore; + +/// +/// Da dove arrivano gli aggiornamenti. Non è l'API di GitHub (api.github.com): senza token +/// quella si ferma dopo 60 richieste l'ora e risponde 403. Si legge il file releases.win.json +/// allegato alla release, lo stesso che pubblica Velopack. +/// +public static class FonteAggiornamenti +{ + public const string Repo = "https://github.com/cammo22/DaP-Convertitore"; + + /// La cartella della release: ci stanno releases.win.json e i pacchetti. + public static Uri Pacchetti { get; } = new(Repo + "/releases/latest/download/"); +} diff --git a/src/DaPConvertitore.Motore/RigheTesto.cs b/src/DaPConvertitore.Motore/RigheTesto.cs new file mode 100644 index 0000000..f96baec --- /dev/null +++ b/src/DaPConvertitore.Motore/RigheTesto.cs @@ -0,0 +1,11 @@ +namespace DaP.Convertitore; + +/// +/// Quante righe di testo sta in una miniatura. FormattedText.MaxLineCount di WPF +/// lancia ArgumentOutOfRangeException se gli si dà 0 o meno (è successo con i .docx): +/// 0 qui vuol dire «quante ce ne stanno nell'altezza», che per WPF è . +/// +public static class RigheTesto +{ + public static int Massimo(int richiesto) => richiesto > 0 ? richiesto : int.MaxValue; +} diff --git a/src/DaPConvertitore.Motore/UnoAllaVolta.cs b/src/DaPConvertitore.Motore/UnoAllaVolta.cs new file mode 100644 index 0000000..e83691c --- /dev/null +++ b/src/DaPConvertitore.Motore/UnoAllaVolta.cs @@ -0,0 +1,28 @@ +namespace DaP.Convertitore; + +/// +/// Un lavoro per volta: il secondo aspetta che il primo abbia finito. +/// Gli aggiornamenti ne hanno bisogno, perché Velopack tiene un lucchetto +/// (.velopack_lock) e il secondo controllo fallisce se il primo è ancora dentro. +/// +public sealed class UnoAllaVolta +{ + readonly SemaphoreSlim porta = new(1, 1); + + public async Task Esegui(Func> lavoro, CancellationToken ct = default) + { + await porta.WaitAsync(ct).ConfigureAwait(false); + try { return await lavoro().ConfigureAwait(false); } + finally { porta.Release(); } + } + + public async Task Esegui(Func lavoro, CancellationToken ct = default) + { + await Esegui(async () => { await lavoro().ConfigureAwait(false); return 0; }, ct).ConfigureAwait(false); + } + + /// Entra se la porta si libera entro ; poi va chiamato . + public bool Prova(TimeSpan attesa) => porta.Wait(attesa); + + public void Esci() => porta.Release(); +} diff --git a/src/DaPConvertitore/Aggiornamenti.cs b/src/DaPConvertitore/Aggiornamenti.cs index 90d5579..eadbedf 100644 --- a/src/DaPConvertitore/Aggiornamenti.cs +++ b/src/DaPConvertitore/Aggiornamenti.cs @@ -4,24 +4,31 @@ namespace DaP.Convertitore.App; /// -/// Gli aggiornamenti arrivano dalle release di GitHub (Velopack: scarica solo la differenza). -/// Un ciclo solo per tutta l'app (convertitore e lettore sono finestre dello stesso processo): guarda all'avvio e poi -/// ogni , senza bloccare niente e senza lamentarsi se sei offline. Appena trova una versione -/// nuova lo dice a tutte le finestre («Aggiornamento X.Y.Z disponibile» in alto), poi la scarica in silenzio. -/// Il clic sul badge la installa; se non lo premi, si mette da sola quando chiudi l'app. +/// Gli aggiornamenti arrivano dal file releases.win.json della release (Velopack: scarica solo la differenza). +/// Non si chiede all'API di GitHub: senza token quella risponde 403 dopo poche richieste. +/// Un ciclo solo per tutta l'app (convertitore e lettore sono finestre dello stesso processo), e un controllo +/// alla volta: Velopack tiene il lucchetto .velopack_lock e il secondo, se parte insieme, fallisce. +/// Guarda all'avvio e poi ogni , senza bloccare niente. Se la rete manca si riprova fra +/// ; se GitHub chiede di aspettare, fra , e non è un errore. +/// Appena trova una versione nuova lo dice a tutte le finestre («Aggiornamento X.Y.Z disponibile» in alto), +/// poi la scarica in silenzio. Il clic sul badge la installa; se non lo premi, si mette da sola quando chiudi l'app. /// public static class Aggiornamenti { - const string Repo = "https://github.com/cammo22/DaP-Convertitore"; - /// Ogni quanto si ricontrolla se l'app resta aperta a lungo. public static readonly TimeSpan OgniQuanto = TimeSpan.FromHours(4); - /// Se il controllo fallisce (offline, GitHub giù) si riprova prima. + /// Se il controllo fallisce per la rete si riprova prima. public static readonly TimeSpan DopoUnErrore = TimeSpan.FromMinutes(20); + /// Dopo un 403 non si martella: il limite di GitHub dura delle ore. + public static readonly TimeSpan DopoIlLimite = TimeSpan.FromHours(6); /// Per le prove a mano: con questa variabile l'app finge che esista quella versione (niente rete, niente installazione). public const string VariabileFinta = "DAP_AGGIORNAMENTO_FINTO"; + static readonly UnoAllaVolta turno = new(); + static readonly CancellationTokenSource fermo = new(); + // 1 mentre si sta già applicando: la chiusura non deve riprendere il lucchetto (si bloccherebbe da sola) + static int applicazione; static UpdateInfo? trovato; static VelopackAsset? scaricato; static string? disponibile; @@ -33,7 +40,7 @@ public static class Aggiornamenti /// Scatta (da un thread qualsiasi) quando compare una versione nuova. public static event Action? Trovata; - static UpdateManager Gestore() => new(new GithubSource(Repo, null, false)); + static UpdateManager Gestore() => new(new SimpleWebSource(FonteAggiornamenti.Pacchetti)); static string? Finta => Environment.GetEnvironmentVariable(VariabileFinta) is { Length: > 0 } v ? v : null; @@ -41,37 +48,58 @@ public static class Aggiornamenti public static void Avvia() { if (Interlocked.Exchange(ref avviato, 1) == 1) return; - _ = Task.Run(Ciclo); + _ = Task.Run(() => Ciclo(fermo.Token)); } - static async Task Ciclo() + static async Task Ciclo(CancellationToken ct) { - while (true) + while (!ct.IsCancellationRequested) { - var riuscito = await ControllaEAvvisa(); - await Task.Delay(riuscito ? OgniQuanto : DopoUnErrore); + var esito = await ControllaEAvvisa(ct).ConfigureAwait(false); + var pausa = esito switch + { + EsitoAggiornamento.Tipo.Fatto => OgniQuanto, + EsitoAggiornamento.Tipo.Tardi => DopoIlLimite, + _ => DopoUnErrore, + }; + try { await Task.Delay(pausa, ct).ConfigureAwait(false); } + catch (OperationCanceledException) { break; } } } - /// Un giro: cerca, avvisa, scarica. Restituisce false se non si è potuto controllare. - static async Task ControllaEAvvisa() + /// Un giro: cerca, avvisa, scarica. anche se non c'è niente di nuovo. + static async Task ControllaEAvvisa(CancellationToken ct) { try { - if (Finta is { } finta) { Segnala(finta); return true; } - var g = Gestore(); - if (!g.IsInstalled) return true; // in sviluppo non c'è niente da aggiornare: inutile ricontrollare ogni 20 minuti - var nuovo = await g.CheckForUpdatesAsync(); - if (nuovo is null) return true; - trovato = nuovo; - Segnala(nuovo.TargetFullRelease.Version.ToString()); - if (scaricato?.Version == nuovo.TargetFullRelease.Version) return true; - await g.DownloadUpdatesAsync(nuovo); - scaricato = nuovo.TargetFullRelease; - Registro.Scrivi($"Aggiornamento {scaricato.Version} scaricato"); - return true; + await turno.Esegui(() => Gira(scarica: true, ct), ct).ConfigureAwait(false); + return EsitoAggiornamento.Tipo.Fatto; + } + catch (OperationCanceledException) { return EsitoAggiornamento.Tipo.Fatto; } + catch (Exception e) + { + Annota("aggiornamenti", e); + return EsitoAggiornamento.Di(e); } - catch (Exception e) { Registro.Errore("aggiornamenti", e); return false; } + } + + /// Cerca (e, se serve, scarica). Resta nel turno: non si chiama da fuori. + static async Task Gira(bool scarica, CancellationToken ct) + { + if (Finta is { } finta) { Segnala(finta); return finta; } + var g = Gestore(); + if (!g.IsInstalled) return null; // in sviluppo non c'è niente da aggiornare + var nuovo = await g.CheckForUpdatesAsync().ConfigureAwait(false); + ct.ThrowIfCancellationRequested(); + if (nuovo is null) return null; + trovato = nuovo; + var v = nuovo.TargetFullRelease.Version.ToString(); + Segnala(v); + if (!scarica || scaricato?.Version == nuovo.TargetFullRelease.Version) return v; + await g.DownloadUpdatesAsync(nuovo, cancelToken: ct).ConfigureAwait(false); + scaricato = nuovo.TargetFullRelease; + Registro.Scrivi($"Aggiornamento {scaricato.Version} scaricato"); + return v; } static void Segnala(string versione) @@ -82,42 +110,67 @@ static void Segnala(string versione) try { Trovata?.Invoke(versione); } catch (Exception e) { Registro.Errore("aggiornamenti (avviso)", e); } } - /// Il tasto «Cerca aggiornamenti» delle impostazioni: guarda subito, adesso. Fuori dall'installazione non c'è mai niente. + static void Annota(string dove, Exception e) + { + var tipo = EsitoAggiornamento.Di(e); + if (tipo == EsitoAggiornamento.Tipo.Guasto) Registro.Errore(dove, e); + else Registro.Scrivi($"{dove}: {EsitoAggiornamento.Nota(tipo)} ({e.Message})"); + } + + /// Il tasto «Cerca aggiornamenti» delle novità: guarda subito, adesso. Fuori dall'installazione non c'è mai niente. public static async Task Controlla() { - try - { - if (Finta is { } finta) { Segnala(finta); return finta; } - var g = Gestore(); - if (!g.IsInstalled) return null; - trovato = await g.CheckForUpdatesAsync(); - var v = trovato?.TargetFullRelease.Version.ToString(); - if (v is not null) Segnala(v); - return v; - } - catch (Exception e) { Registro.Errore("aggiornamenti", e); return null; } + try { return await turno.Esegui(() => Gira(scarica: false, CancellationToken.None)).ConfigureAwait(false); } + catch (Exception e) { Annota("aggiornamenti", e); return null; } } public static async Task Installa() { if (Finta is not null) { Registro.Scrivi("Aggiornamento finto: niente da installare"); return; } - var g = Gestore(); - if (!g.IsInstalled) return; - if (scaricato is null) + VelopackAsset? pacchetto = null; + await turno.Esegui(async () => + { + var g = Gestore(); + if (!g.IsInstalled) return; + if (scaricato is null) + { + trovato ??= await g.CheckForUpdatesAsync().ConfigureAwait(false); + if (trovato is null) return; + Segnala(trovato.TargetFullRelease.Version.ToString()); + await g.DownloadUpdatesAsync(trovato).ConfigureAwait(false); + scaricato = trovato.TargetFullRelease; + } + pacchetto = scaricato; + // il riavvio fa scattare la chiusura: lì non si riprende il lucchetto, lo tiene già Velopack + if (pacchetto is not null) Interlocked.Exchange(ref applicazione, 1); + }).ConfigureAwait(false); + if (pacchetto is null) return; + try { Gestore().ApplyUpdatesAndRestart(pacchetto); } + catch { - trovato ??= await g.CheckForUpdatesAsync(); - if (trovato is null) return; - await g.DownloadUpdatesAsync(trovato); - scaricato = trovato.TargetFullRelease; + Interlocked.Exchange(ref applicazione, 0); + throw; } - g.ApplyUpdatesAndRestart(scaricato); } /// Alla chiusura: se c'è una versione scaricata, Velopack la mette appena l'app è uscita. public static void AllaChiusura() { - if (scaricato is null) return; - try { Gestore().WaitExitThenApplyUpdates(scaricato, true, false, []); } - catch (Exception e) { Registro.Errore("aggiornamento alla chiusura", e); } + try { fermo.Cancel(); } + catch (Exception e) { Registro.Scrivi($"Aggiornamenti: stop del ciclo ({e.Message})"); } + if (Volatile.Read(ref applicazione) == 1) return; + // il controllo in corso tiene il lucchetto: si aspetta un po', poi ci pensa il prossimo avvio + if (!turno.Prova(TimeSpan.FromSeconds(25))) + { + Registro.Scrivi("Aggiornamento alla chiusura: un controllo è ancora in corso, ci pensa il prossimo avvio"); + return; + } + try + { + if (scaricato is null) return; + Gestore().WaitExitThenApplyUpdates(scaricato, true, false, []); + } + catch (Exception e) { Annota("aggiornamento alla chiusura", e); } + finally { turno.Esci(); } } } diff --git a/src/DaPConvertitore/AvatarStrumenti.cs b/src/DaPConvertitore/AvatarStrumenti.cs index 6487774..12373aa 100644 --- a/src/DaPConvertitore/AvatarStrumenti.cs +++ b/src/DaPConvertitore/AvatarStrumenti.cs @@ -271,7 +271,25 @@ public ScegliPersonaggio(FinestraAvatar avatar) Loaded += (_, _) => Posiziona(); avatar.Spostato += Posiziona; avatar.Trasformato += Evidenzia; - Deactivated += (_, _) => Close(); + // un clic fuori chiude. Ma Deactivated arriva anche mentre la finestra si sta già chiudendo + // (la X, Esc): richiamare Close() lì lancia InvalidOperationException. + bool inChiusura = false; + Closing += (_, _) => inChiusura = true; + Deactivated += (_, _) => + { + if (inChiusura) return; + try + { + Dispatcher.BeginInvoke(() => + { + if (inChiusura) return; + inChiusura = true; + try { Close(); } + catch (InvalidOperationException) { /* già in chiusura */ } + }); + } + catch (InvalidOperationException) { /* il dispatcher sta chiudendo */ } + }; Closed += (_, _) => { avatar.Spostato -= Posiziona; avatar.Trasformato -= Evidenzia; }; PreviewKeyDown += (_, e) => { if (e.Key == Key.Escape) Close(); }; } diff --git a/src/DaPConvertitore/Miniature/Documenti.cs b/src/DaPConvertitore/Miniature/Documenti.cs index f8dc1e4..c9f4403 100644 --- a/src/DaPConvertitore/Miniature/Documenti.cs +++ b/src/DaPConvertitore/Miniature/Documenti.cs @@ -40,7 +40,14 @@ public static class Documenti ZipArchive? zip = null; try { - try { zip = ZipFile.OpenRead(percorso); } catch { zip = null; } + // un .doc vecchio, o un file rovinato, non è uno zip: si disegna la pagina senza il testo + try { zip = ZipFile.OpenRead(percorso); } + catch (Exception e) + { + zip = null; + if (e is not InvalidDataException and not IOException) + Registro.Scrivi($"Miniatura di {Path.GetFileName(percorso)}: {e.GetType().Name}: {e.Message}"); + } // 1. l'anteprima che il programma ha messo dentro al file if (zip is not null) foreach (var nome in new[] { "docProps/thumbnail.jpeg", "docProps/thumbnail.jpg", "docProps/thumbnail.png", "Thumbnails/thumbnail.png" }) @@ -114,7 +121,9 @@ static Quadro Pagina(ZipArchive? zip, string percorso, int L, string est, Color dc.DrawText(titolo, new Point(margine, y)); y += titolo.Height + fs * 0.7; var corpo = Scritte.Testo(string.Join("\n", righe.Skip(1)), Scritte.Corpo, fs, scuro, W - margine * 2); - corpo.MaxLineCount = 0; + // con la larghezza, Scritte.Testo mette una riga sola. 0 vorrebbe dire «quante ce ne stanno + // in altezza», ma WPF rifiuta MaxLineCount <= 0 (ArgumentOutOfRangeException sui .docx) + corpo.MaxLineCount = RigheTesto.Massimo(0); corpo.MaxTextWidth = W - margine * 2; corpo.MaxTextHeight = Math.Max(fs, H - y - margine * 0.5); corpo.Trimming = TextTrimming.CharacterEllipsis; @@ -158,7 +167,7 @@ static Quadro Diapositiva(ZipArchive? zip, int L, string est, Color tinta) if (righe.Count > 1) { var sotto = Scritte.Testo(string.Join("\n", righe.Skip(1)), Scritte.Corpo, H * 0.085, Tavolozza.P(Colors.White, 0.7), W - m * 1.6); - sotto.MaxLineCount = 0; + sotto.MaxLineCount = RigheTesto.Massimo(0); sotto.MaxTextHeight = H * 0.32; sotto.Trimming = TextTrimming.CharacterEllipsis; dc.DrawText(sotto, new Point(m, H * 0.2 + Math.Min(t.Height, H * 0.45) + H * 0.06)); diff --git a/src/DaPConvertitore/Ponte.cs b/src/DaPConvertitore/Ponte.cs index e79fd37..fdc7a92 100644 --- a/src/DaPConvertitore/Ponte.cs +++ b/src/DaPConvertitore/Ponte.cs @@ -189,24 +189,31 @@ async void Ricevi(object? _, CoreWebView2WebMessageReceivedEventArgs e) { JsonNode? m; try { m = JsonNode.Parse(e.WebMessageAsJson); } - catch { return; } + catch { return; /* non è JSON: si ignora */ } if (m is null) return; var cmd = (string?)m["cmd"] ?? ""; var id = m["id"]?.GetValue(); var args = m["args"] as JsonObject ?? []; - if (cmd == "lasciati") - { - // i file trascinati dentro: WebView2 ci dà i percorsi veri - var percorsi = e.AdditionalObjects?.OfType().Select(f => f.Path).ToList() ?? []; - Gestisci(new Richiesta(null, percorsi, true)); - return; - } try { + if (cmd == "lasciati") + { + // i file trascinati dentro: WebView2 ci dà i percorsi veri. Sta nel try: è un async void, + // un'eccezione qui fuori chiuderebbe l'app. + var percorsi = e.AdditionalObjects?.OfType().Select(f => f.Path).ToList() ?? []; + Gestisci(new Richiesta(null, percorsi, true)); + if (id is not null) Rispondi(id.Value, true, percorsi.Count, null); + return; + } var dati = await Esegui(cmd, args); if (id is not null) Rispondi(id.Value, true, dati, null); } + catch (Exception ex) when (!EccezioniPonte.DaRegistro(ex)) + { + // la stima nuova ha fermato la vecchia: la pagina non aspetta più questo risultato + if (id is not null) Rispondi(id.Value, false, null, null); + } catch (Exception ex) { Registro.Errore($"ponte {cmd}", ex); diff --git a/src/DaPConvertitore/PonteLettore.cs b/src/DaPConvertitore/PonteLettore.cs index 06c0104..916d028 100644 --- a/src/DaPConvertitore/PonteLettore.cs +++ b/src/DaPConvertitore/PonteLettore.cs @@ -72,22 +72,28 @@ async void Ricevi(object? _, CoreWebView2WebMessageReceivedEventArgs e) { JsonNode? m; try { m = JsonNode.Parse(e.WebMessageAsJson); } - catch { return; } + catch { return; /* non è JSON: si ignora */ } if (m is null) return; var cmd = (string?)m["cmd"] ?? ""; var id = m["id"]?.GetValue(); var args = m["args"] as JsonObject ?? []; - if (cmd == "lasciati") - { - var percorsi = e.AdditionalObjects?.OfType().Select(f => f.Path).Where(File.Exists).ToList() ?? []; - if (percorsi.Count > 0) Apri(percorsi); - return; - } try { + if (cmd == "lasciati") + { + // nel try: questo metodo è async void, un'eccezione qui fuori chiuderebbe l'app + var percorsi = e.AdditionalObjects?.OfType().Select(f => f.Path).Where(File.Exists).ToList() ?? []; + if (percorsi.Count > 0) Apri(percorsi); + if (id is not null) Rispondi(id.Value, true, percorsi.Count, null); + return; + } var dati = await Esegui(cmd, args); if (id is not null) Rispondi(id.Value, true, dati, null); } + catch (Exception ex) when (!EccezioniPonte.DaRegistro(ex)) + { + if (id is not null) Rispondi(id.Value, false, null, null); + } catch (Exception ex) { if (ex is not ErroreConversione) Registro.Errore($"lettore {cmd}", ex); diff --git a/test/DaPConvertitore.Prove/ProveRobustezza.cs b/test/DaPConvertitore.Prove/ProveRobustezza.cs new file mode 100644 index 0000000..425660d --- /dev/null +++ b/test/DaPConvertitore.Prove/ProveRobustezza.cs @@ -0,0 +1,96 @@ +using System.Net; +using System.Net.Http; + +namespace DaP.Convertitore.Prove; + +/// +/// Le correzioni del registro: le righe delle miniature, gli aggiornamenti che non si pestano i piedi, +/// il 403 di GitHub e la stima annullata che non è un errore. +/// +public class ProveRobustezza +{ + [Fact] + public void ZeroRigheVuolDireSenzaLimite() + { + // WPF rifiuta MaxLineCount <= 0: 0 deve diventare «tutte quelle che ci stanno» + Assert.Equal(int.MaxValue, RigheTesto.Massimo(0)); + Assert.Equal(int.MaxValue, RigheTesto.Massimo(-3)); + Assert.Equal(2, RigheTesto.Massimo(2)); + Assert.True(RigheTesto.Massimo(0) > 0); + } + + [Fact] + public void IlFeedNonPassaDallApiDiGitHub() + { + var u = FonteAggiornamenti.Pacchetti; + Assert.Equal("github.com", u.Host); + Assert.DoesNotContain("api.github.com", u.AbsoluteUri, StringComparison.OrdinalIgnoreCase); + Assert.EndsWith("/releases/latest/download/", u.AbsoluteUri); + Assert.EndsWith("/releases/latest/download/releases.win.json", u.AbsoluteUri.TrimEnd('/') + "/releases.win.json"); + } + + [Fact] + public void IlLimiteEIlLucchettoNonSonoUnGuasto() + { + var lucchetto = new InvalidOperationException("Failed to acquire exclusive lock file. Is another operation currently running?"); + Assert.Equal(EsitoAggiornamento.Tipo.Presto, EsitoAggiornamento.Di(lucchetto)); + Assert.Equal(EsitoAggiornamento.Tipo.Presto, EsitoAggiornamento.Di(new IOException("no", new Exception("cannot lock .velopack_lock")))); + + var limite = new HttpRequestException("Response status code does not indicate success: 403 (rate limit exceeded).", null, HttpStatusCode.Forbidden); + Assert.Equal(EsitoAggiornamento.Tipo.Tardi, EsitoAggiornamento.Di(limite)); + Assert.Equal(EsitoAggiornamento.Tipo.Tardi, EsitoAggiornamento.Di(new HttpRequestException("Response status code does not indicate success: 429 (Too Many Requests).", null, HttpStatusCode.TooManyRequests))); + Assert.Equal(EsitoAggiornamento.Tipo.Tardi, EsitoAggiornamento.Di(new Exception("API rate limit exceeded for 1.2.3.4"))); + + Assert.Equal(EsitoAggiornamento.Tipo.Guasto, EsitoAggiornamento.Di(new HttpRequestException("Response status code does not indicate success: 404 (Not Found).", null, HttpStatusCode.NotFound))); + Assert.Equal(EsitoAggiornamento.Tipo.Presto, EsitoAggiornamento.Di(new HttpRequestException("No such host is known."))); + Assert.Equal(EsitoAggiornamento.Tipo.Guasto, EsitoAggiornamento.Di(new InvalidOperationException("boom"))); + + Assert.DoesNotContain("ERRORE", EsitoAggiornamento.Nota(EsitoAggiornamento.Tipo.Tardi), StringComparison.Ordinal); + Assert.DoesNotContain("ERRORE", EsitoAggiornamento.Nota(EsitoAggiornamento.Tipo.Presto), StringComparison.Ordinal); + } + + [Fact] + public void LaStimaAnnullataNonVaNelRegistro() + { + Assert.False(EccezioniPonte.DaRegistro(new TaskCanceledException())); + Assert.False(EccezioniPonte.DaRegistro(new OperationCanceledException())); + Assert.True(EccezioniPonte.DaRegistro(new InvalidOperationException("x"))); + } + + [Fact] + public async Task DueControlliNonVannoInsiemeEDopoUnErroreSiRiparte() + { + var porta = new UnoAllaVolta(); + var insieme = 0; + var massimo = 0; + async Task Lavoro() + { + await porta.Esegui(async () => + { + var n = Interlocked.Increment(ref insieme); + massimo = Math.Max(massimo, n); + await Task.Delay(40); + Interlocked.Decrement(ref insieme); + }); + } + await Task.WhenAll(Lavoro(), Lavoro(), Lavoro()); + Assert.Equal(1, massimo); + + await Assert.ThrowsAsync(() => porta.Esegui(async () => + { + await Task.Yield(); + throw new InvalidOperationException("x"); + })); + var entrato = false; + await porta.Esegui(() => { entrato = true; return Task.CompletedTask; }); + Assert.True(entrato); + + var dentro = new TaskCompletionSource(); + var occupata = porta.Esegui(async () => { dentro.SetResult(); await Task.Delay(400); }); + await dentro.Task; + Assert.False(porta.Prova(TimeSpan.Zero)); + await occupata; + Assert.True(porta.Prova(TimeSpan.FromSeconds(2))); + porta.Esci(); + } +}