From f7237145aaea71a3e2df1c3740ab754b82406504 Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Tue, 20 Oct 2026 10:22:48 +0200 Subject: [PATCH 01/17] Prove: il seme del mondo sintetico si sceglie con FEBE_SEME_PROVA MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Le prove avviano il sito di prova solo da SyntheticSite, che legge il seme da FEBE_SEME_PROVA e usa 13 quando manca: senza la variabile non cambia nulla. Le classi che lo avviano stanno nella categoria SitoDiProva, così la CI può rifarle con un seme diverso a ogni esecuzione senza raddoppiare tutta la suite, e il seme finisce nell'output della prova per rifare un errore. Nuove prove senza browser: la forma del mondo su cui contano le prove d'insieme vale per 300 semi, i lettori leggono pagina dopo pagina ciò che il sito serve con il seme dell'esecuzione, e nessuna prova avvia il sito per altre vie o resta fuori dalla categoria. Co-Authored-By: Claude Opus 5.5 --- docs/decisioni.md | 1 + .../Collection/ProbeIntegrationTests.cs | 4 +- .../Collection/RecipeIntegrationTests.cs | 2 + .../StopAndDownloadIntegrationTests.cs | 2 + .../Collection/Support/CollectionHarness.cs | 2 +- .../Collection/SyntheticSiteSeedTests.cs | 245 ++++++++++++++++++ .../Febe.Tests/Server/ServerEndToEndTests.cs | 2 + .../Server/Support/ServerTestBed.cs | 2 +- tests/Febe.Tests/Support/SyntheticSite.cs | 46 ++++ tools/Febe.SitoDiProva/LEGGIMI.md | 6 +- 10 files changed, 307 insertions(+), 5 deletions(-) create mode 100644 tests/Febe.Tests/Collection/SyntheticSiteSeedTests.cs create mode 100644 tests/Febe.Tests/Support/SyntheticSite.cs diff --git a/docs/decisioni.md b/docs/decisioni.md index be3e037..5d83e70 100644 --- a/docs/decisioni.md +++ b/docs/decisioni.md @@ -226,3 +226,4 @@ Ogni scelta tecnica presa strada facendo, con data e motivo (specifica §15). | 2026-10-13 | Prove dell'interfaccia in un Chromium senza finestra guidato col protocollo DevTools diretto (`UiBrowser`, solo 127.0.0.1), inconcludenti senza Chromium | Come `tools/schermate`; il client CDP di Febe accetta solo letture | | 2026-10-14 | Revisione avversaria di tutto il codice (7 aree, ogni rilievo verificato da un secondo revisore indipendente): 54 rilievi confermati e corretti con prove di regressione, 2 smentiti, 3 incerti corretti dove il rimedio era sicuro | §14, regola 14: resoconti onesti | | 2026-10-14 | Restano noti e accettati: «Tieni il più grande» scrive con il proprio SafeFileWriter e non passa dal lucchetto per account di `LibraryIngest` (un'importazione e uno scaricamento con gli stessi byte nello stesso istante potrebbero entrare entrambi); le prove d'interfaccia con browser vero aspettano fino a 30 s | Finestra rarissima, nessuna perdita di dati: al più un doppione esatto da togliere a mano | +| 2026-10-20 | Il seme del mondo sintetico del sito di prova si sceglie con la variabile `FEBE_SEME_PROVA` (13 se manca), letta da `SyntheticSite` (`tests/Febe.Tests/Support`), l'unico modo in cui le prove avviano il sito; le classi che lo avviano stanno nella categoria `SitoDiProva`, e una prova controlla che nessuna lo avvii per altre vie o resti fuori dalla categoria. `SyntheticSiteSeedTests` controlla senza browser, per 300 semi, la forma del mondo su cui contano le prove d'insieme e i lettori sulle pagine servite | La CI rifà quelle prove con un seme diverso a ogni esecuzione, scritto nel registro, senza raddoppiare la durata di tutta la suite; senza la variabile non cambia nulla; un errore si rifà con lo stesso seme | diff --git a/tests/Febe.Tests/Collection/ProbeIntegrationTests.cs b/tests/Febe.Tests/Collection/ProbeIntegrationTests.cs index 9a2ce6d..e5310ff 100644 --- a/tests/Febe.Tests/Collection/ProbeIntegrationTests.cs +++ b/tests/Febe.Tests/Collection/ProbeIntegrationTests.cs @@ -4,7 +4,6 @@ using Febe.Browser.Cdp; using Febe.Browser.Gestures; using Febe.Core.Abstractions; using Febe.Core.Collection; -using Febe.SitoDiProva; using Febe.Sonda; using Febe.Tests.Collection.Support; using Febe.Tests.Support; @@ -16,6 +15,7 @@ namespace Febe.Tests.Collection; /// the probe only listens. Then the whole M0 path: raw samples, cleaning, verification. /// [TestClass] +[TestCategory(SyntheticSite.Category)] [DoNotParallelize] public sealed class ProbeIntegrationTests { @@ -53,7 +53,7 @@ public sealed class ProbeIntegrationTests Assert.Inconclusive(s_unavailable); } - await using var site = await TestSite.StartAsync(); + await using var site = await SyntheticSite.StartAsync(); using var temp = new TempFolder("sonda"); var raw = temp.Combine("grezzi"); var hosts = new HostClassifier([site.SiteHost], [site.CdnHost]); diff --git a/tests/Febe.Tests/Collection/RecipeIntegrationTests.cs b/tests/Febe.Tests/Collection/RecipeIntegrationTests.cs index 3f6a8f8..33a16ea 100644 --- a/tests/Febe.Tests/Collection/RecipeIntegrationTests.cs +++ b/tests/Febe.Tests/Collection/RecipeIntegrationTests.cs @@ -5,6 +5,7 @@ using Febe.Core.Engine; using Febe.Core.Storage; using Febe.SitoDiProva; using Febe.Tests.Collection.Support; +using Febe.Tests.Support; namespace Febe.Tests.Collection; @@ -13,6 +14,7 @@ namespace Febe.Tests.Collection; /// Instagram. Time is compressed (a 2.2 s wait lasts about 0.2 s); the browser is shared and the tests run one at a time. /// [TestClass] +[TestCategory(SyntheticSite.Category)] [DoNotParallelize] public sealed class RecipeIntegrationTests { diff --git a/tests/Febe.Tests/Collection/StopAndDownloadIntegrationTests.cs b/tests/Febe.Tests/Collection/StopAndDownloadIntegrationTests.cs index a249095..770064c 100644 --- a/tests/Febe.Tests/Collection/StopAndDownloadIntegrationTests.cs +++ b/tests/Febe.Tests/Collection/StopAndDownloadIntegrationTests.cs @@ -7,6 +7,7 @@ using Febe.Core.Library; using Febe.Core.Storage; using Febe.SitoDiProva; using Febe.Tests.Collection.Support; +using Febe.Tests.Support; namespace Febe.Tests.Collection; @@ -14,6 +15,7 @@ namespace Febe.Tests.Collection; /// Stop signals (spec §7.6) and the download queue (spec §6.5) against the local test site with a real Chromium. /// [TestClass] +[TestCategory(SyntheticSite.Category)] [DoNotParallelize] public sealed class StopAndDownloadIntegrationTests { diff --git a/tests/Febe.Tests/Collection/Support/CollectionHarness.cs b/tests/Febe.Tests/Collection/Support/CollectionHarness.cs index f438f3a..b236511 100644 --- a/tests/Febe.Tests/Collection/Support/CollectionHarness.cs +++ b/tests/Febe.Tests/Collection/Support/CollectionHarness.cs @@ -129,7 +129,7 @@ internal sealed class CollectionHarness : IAsyncDisposable public static async Task CreateAsync(SharedChromium chromium, RecipeOptions? options = null, double factor = 10) { - var site = await TestSite.StartAsync(new TestSiteOptions()); + var site = await SyntheticSite.StartAsync(); var temp = new TempFolder("raccolta"); var library = await TestLibrary.CreateAsync(temp); var clock = new CompressedClock(factor, TestZones.Rome); diff --git a/tests/Febe.Tests/Collection/SyntheticSiteSeedTests.cs b/tests/Febe.Tests/Collection/SyntheticSiteSeedTests.cs new file mode 100644 index 0000000..2c43a0b --- /dev/null +++ b/tests/Febe.Tests/Collection/SyntheticSiteSeedTests.cs @@ -0,0 +1,245 @@ +using System.Globalization; +using System.Text.RegularExpressions; +using Febe.Core.Collection.Readers; +using Febe.Core.Domain; +using Febe.SitoDiProva; +using Febe.Tests.Desktop.Support; +using Febe.Tests.Support; + +namespace Febe.Tests.Collection; + +/// +/// The synthetic world of the test site and its seed (), without a browser, so they run +/// everywhere: what the integration tests take for granted holds for every seed, and the readers of +/// lettori.prova.json read what the site serves with the seed of this run, page after page. Never Instagram: +/// the site is on 127.0.0.1. +/// +[TestClass] +[TestCategory(SyntheticSite.Category)] +public sealed partial class SyntheticSiteSeedTests +{ + private static readonly ShapeReader Reader = new(ReaderVocabulary.LoadTestSite()); + + private static readonly string[] StoryBarOrder = ["marta.prova", "nadia.prova", "luca.prova", "giulia.prova"]; + + public TestContext TestContext { get; set; } = null!; + + [TestMethod] + public void TheSeedComesFromTheVariableAndIsThirteenWithoutIt() + { + Assert.AreEqual(13, SyntheticSite.ParseSeed(null)); + Assert.AreEqual(13, SyntheticSite.ParseSeed(" ")); + Assert.AreEqual(4242, SyntheticSite.ParseSeed("4242")); + Assert.AreEqual(-7, SyntheticSite.ParseSeed(" -7 ")); + Assert.ThrowsExactly(() => SyntheticSite.ParseSeed("tredici")); + Assert.ThrowsExactly(() => SyntheticSite.ParseSeed("99999999999")); + } + + [TestMethod] + public void EveryTestThatStartsTheSiteTakesTheSeedOfTheRunAndIsInItsCategory() + { + var tests = Repository.PathOf("tests", "Febe.Tests"); + var direct = new List(); + var outside = new List(); + foreach (var file in Directory.EnumerateFiles(tests, "*.cs", SearchOption.AllDirectories)) + { + var name = Path.GetRelativePath(tests, file).Replace('\\', '/'); + if (name.StartsWith("bin/", StringComparison.Ordinal) || name.StartsWith("obj/", StringComparison.Ordinal)) + { + continue; + } + + var text = File.ReadAllText(file); + if (name != "Support/SyntheticSite.cs" && DirectStart().IsMatch(text)) + { + direct.Add(name); + } + + if (SiteStart().IsMatch(text) && text.Contains("[TestClass]", StringComparison.Ordinal) + && !text.Contains("[TestCategory(SyntheticSite.Category)]", StringComparison.Ordinal)) + { + outside.Add(name); + } + } + + Assert.IsEmpty(direct, "The site starts through SyntheticSite.StartAsync, which reads FEBE_SEME_PROVA: " + string.Join(", ", direct)); + Assert.IsEmpty(outside, "The CI runs these tests again with the seed of the run only through their category: " + string.Join(", ", outside)); + } + + [TestMethod] + public void EverySeedGivesTheWorldTheIntegrationTestsRelyOn() + { + var now = new DateTimeOffset(2026, 10, 20, 9, 30, 0, TimeSpan.Zero); + int[] extremes = [SyntheticSite.Seed, int.MinValue, -1, 0, int.MaxValue]; + foreach (var seed in extremes.Concat(Enumerable.Range(1, 300)).Distinct()) + { + var world = World.Generate(seed, now); + var context = "seme " + seed.ToString(CultureInfo.InvariantCulture); + Assert.AreEqual(seed, world.Seed, context); + Assert.AreEqual("alberto.prova", world.Viewer.Username, context); + Assert.HasCount(31, world.Accounts, context); + Assert.HasCount(28, world.Following, context); + + var counts = new Dictionary + { + ["alberto.prova"] = 4, + ["marta.prova"] = 18, + ["luca.prova"] = 40, + ["giulia.prova"] = 6, + ["nadia.prova"] = 3, + ["paolo.prova"] = 8, + ["riservato.prova"] = 5, + }; + foreach (var (username, count) in counts) + { + Assert.HasCount(count, world.FindByUsername(username)!.Posts, $"{context}: {username}"); + } + + foreach (var account in world.Accounts) + { + if (account.Username.StartsWith("amico", StringComparison.Ordinal)) + { + Assert.IsTrue(account.Posts.Count is 1 or 2, $"{context}: {account.Username}"); + } + + // Newest first, strictly: «known content at the top» and the cursors rely on it. + for (var i = 1; i < account.Posts.Count; i++) + { + Assert.IsTrue(account.Posts[i - 1].PublishedAt > account.Posts[i].PublishedAt, $"{context}: {account.Username} #{i}"); + } + } + + var posts = world.Accounts.SelectMany(a => a.Posts).ToList(); + Assert.HasCount(posts.Count, posts.Select(p => p.Code).Distinct(StringComparer.Ordinal), $"{context}: codes are unique"); + Assert.HasCount(posts.Count, posts.Select(p => p.Id).Distinct(StringComparer.Ordinal), $"{context}: identifiers are unique"); + Assert.IsTrue(posts.All(p => p.Code.Length == 7 && p.PublishedAt <= now), context); + + var feed = world.Feed(); + for (var i = 1; i < feed.Count; i++) + { + Assert.IsTrue(feed[i - 1].PublishedAt >= feed[i].PublishedAt, $"{context}: feed #{i}"); + } + + CollectionAssert.AreEqual(StoryBarOrder, world.StoryBar(now).Select(a => a.Username).ToArray(), context); + var marta = world.FindByUsername("marta.prova")!; + var active = marta.Stories.Where(s => s.ExpiresAt > now).ToList(); + Assert.HasCount(4, active, context); + Assert.AreEqual(1, active.Count(s => s.File.IsVideo), context); + Assert.HasCount(3, world.FindByUsername("nadia.prova")!.Stories.Where(s => s.ExpiresAt > now), context); + Assert.HasCount(2, world.FindByUsername("luca.prova")!.Stories.Where(s => s.ExpiresAt > now), context); + Assert.HasCount(5, world.FindByUsername("giulia.prova")!.Stories.Where(s => s.ExpiresAt > now), context); + + var grid = world.Grid(marta, ProfileTab.Posts); + Assert.IsTrue(grid.Take(2).All(p => p.Pinned) && grid.Count(p => p.Pinned) == 2, $"{context}: two pinned posts on top"); + Assert.IsTrue(grid.Take(DataApi.GridPageSize).Any(p => p.Files.Count == 3), $"{context}: a series on the first page"); + Assert.HasCount(3, world.Grid(marta, ProfileTab.Tagged), context); + CollectionAssert.AreEqual(new[] { "Estate", "Viaggi" }, marta.Highlights.Select(h => h.Title).ToArray(), context); + Assert.IsTrue(marta.Highlights[0].Items.Any(i => i.Id == marta.Stories[1].Id), $"{context}: a story also in «Estate» (H9)"); + } + } + + [TestMethod] + [Timeout(60_000, CooperativeCancellation = true)] + public async Task TheReadersReadWhatTheSiteServesWithTheSeedOfThisRun() + { + await using var site = await SyntheticSite.StartAsync(); + TestContext.WriteLine($"Seme del mondo sintetico: {site.World.Seed.ToString(CultureInfo.InvariantCulture)}"); + Assert.AreEqual(SyntheticSite.Seed, site.World.Seed); + + string[] feed, firstFeedPageSeries, martaFirstPage, lucaGrid, martaStories, following; + string seriesCode, sharedStory, summerId; + lock (site.World.Gate) + { + var world = site.World; + var marta = world.FindByUsername("marta.prova")!; + feed = [.. world.Feed().Select(p => p.Id)]; + firstFeedPageSeries = [.. world.Feed().Take(DataApi.FeedPageSize).Where(p => p.Files.Count > 1).Select(p => p.Id)]; + martaFirstPage = [.. world.Grid(marta, ProfileTab.Posts).Take(DataApi.GridPageSize).Select(p => p.Id)]; + seriesCode = world.Grid(marta, ProfileTab.Posts).First(p => p.Files.Count == 3).Code; + lucaGrid = [.. world.Grid(world.FindByUsername("luca.prova")!, ProfileTab.Posts).Select(p => p.Id)]; + martaStories = [.. marta.Stories.Select(s => s.Id)]; + sharedStory = marta.Stories[1].Id; + summerId = marta.Highlights[0].Id; + following = [.. world.Following.Select(a => a.Username)]; + } + + // The home: the connected account, the stories bar, then the whole feed page by page, as the recipe scrolls it. + var home = await ReadAsync(site, "/dati/inizio"); + Assert.AreEqual(ReadShape.Recognized, home.Shape); + Assert.AreEqual("alberto.prova", home.Viewer?.Username); + CollectionAssert.AreEqual(StoryBarOrder, home.Profiles.Where(p => p.LatestStoryAt is not null).Select(p => p.Username).ToArray()); + CollectionAssert.AreEqual(firstFeedPageSeries, home.Contents.Where(c => !c.IsComplete).Select(c => c.Id).ToArray(), "A series arrives incomplete in the feed."); + Assert.IsTrue(home.Contents.Where(c => !c.IsComplete).All(c => c.Files.Count == 1)); + CollectionAssert.AreEqual(feed, await AllPagesAsync(site, home, "/dati/inizio/altri?dopo=")); + + // Marta's grid: two pinned posts on top, her highlights, her post count. + var profile = await ReadAsync(site, "/dati/profilo/marta.prova?scheda=post"); + CollectionAssert.AreEqual(martaFirstPage, profile.Contents.Select(c => c.Id).ToArray()); + Assert.IsTrue(profile.Contents.Take(2).All(c => c.Pinned) && profile.Contents.Count(c => c.Pinned) == 2); + CollectionAssert.AreEqual(new[] { "Estate", "Viaggi" }, profile.Highlights.Select(h => h.Title).ToArray()); + Assert.AreEqual(18, profile.Profiles.Single(p => p.PostCount is not null).PostCount); + + // Luca's history, page after page (the backfill): every post once, in order. + var luca = await ReadAsync(site, "/dati/profilo/luca.prova?scheda=post"); + CollectionAssert.AreEqual(lucaGrid, await AllPagesAsync(site, luca, "/dati/profilo/luca.prova/altri?scheda=post&dopo=")); + + // A series on its own page: complete, in order, a video in the middle. + var series = (await ReadAsync(site, "/dati/post/" + seriesCode)).Contents.Single(); + Assert.AreEqual(seriesCode, series.Code); + Assert.IsTrue(series.IsComplete); + CollectionAssert.AreEqual(new[] { MediaKind.Photo, MediaKind.Video, MediaKind.Photo }, series.Files.Select(f => f.Kind).ToArray()); + + // Stories and a highlight that shares one of them (H9). + var stories = await ReadAsync(site, "/dati/storie/marta.prova"); + CollectionAssert.AreEqual(martaStories, stories.Contents.Select(c => c.Id).ToArray()); + Assert.AreEqual(1, stories.Contents.Count(c => c.Files[0].Kind == MediaKind.Video)); + var summer = (await ReadAsync(site, "/dati/evidenza/" + summerId)).Highlights.Single(); + Assert.HasCount(3, summer.Items); + Assert.IsTrue(summer.Items.Any(i => i.Id == sharedStory)); + + // The following list, page after page, and a private profile Alberto does not follow. + var first = await ReadAsync(site, "/dati/seguiti"); + var names = first.Profiles.Select(p => p.Username).ToList(); + var page = first.Page; + while (page?.HasMore == true) + { + var next = await ReadAsync(site, "/dati/seguiti?dopo=" + Uri.EscapeDataString(page.Cursor!)); + names.AddRange(next.Profiles.Select(p => p.Username)); + page = next.Page; + } + + CollectionAssert.AreEqual(following, names); + var hidden = await ReadAsync(site, "/dati/profilo/riservato.prova?scheda=post"); + Assert.AreEqual(true, hidden.Profiles.Single().IsPrivate); + Assert.AreEqual(false, hidden.Profiles.Single().IsFollowed); + Assert.IsEmpty(hidden.Contents); + } + + private async Task ReadAsync(TestSite site, string pathAndQuery) + { + var result = Reader.Read(await site.GetDataAsync(pathAndQuery, TestContext.CancellationToken)); + Assert.AreEqual(ReadShape.Recognized, result.Shape, pathAndQuery); + return result; + } + + /// The identifiers of a first page and of every page after it, following the cursors. + private async Task AllPagesAsync(TestSite site, ReadResult first, string nextPath) + { + var ids = first.Contents.Select(c => c.Id).ToList(); + var page = first.Page; + while (page?.HasMore == true) + { + var next = await ReadAsync(site, nextPath + Uri.EscapeDataString(page.Cursor!)); + ids.AddRange(next.Contents.Select(c => c.Id)); + page = next.Page; + } + + return [.. ids]; + } + + [GeneratedRegex(@"\bTestSite\.StartAsync\(")] + private static partial Regex DirectStart(); + + [GeneratedRegex(@"\b(?:SyntheticSite\.StartAsync|CollectionHarness\.CreateAsync|ServerTestBed\.StartAsync)\(")] + private static partial Regex SiteStart(); +} diff --git a/tests/Febe.Tests/Server/ServerEndToEndTests.cs b/tests/Febe.Tests/Server/ServerEndToEndTests.cs index fb69719..392c58b 100644 --- a/tests/Febe.Tests/Server/ServerEndToEndTests.cs +++ b/tests/Febe.Tests/Server/ServerEndToEndTests.cs @@ -9,6 +9,7 @@ using Febe.Core.Storage; using Febe.SitoDiProva; using Febe.Tests.Alerts.Support; using Febe.Tests.Server.Support; +using Febe.Tests.Support; using Febe.Web.Connection; namespace Febe.Tests.Server; @@ -20,6 +21,7 @@ namespace Febe.Tests.Server; /// the remote view. Never Instagram: the browser only sees 127.0.0.1. /// [TestClass] +[TestCategory(SyntheticSite.Category)] [DoNotParallelize] public sealed partial class ServerEndToEndTests { diff --git a/tests/Febe.Tests/Server/Support/ServerTestBed.cs b/tests/Febe.Tests/Server/Support/ServerTestBed.cs index cf3a434..0174618 100644 --- a/tests/Febe.Tests/Server/Support/ServerTestBed.cs +++ b/tests/Febe.Tests/Server/Support/ServerTestBed.cs @@ -60,7 +60,7 @@ internal sealed class ServerTestBed : IAsyncDisposable public static async Task StartAsync(bool autoLogin = false, double factor = 10, HttpMessageHandler? telegram = null, IFreeSpaceProbe? freeSpace = null) { var temp = new TempFolder("server"); - var site = await TestSite.StartAsync(new TestSiteOptions()); + var site = await SyntheticSite.StartAsync(); var zone = NoonZone(); var clock = new CompressedClock(factor, zone); var options = new ServerOptions diff --git a/tests/Febe.Tests/Support/SyntheticSite.cs b/tests/Febe.Tests/Support/SyntheticSite.cs new file mode 100644 index 0000000..d984db7 --- /dev/null +++ b/tests/Febe.Tests/Support/SyntheticSite.cs @@ -0,0 +1,46 @@ +using System.Globalization; +using Febe.SitoDiProva; + +namespace Febe.Tests.Support; + +/// +/// The one way the tests start the local test site (spec §14.2), so that a run can choose the seed of its synthetic +/// world: when it is set, otherwise (nothing changes when it is unset). +/// The CI runs the whole suite with the default seed, then the tests of again with a seed of +/// its own that it prints in the log: a failure is reproduced by setting the same variable. +/// +internal static class SyntheticSite +{ + /// Environment variable with the seed of the synthetic world. + public const string Variable = "FEBE_SEME_PROVA"; + + /// The seed when the variable is not set: the one of the command-line site and of the cleaned samples. + public const int DefaultSeed = 13; + + /// Test category of the tests whose world comes from the seed (the CI runs them with a second seed). + public const string Category = "SitoDiProva"; + + /// The seed of this run. + public static int Seed => ParseSeed(Environment.GetEnvironmentVariable(Variable)); + + /// Starts the test site with the seed of this run, and says which one in the output of the test. + public static Task StartAsync() + { + var seed = Seed; + Console.WriteLine($"Sito di prova con il seme {seed.ToString(CultureInfo.InvariantCulture)} (si cambia con {Variable})."); + return TestSite.StartAsync(new TestSiteOptions { Seed = seed }); + } + + /// The seed written in : the default when it is empty, an error when it is not a number. + public static int ParseSeed(string? value) + { + if (string.IsNullOrWhiteSpace(value)) + { + return DefaultSeed; + } + + return int.TryParse(value.Trim(), NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out var seed) + ? seed + : throw new InvalidOperationException($"{Variable} deve essere un numero intero (fra -2147483648 e 2147483647), non «{value}»."); + } +} diff --git a/tools/Febe.SitoDiProva/LEGGIMI.md b/tools/Febe.SitoDiProva/LEGGIMI.md index c441d91..285ff27 100644 --- a/tools/Febe.SitoDiProva/LEGGIMI.md +++ b/tools/Febe.SitoDiProva/LEGGIMI.md @@ -15,7 +15,11 @@ dotnet run --project tools/Febe.SitoDiProva -- [--porta 8481] [--porta-cdn 8482] del sito non gli arrivano. - I dati sono **sintetici** e si generano da un seme: stesso seme, stessi account, post, codici e didascalie. Le date sono relative al momento dell'avvio (le storie sono attive per 24 ore da lì). -- Le prove automatiche lo avviano dentro il processo con `TestSite.StartAsync(...)` (porte libere scelte da sole). +- Le prove automatiche lo avviano dentro il processo con `SyntheticSite.StartAsync()` (`tests/Febe.Tests/Support`), che + chiama `TestSite.StartAsync(...)` con porte libere scelte da sole e il seme della variabile `FEBE_SEME_PROVA` (13 se + manca). La CI fa girare tutte le prove con il seme 13 e quelle della categoria `SitoDiProva` anche con un seme + diverso a ogni esecuzione, scritto nel registro; per rifare una prova fallita con quel seme: + `FEBE_SEME_PROVA= dotnet test tests/Febe.Tests --filter "TestCategory=SitoDiProva"`. - Campioni grezzi per le prove dei lettori: `dotnet run --project tools/Febe.SitoDiProva -- campioni --cartella ` (poi `febe-sonda ripulisci`, vedi `tests/Febe.Tests/campioni/prova/LEGGIMI.md`). -- 2.54.1 From d642b55b7473ec86ddbf376a7cbaa565df5367fd Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Tue, 20 Oct 2026 10:24:37 +0200 Subject: [PATCH 02/17] Dockerfile: file del restore trovati da soli e aggiornamenti di Debian applicati MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit L'elenco dei progetti scritto a mano rompeva la costruzione dell'immagine a ogni progetto nuovo in Febe.slnx (il prossimo è tests/Febe.Tests.Windows): ora uno stadio «progetti» copia soluzione, props e progetti trovati da soli, e il restore resta in cache finché non cambiano. Lo stadio finale applica gli aggiornamenti di sicurezza già pubblicati, che l'immagine di base non ha ancora, così la scansione dell'immagine non trova correzioni disponibili e non applicate. Co-Authored-By: Claude Opus 5.5 --- docker/Dockerfile | 33 ++++++++++++++++++++------------- docs/decisioni.md | 1 + 2 files changed, 21 insertions(+), 13 deletions(-) diff --git a/docker/Dockerfile b/docker/Dockerfile index 52f33d1..c416a2a 100644 --- a/docker/Dockerfile +++ b/docker/Dockerfile @@ -7,7 +7,10 @@ # -t 192.168.30.23:3000/alby96/febe:0.1.0 . # # Stadi: -# build restore e compilazione di tutta la soluzione con gli avvisi come errori; +# progetti solo i file che il restore legge (soluzione, props, progetti), trovati da soli: un progetto nuovo in +# Febe.slnx non chiede di cambiare questo file; +# build restore (in cache finché quei file non cambiano) e compilazione di tutta la soluzione con gli avvisi come +# errori; # test tutte le prove: un'immagine con prove rosse non esiste. Qui non ci sono Chromium né Xvfb, quindi le prove # con il browser vero risultano «inconcludenti» (saltate) e girano solo dove ci sono (CI, sviluppo); # publish Febe.Server autosufficiente per linux-x64: nell'immagine non serve il runtime .NET; @@ -18,24 +21,25 @@ ARG DOTNET_VERSION=10.0 +# ─────────────────────────────────────────────────────────────── progetti +# I file che il restore legge, ciascuno nella sua cartella. Questo stadio rigira a ogni modifica, ma il suo risultato +# cambia solo con loro: la copia nello stadio build, e quindi il restore, restano in cache (BuildKit confronta il +# contenuto). Un progetto aggiunto a Febe.slnx (per esempio tests/Febe.Tests.Windows) arriva qui senza toccare il file. +FROM mcr.microsoft.com/dotnet/sdk:${DOTNET_VERSION} AS progetti +WORKDIR /src +COPY . . +RUN mkdir -p /progetti \ + && find . -type f \( -name '*.slnx' -o -name '*.csproj' -o -name 'Directory.*.props' -o -name 'Directory.*.targets' \ + -o -iname 'nuget.config' -o -name 'global.json' \) -exec cp --parents '{}' /progetti/ ';' \ + && test -f /progetti/Febe.slnx + # ─────────────────────────────────────────────────────────────── build FROM mcr.microsoft.com/dotnet/sdk:${DOTNET_VERSION} AS build WORKDIR /src ENV DOTNET_NOLOGO=1 DOTNET_CLI_TELEMETRY_OPTOUT=1 # Prima i file di progetto: il restore resta in cache finché non cambiano. -COPY Directory.Build.props Directory.Packages.props Febe.slnx ./ -COPY src/Febe.Core/Febe.Core.csproj src/Febe.Core/ -COPY src/Febe.Data/Febe.Data.csproj src/Febe.Data/ -COPY src/Febe.Browser/Febe.Browser.csproj src/Febe.Browser/ -COPY src/Febe.Web/Febe.Web.csproj src/Febe.Web/ -COPY src/Febe.App/Febe.App.csproj src/Febe.App/ -COPY src/Febe.Server/Febe.Server.csproj src/Febe.Server/ -COPY src/Febe.Desktop.Core/Febe.Desktop.Core.csproj src/Febe.Desktop.Core/ -COPY src/Febe.Desktop/Febe.Desktop.csproj src/Febe.Desktop/ -COPY tests/Febe.Tests/Febe.Tests.csproj tests/Febe.Tests/ -COPY tools/Febe.Sonda/Febe.Sonda.csproj tools/Febe.Sonda/ -COPY tools/Febe.SitoDiProva/Febe.SitoDiProva.csproj tools/Febe.SitoDiProva/ +COPY --from=progetti /progetti/ ./ RUN dotnet restore Febe.slnx \ && dotnet restore src/Febe.Server/Febe.Server.csproj -r linux-x64 @@ -73,8 +77,11 @@ LABEL org.opencontainers.image.title="Febe" \ # Chromium della distribuzione con le sue lingue, il display virtuale, ffmpeg (miniature dei video importati), ICU e # le librerie del runtime .NET autosufficiente, caratteri di sistema con le emoji, certificati, fusi orari, la lingua # italiana generata, tini come processo 1 (raccoglie i processi di Chromium), setpriv (util-linux) per PUID/PGID. +# Prima gli aggiornamenti di sicurezza della distribuzione già pubblicati, anche quelli arrivati dopo l'immagine di +# base: la scansione della CI non deve trovare correzioni disponibili e non applicate. ENV DEBIAN_FRONTEND=noninteractive RUN apt-get update \ + && apt-get upgrade -y --no-install-recommends \ && apt-get install -y --no-install-recommends \ chromium chromium-l10n \ xvfb \ diff --git a/docs/decisioni.md b/docs/decisioni.md index 5d83e70..cd1a3c2 100644 --- a/docs/decisioni.md +++ b/docs/decisioni.md @@ -227,3 +227,4 @@ Ogni scelta tecnica presa strada facendo, con data e motivo (specifica §15). | 2026-10-14 | Revisione avversaria di tutto il codice (7 aree, ogni rilievo verificato da un secondo revisore indipendente): 54 rilievi confermati e corretti con prove di regressione, 2 smentiti, 3 incerti corretti dove il rimedio era sicuro | §14, regola 14: resoconti onesti | | 2026-10-14 | Restano noti e accettati: «Tieni il più grande» scrive con il proprio SafeFileWriter e non passa dal lucchetto per account di `LibraryIngest` (un'importazione e uno scaricamento con gli stessi byte nello stesso istante potrebbero entrare entrambi); le prove d'interfaccia con browser vero aspettano fino a 30 s | Finestra rarissima, nessuna perdita di dati: al più un doppione esatto da togliere a mano | | 2026-10-20 | Il seme del mondo sintetico del sito di prova si sceglie con la variabile `FEBE_SEME_PROVA` (13 se manca), letta da `SyntheticSite` (`tests/Febe.Tests/Support`), l'unico modo in cui le prove avviano il sito; le classi che lo avviano stanno nella categoria `SitoDiProva`, e una prova controlla che nessuna lo avvii per altre vie o resti fuori dalla categoria. `SyntheticSiteSeedTests` controlla senza browser, per 300 semi, la forma del mondo su cui contano le prove d'insieme e i lettori sulle pagine servite | La CI rifà quelle prove con un seme diverso a ogni esecuzione, scritto nel registro, senza raddoppiare la durata di tutta la suite; senza la variabile non cambia nulla; un errore si rifà con lo stesso seme | +| 2026-10-20 | Dockerfile: i file che il restore legge (soluzione, `Directory.*.props`, progetti) si trovano da soli in uno stadio `progetti` invece che da un elenco scritto a mano; lo stadio finale applica gli aggiornamenti della distribuzione (`apt-get upgrade`) prima di installare i pacchetti | Un progetto nuovo in `Febe.slnx` (come `tests/Febe.Tests.Windows`) non rompe più la costruzione dell'immagine e il restore resta in cache (BuildKit confronta il contenuto copiato); la scansione Trivy della CI non deve trovare correzioni di Debian già pubblicate ma non applicate perché l'immagine di base è più vecchia | -- 2.54.1 From 91080a2664a42a5b773003b11cdb74af80a392df Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Tue, 20 Oct 2026 10:51:19 +0200 Subject: [PATCH 03/17] CI: script comuni per strumenti verificati, prove, immagine e pulizia MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Gli script di .gitea/scripts servono sia alla verifica sia al rilascio e si lanciano anche a mano. gitleaks e Trivy si installano a versione fissa e solo se l'impronta SHA-256 coincide; la scansione dell'immagine ferma il lavoro per una CRITICAL con correzione e riporta le HIGH; la prova del contenitore gira sempre senza rete, così l'immagine non può raggiungere nessun sito; la costruzione usa sempre gli stessi argomenti, perché quella pubblicata esca dalla cache di quella provata. La pulizia tocca solo ciò che porta i segni della CI di Febe (etichette febe.ci.*, febe-ci:, builder febe-ci-) e le immagini senza nome più vecchie di tre giorni: il demone è condiviso con gli altri progetti. Il riepilogo delle prove conta superate, fallite e saltate e fallisce se una prova si salta dove non dovrebbe. Co-Authored-By: Claude Opus 5.5 --- .gitea/scripts/ambiente-prove.sh | 36 +++++++ .gitea/scripts/controlli.sh | 89 ++++++++++++++++ .gitea/scripts/costruisci-immagine.sh | 46 +++++++++ .gitea/scripts/prova-immagine.sh | 76 ++++++++++++++ .gitea/scripts/pulizia-docker.sh | 142 ++++++++++++++++++++++++++ .gitea/scripts/riepilogo-prove.sh | 106 +++++++++++++++++++ .gitea/scripts/scansione-immagine.sh | 54 ++++++++++ .gitea/scripts/segreti.sh | 47 +++++++++ .gitea/scripts/strumento.sh | 60 +++++++++++ docs/decisioni.md | 6 ++ 10 files changed, 662 insertions(+) create mode 100755 .gitea/scripts/ambiente-prove.sh create mode 100755 .gitea/scripts/controlli.sh create mode 100755 .gitea/scripts/costruisci-immagine.sh create mode 100755 .gitea/scripts/prova-immagine.sh create mode 100755 .gitea/scripts/pulizia-docker.sh create mode 100755 .gitea/scripts/riepilogo-prove.sh create mode 100755 .gitea/scripts/scansione-immagine.sh create mode 100755 .gitea/scripts/segreti.sh create mode 100755 .gitea/scripts/strumento.sh diff --git a/.gitea/scripts/ambiente-prove.sh b/.gitea/scripts/ambiente-prove.sh new file mode 100755 index 0000000..ece19fc --- /dev/null +++ b/.gitea/scripts/ambiente-prove.sh @@ -0,0 +1,36 @@ +#!/usr/bin/env bash +# Prepara il contenitore Debian del lavoro «prove» (node:24-trixie: Debian 13 con Node, che serve alle azioni) perché +# nessuna prova si salti: Chromium vero della distribuzione (su Ubuntu è uno snap, che nei contenitori non va) con le +# sue lingue, Xvfb, ffmpeg e ffprobe, makensis (NSIS) e zip, la lingua it_IT.UTF-8, fusi orari, ICU e gli stessi +# caratteri dell'immagine di Febe. Node c'è già (prova della pagina di accesso); setpriv, getent e l'utente nobody +# (65534) vengono con Debian (prove dell'avvio del contenitore). +# +# .gitea/scripts/ambiente-prove.sh +set -euo pipefail + +sudo="" +[[ "$(id -u)" == 0 ]] || sudo="sudo" +export DEBIAN_FRONTEND=noninteractive + +$sudo apt-get update -qq +$sudo apt-get install -y -qq --no-install-recommends \ + chromium chromium-l10n \ + xvfb \ + ffmpeg \ + nsis zip \ + locales tzdata libicu76 ca-certificates \ + fonts-noto-color-emoji fonts-liberation fonts-dejavu-core \ + util-linux procps > /dev/null +$sudo sed -i 's/^# *\(it_IT.UTF-8 UTF-8\)/\1/' /etc/locale.gen +$sudo locale-gen > /dev/null + +echo "== Strumenti delle prove" +chromium --version +command -v Xvfb +ffmpeg -version | head -n 1 || true +ffprobe -version | head -n 1 || true +echo "makensis $(makensis -VERSION)" +echo "node $(node --version)" +locale -a | grep -i '^it_IT\.utf8$' +for strumento in setpriv getent stat chown sh; do command -v "$strumento" > /dev/null || { echo "Manca $strumento." >&2; exit 1; }; done +getent passwd 65534 > /dev/null && getent group 65534 > /dev/null || { echo "Mancano l'utente o il gruppo 65534 (nobody)." >&2; exit 1; } diff --git a/.gitea/scripts/controlli.sh b/.gitea/scripts/controlli.sh new file mode 100755 index 0000000..47c6c7f --- /dev/null +++ b/.gitea/scripts/controlli.sh @@ -0,0 +1,89 @@ +#!/usr/bin/env bash +# Controlli veloci prima di compilare (lavoro «controlli» della CI): pochi secondi, e fermano subito gli errori che +# altrimenti si scoprirebbero dopo mezz'ora di prove. Si lanciano anche a mano, dalla radice del repository: +# +# bash .gitea/scripts/controlli.sh +# +# 1. ogni script di shell del repository è sintassi valida (bash -n; sh -n per quelli in sh) e ha le righe Unix; +# 2. i flussi della CI non hanno tabulazioni (YAML non le accetta come rientro); +# 3. nessun file contiene segni di conflitto rimasti da un'unione; +# 4. la versione di Directory.Build.props è nella forma x.y.z[-qualcosa], quella che installer/costruisci.sh accetta; +# 5. ogni progetto elencato in Febe.slnx esiste; +# 6. ogni file JSON del repository si legge (configurazioni, campioni ripuliti, criteri di Chromium). +set -uo pipefail + +radice="$(git rev-parse --show-toplevel)" || exit 2 +cd "$radice" || exit 2 +errori=0 + +errore() { + echo "ERRORE: $*" >&2 + errori=$((errori + 1)) +} + +echo "== Script di shell" +quanti=0 +while IFS= read -r -d '' script; do + quanti=$((quanti + 1)) + bash -n "$script" || errore "$script: sintassi bash non valida." + if head -n 1 "$script" | grep -Eq '^#!(/usr/bin/env )?/?(bin/)?sh( |$)'; then + sh -n "$script" || errore "$script: sintassi sh non valida." + fi + if grep -q $'\r' "$script"; then + errore "$script ha righe Windows (CR): bash non le regge (.gitattributes chiede eol=lf)." + fi +done < <(git ls-files -z -- '*.sh') +echo " $quanti script controllati" + +echo "== Flussi della CI" +while IFS= read -r -d '' flusso; do + if grep -n $'\t' "$flusso" > /dev/null; then + errore "$flusso contiene tabulazioni: in YAML il rientro si fa con gli spazi." + fi +done < <(git ls-files -z -- '.gitea/workflows/*.yml' '.gitea/workflows/*.yaml') + +echo "== Segni di conflitto" +if conflitti=$(git grep -n -I -E '^(<{7}|>{7})( |$)' -- . ':!*.png' ':!*.jpg'); then + errore "segni di conflitto rimasti:" + echo "$conflitti" >&2 +fi + +echo "== Versione" +versione=$(sed -n 's:.*\(.*\).*:\1:p' Directory.Build.props) +if [[ "$(printf '%s\n' "$versione" | grep -c .)" != "1" ]]; then + errore "Directory.Build.props deve avere una sola ." +elif [[ ! "$versione" =~ ^[0-9]+\.[0-9]+\.[0-9]+([-+][0-9A-Za-z.-]+)?$ ]]; then + errore "versione «$versione» non valida: serve x.y.z, eventualmente con -qualcosa." +else + echo " $versione" +fi + +echo "== Progetti della soluzione" +while IFS= read -r progetto; do + [[ -f "$progetto" ]] || errore "Febe.slnx elenca $progetto, che non esiste." +done < <(sed -n 's:.*&2 + fi +else + errore "manca node: i file JSON non si possono controllare." +fi + +if ((errori > 0)); then + echo "Controlli falliti: $errori." >&2 + exit 1 +fi +echo "Controlli superati." diff --git a/.gitea/scripts/costruisci-immagine.sh b/.gitea/scripts/costruisci-immagine.sh new file mode 100755 index 0000000..5e58b96 --- /dev/null +++ b/.gitea/scripts/costruisci-immagine.sh @@ -0,0 +1,46 @@ +#!/usr/bin/env bash +# Costruzione dell'immagine Docker di Febe con il builder buildx dell'esecuzione (docker-container), sempre con gli +# stessi argomenti e le stesse etichette: la costruzione che si pubblica esce intera dalla cache di quella che si è +# provata e scansionata, quindi gli strati sono gli stessi. +# +# costruisci-immagine.sh archivio archivio dell'immagine, per docker load e per Trivy +# costruisci-immagine.sh pubblica ... spinta sul registro da buildx: le credenziali sono +# già nella configurazione del client, il demone non +# parla mai con il registro (proverebbe HTTPS) +# +# Variabili richieste: BUILDER, VERSIONE, GIT_COMMIT, FLUSSO (verifica o rilascio), ESECUZIONE (gitea.run_id). +# Le etichette febe.ci.* dicono quale flusso, esecuzione, ramo e commit hanno costruito l'immagine; la pulizia +# (pulizia-docker.sh) riconosce da lì ciò che è della CI di Febe. +set -euo pipefail + +modo="${1:?Indica il modo: archivio o pubblica.}" +shift +cd "$(git rev-parse --show-toplevel)" + +comuni=(--builder "${BUILDER:?}" -f docker/Dockerfile + --build-arg "VERSION=${VERSIONE:?}" --build-arg "GIT_COMMIT=${GIT_COMMIT:?}" + --label "febe.ci.workflow=${FLUSSO:?}" --label "febe.ci.run=${ESECUZIONE:?}" + --label "febe.ci.ref=${GITHUB_REF_NAME:-}" --label "febe.ci.commit=${GITHUB_SHA:-}") + +case "$modo" in + archivio) + archivio="${1:?Indica il file .tar da scrivere.}" + nome="${2:?Indica il nome locale, per esempio febe-ci:123.}" + mkdir -p "$(dirname "$archivio")" + docker buildx build "${comuni[@]}" --output "type=docker,name=$nome,dest=$archivio" . + echo "Archivio dell'immagine: $archivio ($(du -h "$archivio" | cut -f1))" + ;; + pubblica) + (($# > 0)) || { echo "Indica almeno un nome:etichetta da pubblicare." >&2; exit 2; } + etichette=() + for nome in "$@"; do + etichette+=(-t "$nome") + done + docker buildx build "${comuni[@]}" "${etichette[@]}" --push . + printf 'Pubblicata: %s\n' "$@" + ;; + *) + echo "Modo sconosciuto: «$modo» (archivio o pubblica)." >&2 + exit 2 + ;; +esac diff --git a/.gitea/scripts/prova-immagine.sh b/.gitea/scripts/prova-immagine.sh new file mode 100755 index 0000000..426fc75 --- /dev/null +++ b/.gitea/scripts/prova-immagine.sh @@ -0,0 +1,76 @@ +#!/usr/bin/env bash +# Prova dell'immagine appena costruita, sul demone Docker del runner. Ogni contenitore gira SENZA RETE +# (--network none): Febe non può raggiungere alcun sito, tanto meno Instagram (regola 1), e il controllo di salute +# passa dalla rete interna del contenitore. Ogni contenitore porta l'etichetta febe.ci.run dell'esecuzione: se il +# lavoro si interrompe, lo toglie pulizia-docker.sh. +# +# .gitea/scripts/prova-immagine.sh [esecuzione] +# +# 1. Chromium della distribuzione risponde e i criteri di Febe (niente password salvate) sono al loro posto; +# 2. la lingua it_IT.UTF-8 è generata; +# 3. il contenitore parte come dice la guida (profilo seccomp di Febe, password dell'interfaccia, PUID/PGID +# predefiniti), il controllo di salute dell'immagine diventa «healthy» e «febe --controllo-salute» risponde; +# 4. allo stop si ferma da solo, entro i 30 secondi che la guida concede. +# La password è casuale, vive solo nell'ambiente del client Docker e non si stampa mai. +set -euo pipefail + +immagine="${1:?Indica quale immagine provare.}" +esecuzione="${2:-${ESECUZIONE:-locale}}" +radice="$(git rev-parse --show-toplevel)" +etichette=(--label "febe.ci.workflow=${FLUSSO:-prova}" --label "febe.ci.run=$esecuzione") +nome="febe-prova-$esecuzione" + +togli() { docker rm -f -v "$nome" > /dev/null 2>&1 || true; } +trap togli EXIT +togli + +echo "== Chromium e criteri di Febe" +docker run --rm --network none "${etichette[@]}" --entrypoint /usr/bin/chromium "$immagine" --version +docker run --rm --network none "${etichette[@]}" --entrypoint sh "$immagine" -c \ + 'test -s /etc/chromium/policies/managed/febe.json && test -s /usr/share/febe/seccomp.json && echo "criteri di Chromium e profilo seccomp presenti"' + +echo "== Lingua italiana" +docker run --rm --network none "${etichette[@]}" --entrypoint sh "$immagine" -c 'locale -a | grep -i "^it_IT\.utf8$"' + +echo "== Avvio, salute e arresto" +FEBE_PASSWORD="$(head -c 32 /dev/urandom | base64 | tr -dc 'A-Za-z0-9')" +export FEBE_PASSWORD +docker run -d --name "$nome" --network none "${etichette[@]}" \ + --security-opt "seccomp=$radice/docker/chromium/seccomp.json" \ + --stop-timeout 30 -e FEBE_PASSWORD "$immagine" > /dev/null +unset FEBE_PASSWORD + +# Il primo controllo di salute dell'immagine arriva 30 secondi dopo l'avvio (HEALTHCHECK --interval=30s): fino a 3 minuti. +stato="" +for _ in $(seq 1 36); do + if [[ "$(docker inspect -f '{{.State.Running}}' "$nome")" != "true" ]]; then + echo "Il contenitore si è fermato da solo (codice $(docker inspect -f '{{.State.ExitCode}}' "$nome")). Registro:" >&2 + docker logs --tail 80 "$nome" >&2 || true + exit 1 + fi + stato="$(docker inspect -f '{{if .State.Health}}{{.State.Health.Status}}{{end}}' "$nome")" + [[ "$stato" == "healthy" || "$stato" == "unhealthy" ]] && break + sleep 5 +done +if [[ "$stato" != "healthy" ]]; then + echo "Il controllo di salute dice «${stato:-niente}» invece di «healthy». Registro:" >&2 + docker logs --tail 80 "$nome" >&2 || true + exit 1 +fi +if ! docker exec "$nome" /app/febe --controllo-salute > /dev/null; then + echo "febe --controllo-salute non risponde «ok» dentro il contenitore. Registro:" >&2 + docker logs --tail 80 "$nome" >&2 || true + exit 1 +fi +echo "salute: healthy, e febe --controllo-salute risponde" + +inizio=$(date +%s) +docker stop -t 30 "$nome" > /dev/null +durata=$(($(date +%s) - inizio)) +codice="$(docker inspect -f '{{.State.ExitCode}}' "$nome")" +echo "arresto in ${durata} s (codice di uscita $codice)" +if ((durata >= 30)); then + echo "Febe non si è fermato da solo entro 30 secondi: Docker l'ha dovuto uccidere. Registro:" >&2 + docker logs --tail 80 "$nome" >&2 || true + exit 1 +fi diff --git a/.gitea/scripts/pulizia-docker.sh b/.gitea/scripts/pulizia-docker.sh new file mode 100755 index 0000000..dff35b0 --- /dev/null +++ b/.gitea/scripts/pulizia-docker.sh @@ -0,0 +1,142 @@ +#!/usr/bin/env bash +# Pulizia di ciò che la CI di Febe lascia sul demone Docker del runner. È lo stesso demone che costruisce Encelado, +# Mimante e gli altri progetti di Alberto: si tocca solo ciò che porta i segni della CI di Febe, più le immagini senza +# nome («dangling») più vecchie di tre giorni. Mai altro, e mai la cache di costruzione del demone (è condivisa). +# +# I segni della CI di Febe: +# - contenitori con l'etichetta febe.ci.run (le prove dell'immagine, fatte con --label); +# - immagini del repository locale «febe-ci» (le immagini provate; mai quelle col nome del registro) con la stessa +# etichetta, o senza nome ma con quell'etichetta; +# - builder buildx di nome febe-ci-: il contenitore buildx_buildkit_febe-ci-0 e il suo volume +# …_state, che contengono la cache di costruzione di quell'esecuzione; +# - l'immagine febe:ci lasciata dal vecchio flusso di verifica (prima del 20 ottobre 2026), se nessuno la usa. +# +# pulizia-docker.sh esecuzione tutto ciò che ha creato l'esecuzione (alla fine del lavoro, sempre) +# pulizia-docker.sh residui [minuti] i resti di esecuzioni interrotte, più vecchi di N minuti (predefinito 90: un +# lavoro dura al massimo 60 minuti, quindi nessuno di essi è ancora vivo) +# pulizia-docker.sh settimanale residui, febe:ci, immagini senza nome più vecchie di 72 ore (flusso «pulizia») +# +# Un oggetto già sparito non è un errore: la pulizia si può ripetere. Nei modi «esecuzione» e «residui» un errore +# diventa un avviso (un lavoro verde non diventa rosso per la pulizia, che il flusso settimanale ripete); nel modo +# «settimanale» fa fallire il lavoro. +set -uo pipefail + +modo="${1:-}" +problemi=0 + +avviso() { + echo "::warning::$*" + problemi=$((problemi + 1)) +} + +# Minuti trascorsi da un istante RFC 3339 (il campo Created di docker inspect). Se non si legge, 0: nel dubbio +# l'oggetto è giovane e resta. +eta_minuti() { + local creato="${1%%.*}" + creato="${creato%Z}" + local secondi + secondi=$(date -u -d "${creato}Z" +%s 2>/dev/null) || { echo 0; return; } + echo $((($(date -u +%s) - secondi) / 60)) +} + +togli_contenitore() { + local id="$1" nome + nome=$(docker inspect -f '{{.Name}}' "$id" 2>/dev/null) || return 0 + if docker rm -f -v "$id" > /dev/null 2>&1; then + echo " contenitore ${nome#/} tolto" + else + avviso "Non riesco a togliere il contenitore ${nome#/}." + fi +} + +togli_immagine() { + local id="$1" nomi + nomi=$(docker image inspect -f '{{join .RepoTags ", "}}' "$id" 2>/dev/null) || return 0 + if docker image rm -f "$id" > /dev/null 2>&1; then + echo " immagine ${nomi:-$id} tolta" + else + avviso "Non riesco a togliere l'immagine ${nomi:-$id}." + fi +} + +# Un builder buildx della CI: prima con buildx (se questo client lo conosce), poi contenitore e volume per nome, perché +# un lavoro diverso da quello che l'ha creato non ne ha la configurazione. +togli_builder() { + local builder="$1" + [[ "$builder" =~ ^febe-ci-[0-9]+$ ]] || { avviso "Nome di builder inatteso: «$builder»."; return 0; } + docker buildx rm -f "$builder" > /dev/null 2>&1 && echo " builder $builder tolto" + local contenitore="buildx_buildkit_${builder}0" + if docker inspect "$contenitore" > /dev/null 2>&1; then + togli_contenitore "$contenitore" + fi + if docker volume inspect "${contenitore}_state" > /dev/null 2>&1; then + if docker volume rm -f "${contenitore}_state" > /dev/null 2>&1; then + echo " volume ${contenitore}_state tolto" + else + avviso "Non riesco a togliere il volume ${contenitore}_state." + fi + fi +} + +esecuzione() { + local run="${1:-}" + [[ "$run" =~ ^[0-9]+$ ]] || { echo "Indica il numero dell'esecuzione (gitea.run_id), non «$run»." >&2; exit 2; } + echo "== Pulizia dell'esecuzione $run" + local id + for id in $(docker ps -a -q --filter "label=febe.ci.run=$run"); do togli_contenitore "$id"; done + for id in $(docker image ls -q --no-trunc --filter "label=febe.ci.run=$run" | sort -u); do togli_immagine "$id"; done + togli_builder "febe-ci-$run" +} + +residui() { + local minuti="${1:-90}" + [[ "$minuti" =~ ^[0-9]+$ ]] || { echo "I minuti devono essere un numero, non «$minuti»." >&2; exit 2; } + echo "== Resti di esecuzioni interrotte, più vecchi di $minuti minuti" + local id nome + for id in $(docker ps -a -q --filter "label=febe.ci.run"); do + (($(eta_minuti "$(docker inspect -f '{{.Created}}' "$id" 2>/dev/null)") >= minuti)) && togli_contenitore "$id" + done + for id in $( { docker image ls -q --no-trunc --filter "reference=febe-ci" --filter "label=febe.ci.run" + docker image ls -q --no-trunc --filter "dangling=true" --filter "label=febe.ci.run"; } | sort -u); do + (($(eta_minuti "$(docker image inspect -f '{{.Created}}' "$id" 2>/dev/null)") >= minuti)) && togli_immagine "$id" + done + # Il filtro per nome di Docker cerca una parte del nome: il nome esatto si controlla qui. + while read -r id nome; do + [[ -n "${id:-}" ]] || continue + nome="${nome#/}" + [[ "$nome" =~ ^buildx_buildkit_(febe-ci-[0-9]+)0$ ]] || continue + (($(eta_minuti "$(docker inspect -f '{{.Created}}' "$id" 2>/dev/null)") >= minuti)) && togli_builder "${BASH_REMATCH[1]}" + done < <(docker ps -a --no-trunc --filter "name=buildx_buildkit_febe-ci-" --format '{{.ID}} {{.Names}}') +} + +settimanale() { + residui 90 + echo "== Immagine febe:ci del vecchio flusso di verifica" + if docker image inspect febe:ci > /dev/null 2>&1; then + # Senza -f: se un contenitore la usa resta dov'è. + docker image rm febe:ci > /dev/null 2>&1 && echo " febe:ci tolta" || echo " febe:ci è in uso: resta" + fi + echo "== Immagini senza nome più vecchie di 72 ore" + docker image prune -f --filter "until=72h" || avviso "La pulizia delle immagini senza nome non è riuscita." +} + +command -v docker > /dev/null || { echo "Manca il client Docker: niente da pulire." >&2; exit 2; } +case "$modo" in + esecuzione) esecuzione "${2:-}" ;; + residui) residui "${2:-90}" ;; + settimanale) + docker system df || true + settimanale + docker system df || true + ;; + *) + echo "Uso: $0 esecuzione | residui [minuti] | settimanale" >&2 + exit 2 + ;; +esac + +if ((problemi > 0)); then + echo "Pulizia finita con $problemi avvisi." + [[ "$modo" == settimanale ]] && exit 1 +fi +exit 0 diff --git a/.gitea/scripts/riepilogo-prove.sh b/.gitea/scripts/riepilogo-prove.sh new file mode 100755 index 0000000..a5ab3bd --- /dev/null +++ b/.gitea/scripts/riepilogo-prove.sh @@ -0,0 +1,106 @@ +#!/usr/bin/env bash +# Riepilogo dei risultati delle prove (file .trx di «dotnet test --logger trx»): superate, fallite e saltate per ogni +# file, i nomi delle fallite e i motivi delle saltate. Lo scrive nel registro e, se il runner lo offre, nel riepilogo +# del lavoro (GITHUB_STEP_SUMMARY). Nessun corpo di risposta né dato personale: solo nomi di prove e messaggi. +# +# .gitea/scripts/riepilogo-prove.sh [saltate ammesse] +# +# Esce con 1 se una prova è fallita, se le saltate sono più di quelle ammesse (predefinito 0: nella CI ci sono +# Chromium, Xvfb, ffmpeg, NSIS e Node, quindi nessuna prova ha motivo di saltarsi) o se non c'è nessun risultato. +set -euo pipefail + +cartella="${1:?Indica la cartella con i file .trx.}" +ammesse="${2:-${PROVE_SALTATE_AMMESSE:-0}}" +[[ "$ammesse" =~ ^[0-9]+$ ]] || { echo "Il numero di prove saltate ammesse deve essere un intero, non «$ammesse»." >&2; exit 2; } + +shopt -s nullglob +file=("$cartella"/*.trx) +if (( ${#file[@]} == 0 )); then + echo "Nessun risultato delle prove in $cartella: le prove non sono partite." >&2 + exit 1 +fi + +riepilogo="$(mktemp)" +trap 'rm -f "$riepilogo"' EXIT + +fallite_totali=0 +saltate_totali=0 +{ + echo "### Prove" + echo + echo "| Risultati | Totale | Superate | Fallite | Saltate |" + echo "|---|---:|---:|---:|---:|" +} > "$riepilogo" + +for trx in "${file[@]}"; do + nome="$(basename "$trx")" + # Un risultato per riga (i .trx sono XML su più righe), poi nome, esito e primo messaggio di ciascuno. + righe="$(tr '\r\n' ' ' < "$trx" | sed 's/", s); gsub(/&/, "\\&", s); gsub(/[ \t]+/, " ", s) + return s + } + /^.*/, "", testata) + messaggio = "" + if (match($0, /[^<]*<\/Message>/)) { + messaggio = substr($0, RSTART + 9, RLENGTH - 19) + } + printf "%s\t%s\t%s\n", attributo(testata, "outcome"), testo_xml(attributo(testata, "testName")), testo_xml(messaggio) + }')" + + totale=0; superate=0; fallite=0; saltate=0 + if [[ -n "$righe" ]]; then + totale=$(printf '%s\n' "$righe" | wc -l) + superate=$(printf '%s\n' "$righe" | awk -F'\t' '$1 == "Passed"' | wc -l) + fallite=$(printf '%s\n' "$righe" | awk -F'\t' '$1 == "Failed" || $1 == "Error" || $1 == "Timeout" || $1 == "Aborted"' | wc -l) + fi + saltate=$((totale - superate - fallite)) + fallite_totali=$((fallite_totali + fallite)) + saltate_totali=$((saltate_totali + saltate)) + + echo "== $nome: totale $totale · superate $superate · fallite $fallite · saltate $saltate" + echo "| \`$nome\` | $totale | $superate | $fallite | $saltate |" >> "$riepilogo" + + if (( fallite > 0 )); then + echo " Fallite:" + # Le righe in più si leggono e si scartano (niente «head»: con pipefail il SIGPIPE fermerebbe lo script). + printf '%s\n' "$righe" | awk -F'\t' '$1 == "Failed" || $1 == "Error" || $1 == "Timeout" || $1 == "Aborted" { + if (++n > 50) next; m = $3; if (length(m) > 300) m = substr(m, 1, 300) "…"; print " - " $2 ": " m }' + fi + + if (( saltate > 0 )); then + echo " Saltate, per motivo:" + # Il motivo senza la cornice di MSTest («Il metodo … ha generato un'eccezione. Assert.Inconclusive.»). + printf '%s\n' "$righe" | awk -F'\t' '$1 != "Passed" && $1 != "Failed" && $1 != "Error" && $1 != "Timeout" && $1 != "Aborted" { + m = $3; sub(/^.*Assert\.Inconclusive\. */, "", m); if (m == "") m = "(nessun motivo)"; print m }' \ + | sort | uniq -c | sort -rn | awk 'NR <= 30 { sub(/^ */, " "); print }' + fi +done + +esito=0 +{ + echo + echo "Fallite: $fallite_totali · saltate: $saltate_totali (ammesse: $ammesse)." +} >> "$riepilogo" +if (( fallite_totali > 0 )); then + echo "Prove fallite: $fallite_totali (i file .trx sono fra gli artefatti dell'esecuzione)." >&2 + esito=1 +fi +if (( saltate_totali > ammesse )); then + echo "Prove saltate: $saltate_totali, più delle $ammesse ammesse. Qui ci sono Chromium, Xvfb, ffmpeg, NSIS e Node: una prova che si salta segnala un ambiente rotto, non una prova superata." >&2 + esito=1 +fi + +if [[ -n "${GITHUB_STEP_SUMMARY:-}" ]]; then + cat "$riepilogo" >> "$GITHUB_STEP_SUMMARY" || true +fi +exit "$esito" diff --git a/.gitea/scripts/scansione-immagine.sh b/.gitea/scripts/scansione-immagine.sh new file mode 100755 index 0000000..43d37c8 --- /dev/null +++ b/.gitea/scripts/scansione-immagine.sh @@ -0,0 +1,54 @@ +#!/usr/bin/env bash +# Scansione delle vulnerabilità dell'immagine Docker con Trivy, a versione fissa (strumento.sh), sull'archivio prodotto +# dalla costruzione (docker save o buildx --output type=docker): non serve il demone, e si scansiona proprio +# l'immagine provata. Pacchetti di Debian e dipendenze .NET di Febe (i file *.deps.json). +# +# .gitea/scripts/scansione-immagine.sh [cartella dei rapporti] +# +# La regola (docs/processo.md, «Rilievi di sicurezza»): +# - CRITICAL con una correzione disponibile: il lavoro fallisce e l'immagine non si pubblica; +# - HIGH, e CRITICAL ancora senza correzione: si riportano nel registro e in trivy.json, senza fermare nulla. +# Le eccezioni stanno solo in .trivyignore, alla radice del repository: un identificativo per riga, con la scadenza +# (exp:AAAA-MM-GG) e, sulla riga sopra, il motivo scritto e chi l'ha deciso. +set -euo pipefail + +radice="$(git rev-parse --show-toplevel)" +archivio="${1:?Manca il file .tar da scansionare.}" +rapporti="${2:-$radice/out/sicurezza}" +lavoro="${RUNNER_TEMP:-/tmp}" +strumenti="$lavoro/febe-strumenti" + +[[ -s "$archivio" ]] || { echo "Manca l'archivio dell'immagine: $archivio" >&2; exit 2; } +bash "$radice/.gitea/scripts/strumento.sh" trivy "$strumenti" +mkdir -p "$rapporti" + +# Niente barre di avanzamento, niente controllo di versioni nuove, niente dati d'uso. +export TRIVY_NO_PROGRESS=true TRIVY_SKIP_VERSION_CHECK=true TRIVY_DISABLE_TELEMETRY=true +export TRIVY_CACHE_DIR="$lavoro/febe-trivy-cache" +comuni=(image --input "$archivio" --scanners vuln --timeout 20m) +if [[ -f "$radice/.trivyignore" ]]; then + comuni+=(--ignorefile "$radice/.trivyignore") + echo "Eccezioni in .trivyignore: $(grep -c -E '^[^#[:space:]]' "$radice/.trivyignore" || true)" +fi + +echo "== Vulnerabilità HIGH e CRITICAL (rapporto: non fermano il lavoro)" +"$strumenti/trivy" "${comuni[@]}" --severity HIGH,CRITICAL --format json --output "$rapporti/trivy.json" --exit-code 0 +"$strumenti/trivy" convert --format table "$rapporti/trivy.json" + +if command -v jq > /dev/null; then + conteggio=$(jq -r '[.Results[]?.Vulnerabilities[]?] as $v + | "HIGH \([$v[] | select(.Severity == "HIGH")] | length) · CRITICAL \([$v[] | select(.Severity == "CRITICAL")] | length), di cui correggibili \([$v[] | select(.Severity == "CRITICAL" and ((.FixedVersion // "") != ""))] | length)"' "$rapporti/trivy.json") + echo "Trovate: $conteggio." + if [[ -n "${GITHUB_STEP_SUMMARY:-}" ]]; then + printf "### Sicurezza dell'immagine (Trivy)\n\n%s.\n" "$conteggio" >> "$GITHUB_STEP_SUMMARY" || true + fi +fi + +echo "== CRITICAL con una correzione disponibile (fermano il lavoro)" +if "$strumenti/trivy" "${comuni[@]}" --skip-db-update --skip-java-db-update --severity CRITICAL --ignore-unfixed \ + --format table --exit-code 1; then + echo "Nessuna vulnerabilità CRITICAL con una correzione disponibile." +else + echo "Vulnerabilità CRITICAL con una correzione disponibile: l'immagine non passa. Aggiorna il pacchetto o la dipendenza (docs/processo.md, «Rilievi di sicurezza»)." >&2 + exit 1 +fi diff --git a/.gitea/scripts/segreti.sh b/.gitea/scripts/segreti.sh new file mode 100755 index 0000000..0882922 --- /dev/null +++ b/.gitea/scripts/segreti.sh @@ -0,0 +1,47 @@ +#!/usr/bin/env bash +# Cerca segreti (gettoni, chiavi, password) in tutta la storia del repository con gitleaks, a versione fissa +# (strumento.sh): ogni commit di ogni ramo e tag scaricato, non solo l'ultimo. Un segreto non compare mai per intero: +# --redact lo sostituisce con REDACTED nel registro e nel rapporto, e qui si stampano solo regola, file, riga, commit +# e impronta del rilievo. +# +# .gitea/scripts/segreti.sh [cartella del rapporto] +# +# Che cosa fare con un rilievo: docs/processo.md, «Rilievi di sicurezza». In breve: un segreto vero si revoca subito +# (toglierlo dalla storia non basta); un falso allarme già controllato (un dato di prova finto) si mette in +# .gitleaksignore con la sua impronta e, sulla riga sopra, un commento che dice che cos'è e chi l'ha controllato. +set -euo pipefail + +radice="$(git rev-parse --show-toplevel)" +rapporti="${1:-$radice/out/sicurezza}" +strumenti="${RUNNER_TEMP:-/tmp}/febe-strumenti" + +if [[ "$(git -C "$radice" rev-parse --is-shallow-repository)" == "true" ]]; then + echo "Il clone è parziale: per cercare in tutta la storia serve actions/checkout con fetch-depth: 0." >&2 + exit 2 +fi + +bash "$radice/.gitea/scripts/strumento.sh" gitleaks "$strumenti" +mkdir -p "$rapporti" +rapporto="$rapporti/gitleaks.json" + +argomenti=(git "$radice" --redact --no-banner --no-color --exit-code 1 --log-level warn + --report-format json --report-path "$rapporto") +[[ -f "$radice/.gitleaks.toml" ]] && argomenti+=(--config "$radice/.gitleaks.toml") +[[ -f "$radice/.gitleaksignore" ]] && argomenti+=(--gitleaks-ignore-path "$radice/.gitleaksignore") + +commit=$(git -C "$radice" rev-list --all --count) +stato=0 +"$strumenti/gitleaks" "${argomenti[@]}" || stato=$? +if ((stato == 0)); then + echo "Nessun segreto in $commit commit." + exit 0 +fi + +if [[ -s "$rapporto" ]] && command -v jq > /dev/null; then + quanti=$(jq 'length' "$rapporto") + echo "Possibili segreti: $quanti (in $commit commit). Regola, file:riga, commit, impronta per .gitleaksignore:" >&2 + jq -r '.[] | " \(.RuleID) \(.File):\(.StartLine) commit \(.Commit[0:12]) impronta \(.Fingerprint)"' "$rapporto" >&2 +else + echo "gitleaks è uscito con $stato: vedi il registro qui sopra e il rapporto $rapporto." >&2 +fi +exit "$stato" diff --git a/.gitea/scripts/strumento.sh b/.gitea/scripts/strumento.sh new file mode 100755 index 0000000..66bbba7 --- /dev/null +++ b/.gitea/scripts/strumento.sh @@ -0,0 +1,60 @@ +#!/usr/bin/env bash +# Installa uno dei due strumenti esterni della CI, gli unici approvati da Alberto e solo per la CI (20 ottobre 2026): +# gitleaks (segreti nella storia) e Trivy (vulnerabilità dell'immagine). Versione fissa, archivio scaricato dalla +# release del progetto e installato solo se la sua impronta SHA-256 coincide con quella scritta qui. Le impronte sono +# quelle dei file *_checksums.txt delle release, ricontrollate il 20 ottobre 2026 sull'archivio scaricato e +# sull'impronta che GitHub mostra per l'allegato. +# +# .gitea/scripts/strumento.sh gitleaks|trivy +# +# Per aggiornare uno strumento si cambiano versione e impronta insieme, in un commit solo, con una riga in +# docs/decisioni.md. Mai «latest», mai le azioni di terzi (trivy-action fu compromessa a marzo 2026, CVE-2026-33634), +# mai uno script di installazione scaricato al volo. +set -euo pipefail + +nome="${1:?Indica lo strumento: gitleaks o trivy.}" +cartella="${2:?Indica la cartella in cui installarlo.}" + +case "$nome" in + gitleaks) + versione="8.30.1" + archivio="gitleaks_${versione}_linux_x64.tar.gz" + indirizzo="https://github.com/gitleaks/gitleaks/releases/download/v${versione}/${archivio}" + sha256="551f6fc83ea457d62a0d98237cbad105af8d557003051f41f3e7ca7b3f2470eb" + ;; + trivy) + versione="0.75.0" + archivio="trivy_${versione}_Linux-64bit.tar.gz" + indirizzo="https://github.com/aquasecurity/trivy/releases/download/v${versione}/${archivio}" + sha256="c6e65abddb348e25f10549df887045629cf28cc72453cd1c63acb717316b3f3f" + ;; + *) + echo "Strumento sconosciuto: «$nome» (gitleaks o trivy)." >&2 + exit 2 + ;; +esac + +piattaforma="$(uname -s)-$(uname -m)" +if [[ "$piattaforma" != "Linux-x86_64" ]]; then + echo "Gli archivi fissati qui sono per Linux x86_64, non per $piattaforma." >&2 + exit 2 +fi + +if [[ -x "$cartella/$nome" ]] && [[ -f "$cartella/$nome.sha256" ]] && [[ "$(cat "$cartella/$nome.sha256")" == "$sha256" ]]; then + echo "== $nome $versione già installato in $cartella" + exit 0 +fi + +temporanea="$(mktemp -d)" +trap 'rm -rf "$temporanea"' EXIT +echo "== $nome $versione" +curl -fsSL --retry 3 --retry-delay 5 --max-time 600 -o "$temporanea/$archivio" "$indirizzo" +if ! echo "$sha256 $temporanea/$archivio" | sha256sum -c --quiet -; then + echo "L'impronta SHA-256 di $archivio non è quella attesa: $nome non si installa." >&2 + exit 1 +fi +mkdir -p "$cartella" +tar -xzf "$temporanea/$archivio" -C "$cartella" "$nome" +chmod 0755 "$cartella/$nome" +echo "$sha256" > "$cartella/$nome.sha256" +"$cartella/$nome" --version | head -n 1 || true diff --git a/docs/decisioni.md b/docs/decisioni.md index cd1a3c2..ccbb776 100644 --- a/docs/decisioni.md +++ b/docs/decisioni.md @@ -228,3 +228,9 @@ Ogni scelta tecnica presa strada facendo, con data e motivo (specifica §15). | 2026-10-14 | Restano noti e accettati: «Tieni il più grande» scrive con il proprio SafeFileWriter e non passa dal lucchetto per account di `LibraryIngest` (un'importazione e uno scaricamento con gli stessi byte nello stesso istante potrebbero entrare entrambi); le prove d'interfaccia con browser vero aspettano fino a 30 s | Finestra rarissima, nessuna perdita di dati: al più un doppione esatto da togliere a mano | | 2026-10-20 | Il seme del mondo sintetico del sito di prova si sceglie con la variabile `FEBE_SEME_PROVA` (13 se manca), letta da `SyntheticSite` (`tests/Febe.Tests/Support`), l'unico modo in cui le prove avviano il sito; le classi che lo avviano stanno nella categoria `SitoDiProva`, e una prova controlla che nessuna lo avvii per altre vie o resti fuori dalla categoria. `SyntheticSiteSeedTests` controlla senza browser, per 300 semi, la forma del mondo su cui contano le prove d'insieme e i lettori sulle pagine servite | La CI rifà quelle prove con un seme diverso a ogni esecuzione, scritto nel registro, senza raddoppiare la durata di tutta la suite; senza la variabile non cambia nulla; un errore si rifà con lo stesso seme | | 2026-10-20 | Dockerfile: i file che il restore legge (soluzione, `Directory.*.props`, progetti) si trovano da soli in uno stadio `progetti` invece che da un elenco scritto a mano; lo stadio finale applica gli aggiornamenti della distribuzione (`apt-get upgrade`) prima di installare i pacchetti | Un progetto nuovo in `Febe.slnx` (come `tests/Febe.Tests.Windows`) non rompe più la costruzione dell'immagine e il restore resta in cache (BuildKit confronta il contenuto copiato); la scansione Trivy della CI non deve trovare correzioni di Debian già pubblicate ma non applicate perché l'immagine di base è più vecchia | +| 2026-10-20 | Codice comune della CI in script di `.gitea/scripts/` (lanciati con `bash`), non in azioni composite locali | Uno script si prova con `bash -n` nel lavoro «controlli» e si lancia anche a mano; le azioni composite di act hanno comportamenti propri (ambiente, `if`, passi finali) che qui non si possono provare prima della prima esecuzione vera | +| 2026-10-20 | Strumenti esterni della CI: solo gitleaks 8.30.1 e Trivy 0.75.0 (approvati da Alberto il 20 ottobre, solo nella CI), scaricati dalle release come binari e installati solo se l'impronta SHA-256 scritta in `strumento.sh` coincide (verificata sull'archivio, sul file `*_checksums.txt` e sull'impronta mostrata da GitHub); nessuna azione di terzi per eseguirli | `trivy-action` e `setup-trivy` furono compromesse a marzo 2026 (CVE-2026-33634, Trivy 0.69.4–0.69.6): un'etichetta si sposta, un'impronta no. Trivy 0.75.0 e non 0.76.0: almeno due settimane di vita prima di entrare nella CI | +| 2026-10-20 | gitleaks su tutta la storia (`fetch-depth: 0`, tutti i rami e i tag) con `--redact`; nessun `.gitleaks.toml` né elenco di eccezioni per ora: un'approssimazione locale delle 221 regole predefinite (le espressioni regolari pubblicate, applicate da uno script nostro: gitleaks non gira fuori dalla CI) non ha trovato rilievi veri, e i gettoni finti delle prove non hanno la forma completa che le regole cercano | Un falso allarme futuro si toglie con la sua impronta in `.gitleaksignore` e un commento accanto, mai disattivando una regola; un segreto vero si revoca prima di tutto (`docs/processo.md`) | +| 2026-10-20 | Trivy sull'archivio dell'immagine provata (non dal demone): una vulnerabilità CRITICAL con correzione disponibile ferma il lavoro, le HIGH (e le CRITICAL senza correzione) si riportano nel registro e in `trivy.json` (artefatto di 14 giorni); eccezioni solo in `.trivyignore`, con motivo scritto e scadenza `exp:` | La regola chiesta da Alberto; scansionare l'archivio vuol dire scansionare proprio l'immagine provata, senza dipendere dal socket del demone | +| 2026-10-20 | La prova del contenitore (`prova-immagine.sh`) gira sempre con `--network none`: Chromium, criteri, lingua, poi l'avvio come da guida (profilo seccomp, password casuale passata solo nell'ambiente del client) fino a «healthy», `febe --controllo-salute` e l'arresto entro 30 secondi | Regola 1: un'immagine appena costruita non deve poter raggiungere Instagram nemmeno per sbaglio; il controllo di salute passa dalla rete interna del contenitore | +| 2026-10-20 | Ciò che la CI crea sul demone porta i suoi segni: etichette `febe.ci.workflow`, `febe.ci.run`, `febe.ci.ref`, `febe.ci.commit` sull'immagine e sui contenitori di prova, nome locale `febe-ci:`, builder `febe-ci-`. `pulizia-docker.sh` toglie solo quello (più le immagini senza nome oltre 72 ore): alla fine di ogni lavoro, all'inizio del lavoro successivo per i resti più vecchi di 90 minuti, e ogni settimana. Mai `system prune`, `builder prune`, `volume prune` | Il demone è lo stesso di Encelado, Mimante e degli altri progetti: la loro cache e le loro immagini non si toccano; un'esecuzione annullata non può pulire da sé, e un lavoro dura al massimo 60 minuti, quindi un resto di 90 minuti è certamente orfano | -- 2.54.1 From f35b0a73017a2e1f3ac9034acc9cfe33eec1bf9f Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Tue, 20 Oct 2026 10:51:27 +0200 Subject: [PATCH 04/17] CI: pulizia settimanale del demone Docker del runner MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ogni lunedì, e a mano, toglie ciò che esecuzioni annullate o scadute non hanno potuto togliere (contenitori, immagini febe-ci e builder della CI di Febe più vecchi di 90 minuti), l'immagine febe:ci del vecchio flusso e le immagini senza nome più vecchie di 72 ore. Il demone è lo stesso degli altri progetti di Alberto: niente prune generali, niente cache del demone, niente volumi con nome. Co-Authored-By: Claude Opus 5.5 --- .gitea/workflows/pulizia.yml | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 .gitea/workflows/pulizia.yml diff --git a/.gitea/workflows/pulizia.yml b/.gitea/workflows/pulizia.yml new file mode 100644 index 0000000..7f5b538 --- /dev/null +++ b/.gitea/workflows/pulizia.yml @@ -0,0 +1,35 @@ +# Pulizia settimanale (il lunedì alle 4:17, ora del server di Gitea) e a mano (Actions ▸ pulizia ▸ Esegui) del demone +# Docker del runner. +# Ogni esecuzione di verifica e di rilascio toglie già ciò che crea; qui si toglie ciò che resta di esecuzioni +# interrotte (annullate o scadute) e ciò che invecchia. Il demone è lo stesso di Encelado, Mimante e degli altri +# progetti di Alberto: si toccano solo oggetti con i segni della CI di Febe (etichetta febe.ci.run, repository locale +# febe-ci, builder febe-ci-) e le immagini senza nome più vecchie di 72 ore. Mai le immagini degli altri +# progetti, mai la cache di costruzione del demone, mai i volumi con un nome. Dettagli in .gitea/scripts/pulizia-docker.sh +# e in docs/processo.md, «Pulizia». +name: pulizia + +on: + schedule: + - cron: "17 4 * * 1" + workflow_dispatch: + +permissions: + contents: read + +concurrency: + group: pulizia + cancel-in-progress: false + +defaults: + run: + shell: bash + +jobs: + docker: + runs-on: ubuntu-latest + timeout-minutes: 20 + steps: + - uses: actions/checkout@v4 + + - name: Resti della CI di Febe e immagini senza nome + run: bash .gitea/scripts/pulizia-docker.sh settimanale -- 2.54.1 From 7d8ea223815c8e57c6a45ed7f276349d1255fd66 Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Tue, 20 Oct 2026 10:51:46 +0200 Subject: [PATCH 05/17] Rilascio: immagine provata senza rete e scansionata, pulizia a fine lavoro MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Il lavoro «immagine» del rilascio costruisce come la verifica, con gli stessi script: prima della pubblicazione il contenitore parte senza rete fino al controllo di salute e Trivy ferma tutto per una CRITICAL con correzione; alla fine, sempre, toglie immagini, contenitori, cache e builder dell'esecuzione, e all'inizio i resti di esecuzioni interrotte. Il resto non cambia: prove, Windows, pubblicazione con il segreto (o la release che dice che manca) e release. Ogni lavoro ha un tempo massimo. La prova del flusso segue la pubblicazione nello script comune. Co-Authored-By: Claude Opus 5.5 --- .gitea/workflows/rilascio.yml | 67 +++++++++++++++----- tests/Febe.Tests/Packaging/PackagingTests.cs | 20 ++++-- 2 files changed, 67 insertions(+), 20 deletions(-) diff --git a/.gitea/workflows/rilascio.yml b/.gitea/workflows/rilascio.yml index a55bdf8..90284b9 100644 --- a/.gitea/workflows/rilascio.yml +++ b/.gitea/workflows/rilascio.yml @@ -3,9 +3,10 @@ # e tutte le prove passano. Senza prove verdi non si costruisce né si rilascia nulla; # 2. windows: Febe.exe in un file solo, il programma di installazione NSIS e lo zip portabile (installer/costruisci.sh, # gira su Linux); -# 3. immagine: l'immagine Docker (le prove girano anche dentro la build), pubblicata sul registro dei container di +# 3. immagine: l'immagine Docker (le prove girano anche dentro la build), provata senza rete e scansionata con Trivy +# come nella verifica (una CRITICAL con correzione ferma tutto), poi pubblicata sul registro dei container di # Gitea come //febe:X.Y.Z e :latest (solo per le versioni senza trattino). Il lavoro dice -# se l'ha pubblicata; +# se l'ha pubblicata, e alla fine toglie sempre immagini, contenitori, cache e builder dell'esecuzione; # 4. release: solo dopo le prove, l'installatore e l'immagine. Crea la release (o la completa, se esiste già) con # installatore, zip portabile, modello Unraid e l'archivio per Docker Compose (compose.yml con il profilo seccomp # accanto); le note dicono dove sta l'immagine, o che non è stata pubblicata. @@ -29,6 +30,7 @@ on: jobs: prove: runs-on: ubuntu-latest + timeout-minutes: 60 steps: - uses: actions/checkout@v4 @@ -60,6 +62,7 @@ jobs: windows: runs-on: ubuntu-latest needs: prove + timeout-minutes: 30 steps: - uses: actions/checkout@v4 @@ -90,6 +93,12 @@ jobs: immagine: runs-on: ubuntu-latest needs: prove + timeout-minutes: 60 + env: + FLUSSO: rilascio + ESECUZIONE: ${{ gitea.run_id }} + BUILDER: febe-ci-${{ gitea.run_id }} + PROVA: febe-ci:${{ gitea.run_id }} outputs: immagine: ${{ steps.nome.outputs.immagine }} pubblicata: ${{ steps.pubblicazione.outputs.pubblicata }} @@ -97,6 +106,12 @@ jobs: steps: - uses: actions/checkout@v4 + # Ciò che un'esecuzione interrotta non ha potuto togliere, e un tentativo precedente di questa stessa esecuzione. + - name: Resti di esecuzioni interrotte + run: | + bash .gitea/scripts/pulizia-docker.sh residui 90 + bash .gitea/scripts/pulizia-docker.sh esecuzione "$ESECUZIONE" + - name: Versione, registro e nome dell'immagine id: nome run: | @@ -105,6 +120,9 @@ jobs: [ -n "$REGISTRY" ] || REGISTRY=$(echo "${{ gitea.server_url }}" | sed -E 's#^https?://##; s#/.*$##') OWNER=$(echo "${{ gitea.repository_owner }}" | tr '[:upper:]' '[:lower:]') echo "VERSION=$V" >> "$GITHUB_ENV" + echo "VERSIONE=$V" >> "$GITHUB_ENV" + echo "GIT_COMMIT=${GITHUB_SHA::12}" >> "$GITHUB_ENV" + echo "ARCHIVIO=${RUNNER_TEMP:-/tmp}/febe-$ESECUZIONE.tar" >> "$GITHUB_ENV" echo "REGISTRY=$REGISTRY" >> "$GITHUB_ENV" echo "IMAGE=$REGISTRY/$OWNER/febe" >> "$GITHUB_ENV" echo "registro=$REGISTRY" >> "$GITHUB_OUTPUT" @@ -113,19 +131,32 @@ jobs: # Un builder buildx proprio, che sa che il registro di casa risponde in HTTP. - uses: docker/setup-buildx-action@v3 with: + name: febe-ci-${{ gitea.run_id }} driver: docker-container buildkitd-config-inline: | [registry."${{ steps.nome.outputs.registro }}"] http = true insecure = true + # Gli stessi argomenti ed etichette della pubblicazione (costruisci-immagine.sh): quella esce dalla cache di questa. - name: Costruzione dell'immagine (le prove girano dentro la build) run: | - docker buildx build -f docker/Dockerfile \ - --build-arg VERSION="$VERSION" \ - --build-arg GIT_COMMIT="${GITHUB_SHA::12}" \ - -t "$IMAGE:$VERSION" --load . - docker run --rm --entrypoint /usr/bin/chromium "$IMAGE:$VERSION" --version + bash .gitea/scripts/costruisci-immagine.sh archivio "$ARCHIVIO" "$PROVA" + docker load -i "$ARCHIVIO" + + - name: Prova del contenitore, senza rete + run: bash .gitea/scripts/prova-immagine.sh "$PROVA" "$ESECUZIONE" + + - name: Vulnerabilità dell'immagine (Trivy) + run: bash .gitea/scripts/scansione-immagine.sh "$ARCHIVIO" out/sicurezza + + - name: Rapporto di Trivy + if: ${{ !cancelled() }} + uses: actions/upload-artifact@v3 + with: + name: sicurezza-immagine + path: out/sicurezza/trivy.json + if-no-files-found: ignore - name: Segreto per il registro id: segreto @@ -156,16 +187,13 @@ jobs: AUTH=$(printf '%s:%s' "$UTENTE" "$TOKEN" | base64 -w0) jq --arg r "$REGISTRY" --arg a "$AUTH" '.auths[$r].auth = $a' "$CONFIG/config.json" > "$CONFIG/config.json.nuovo" mv "$CONFIG/config.json.nuovo" "$CONFIG/config.json" - TAGS="-t $IMAGE:$VERSION" + NOMI="$IMAGE:$VERSION" case "$VERSION" in *-*) echo "Versione di anteprima: :latest non si sposta." ;; - *) TAGS="$TAGS -t $IMAGE:latest" ;; + *) NOMI="$NOMI $IMAGE:latest" ;; esac - # La stessa costruzione di prima (dalla cache del builder), questa volta spinta sul registro. - docker buildx build -f docker/Dockerfile \ - --build-arg VERSION="$VERSION" \ - --build-arg GIT_COMMIT="${GITHUB_SHA::12}" \ - $TAGS --push . + # La stessa costruzione di prima (dalla cache del builder), questa volta spinta sul registro da buildx. + bash .gitea/scripts/costruisci-immagine.sh pubblica $NOMI echo "pubblicata=si" >> "$GITHUB_OUTPUT" - name: Credenziali tolte @@ -176,12 +204,19 @@ jobs: jq --arg r "$REGISTRY" 'if .auths then .auths |= del(.[$r]) else . end' "$CONFIG" > "$CONFIG.nuovo" && mv "$CONFIG.nuovo" "$CONFIG" fi + - name: Pulizia (sempre) + if: always() + run: | + if [ -n "${ARCHIVIO:-}" ]; then rm -f "$ARCHIVIO"; fi + bash .gitea/scripts/pulizia-docker.sh esecuzione "$ESECUZIONE" + release: runs-on: ubuntu-latest # Le prove sono verdi, l'installatore c'è e l'immagine si è costruita: pubblicata, o non pubblicata per la sola - # mancanza del segreto (il lavoro «immagine» lo dice e le note lo riportano). Se la costruzione o la spinta sul - # registro falliscono, non esce nessuna release. + # mancanza del segreto (il lavoro «immagine» lo dice e le note lo riportano). Se la costruzione, la prova del + # contenitore, la scansione o la spinta sul registro falliscono, non esce nessuna release. needs: [prove, windows, immagine] + timeout-minutes: 15 steps: - uses: actions/checkout@v4 diff --git a/tests/Febe.Tests/Packaging/PackagingTests.cs b/tests/Febe.Tests/Packaging/PackagingTests.cs index 91e923d..4b10664 100644 --- a/tests/Febe.Tests/Packaging/PackagingTests.cs +++ b/tests/Febe.Tests/Packaging/PackagingTests.cs @@ -145,13 +145,25 @@ public sealed partial class PackagingTests StringAssert.Contains(secret, "presente=no"); StringAssert.Contains(Step(image, "Pubblicazione sul registro di Gitea"), "if: steps.segreto.outputs.presente == 'si'"); - // The registry at home answers in HTTP: buildx with its own builder, told so, and no «docker login». + // The registry at home answers in HTTP: buildx with its own builder, told so, and no «docker login». The push is + // the same build as the tested one (.gitea/scripts/costruisci-immagine.sh, shared with the verification). StringAssert.Contains(image, "uses: docker/setup-buildx-action@v3"); StringAssert.Contains(image, "http = true"); StringAssert.Contains(image, "insecure = true"); - StringAssert.Contains(image, "--push"); - Assert.DoesNotContain("docker login", image); - Assert.DoesNotContain("docker push", image); + StringAssert.Contains(Step(image, "Pubblicazione sul registro di Gitea"), "bash .gitea/scripts/costruisci-immagine.sh pubblica"); + var build = File.ReadAllText(Repository.PathOf(".gitea", "scripts", "costruisci-immagine.sh")); + StringAssert.Contains(build, "docker buildx build \"${comuni[@]}\" \"${etichette[@]}\" --push ."); + foreach (var text in new[] { image, build }) + { + Assert.DoesNotContain("docker login", text); + Assert.DoesNotContain("docker push", text); + } + + // Before publishing, the image is started without a network and scanned (Trivy); at the end everything of the + // run goes away, whatever happened. + StringAssert.Contains(image, "bash .gitea/scripts/prova-immagine.sh"); + StringAssert.Contains(image, "bash .gitea/scripts/scansione-immagine.sh"); + StringAssert.Contains(Step(image, "Pulizia (sempre)"), "if: always()"); // pkg-4: compose.yml goes out with chromium/seccomp.json next to it, never alone. StringAssert.Contains(release, "cp docker/compose.yml \"$COMPOSE/compose.yml\""); -- 2.54.1 From d1e29aa7a4d6db7bf9b773aededa243bd3e9ea30 Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Tue, 20 Oct 2026 10:52:27 +0200 Subject: [PATCH 06/17] CI: verifica di ogni push con controlli, prove vere, installatore e immagine MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit La verifica girava solo su main e su un ramo che non esiste più, e saltava le 66 prove con browser, ffmpeg e makensis. Ora gira a ogni push su qualunque ramo (e a mano), in quattro lavori: controlli veloci e gitleaks su tutta la storia; compilazione di tutta la soluzione e tutte le prove di tests/Febe.Tests in un contenitore Debian con Chromium, Xvfb, ffmpeg, NSIS e Node veri, senza prove saltate, con il seme 13 e di nuovo con il seme dell'esecuzione per le prove del sito di prova; installatore e zip con la versione -ci. come artefatti per 14 giorni; immagine costruita con buildx, provata senza rete, scansionata con Trivy e, solo dopo un push su main e con il segreto, pubblicata come :main e :sha-. Senza il segreto un avviso e il lavoro resta verde; alla fine si toglie sempre ciò che l'esecuzione ha creato. Niente pull_request, che rifarebbe tutto sullo stesso commit. Le prove sui flussi tengono ferme queste regole. Co-Authored-By: Claude Opus 5.5 --- .gitea/workflows/verifica.yml | 301 ++++++++++++++++++-- docs/decisioni.md | 7 + tests/Febe.Tests/Packaging/PipelineTests.cs | 258 +++++++++++++++++ 3 files changed, 538 insertions(+), 28 deletions(-) create mode 100644 tests/Febe.Tests/Packaging/PipelineTests.cs diff --git a/.gitea/workflows/verifica.yml b/.gitea/workflows/verifica.yml index 363bc25..312bdd0 100644 --- a/.gitea/workflows/verifica.yml +++ b/.gitea/workflows/verifica.yml @@ -1,18 +1,149 @@ -# Verifica a ogni push e a ogni pull request: compilazione con gli avvisi come errori -# (compreso Febe.Desktop, che si compila anche da Linux) e tutte le prove. -# Le prove che richiedono Chromium e Xvfb si saltano da sole se il runner non li ha. +# Verifica: a ogni push su qualunque ramo (i tag li prende rilascio.yml) e a mano (Actions ▸ verifica ▸ Esegui). +# I suoi quattro lavori sono i controlli richiesti per unire in main (docs/processo.md): +# controlli sintassi degli script, flussi senza tabulazioni, segni di conflitto, versione, progetti della +# soluzione, JSON; segreti in tutta la storia con gitleaks (versione e impronta fissate); +# prove compilazione di tutta la soluzione con gli avvisi come errori e tutte le prove di tests/Febe.Tests +# (mai «dotnet test» sulla soluzione intera: tests/Febe.Tests.Windows gira solo su Windows) con +# Chromium, Xvfb, ffmpeg, NSIS e Node veri in un contenitore Debian 13: nessuna prova deve saltarsi. +# Il mondo sintetico del sito di prova ha il seme 13 e, per la categoria SitoDiProva, anche il seme di +# questa esecuzione, scritto nel registro per rifare un errore; +# installatore Febe-Setup--ci..exe e lo zip portabile, artefatti per 14 giorni; +# immagine l'immagine Docker costruita con buildx, provata senza rete (parte, salute, Chromium, it_IT) e +# scansionata con Trivy (si ferma per una CRITICAL con correzione); solo dopo un push su main la +# pubblica come :main e :sha-<7 caratteri> (:latest resta al rilascio). Alla fine, sempre, toglie +# immagini, contenitori, cache e builder di questa esecuzione. # -# Runner: act_runner con l'etichetta ubuntu-latest. +# Niente «pull_request»: in Gitea una richiesta di unione mostra lo stato del suo ultimo commit, che il push del ramo +# ha già verificato; pull_request rifarebbe tutto sullo stesso commit (refs/pull/N/head) sull'unico runner. +# Runner: act_runner con l'etichetta ubuntu-latest, un lavoro alla volta. I lavori parlano con il demone Docker del +# server, lo stesso di Encelado, Mimante e degli altri progetti: niente montaggi della cartella del lavoro in altri +# contenitori (sul server i percorsi sono diversi); le immagini passano come archivi e contesti di costruzione. +# Che cosa di Gitea 28 si usa e perché: docs/decisioni.md (20 ottobre 2026) e docs/processo.md. name: verifica on: push: - branches: [main, febe-v1] - pull_request: + branches: ["**"] + workflow_dispatch: + inputs: + seme: + description: "Seme del mondo sintetico per la seconda passata delle prove (vuoto: 1000 più il numero dell'esecuzione)" + required: false + default: "" + +permissions: + contents: read + +# Su un ramo conta l'ultimo push: l'esecuzione precedente si annulla. Su main ogni commit ha il suo gruppo, così ogni +# unione arriva fino in fondo e pubblica la sua :sha-. +concurrency: + group: verifica-${{ gitea.ref }}${{ gitea.ref == 'refs/heads/main' && format('-{0}', gitea.sha) || '' }} + cancel-in-progress: ${{ gitea.ref != 'refs/heads/main' }} + +defaults: + run: + shell: bash + +env: + DOTNET_NOLOGO: "1" + DOTNET_CLI_TELEMETRY_OPTOUT: "1" + DOTNET_SKIP_FIRST_TIME_EXPERIENCE: "1" jobs: - prove: + controlli: runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + # Tutta la storia, di tutti i rami e i tag: gitleaks la legge commit per commit. + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Script, flussi, conflitti, versione, soluzione e JSON + run: bash .gitea/scripts/controlli.sh + + - name: Segreti in tutta la storia (gitleaks) + run: bash .gitea/scripts/segreti.sh out/sicurezza + + - name: Rapporto di gitleaks (segreti oscurati) + if: failure() + uses: actions/upload-artifact@v3 + with: + name: rapporto-gitleaks + path: out/sicurezza/gitleaks.json + retention-days: 14 + if-no-files-found: ignore + + prove: + needs: controlli + runs-on: ubuntu-latest + timeout-minutes: 60 + # Debian 13 con Node 24: Chromium vero della distribuzione, come nell'immagine di Febe (su Ubuntu è uno snap), e + # Node per le azioni e per la prova della pagina di accesso. + container: + image: node:24-trixie + env: + FEBE_CHROMIUM: /usr/bin/chromium + SEME_RICHIESTO: ${{ gitea.event.inputs.seme }} + NUMERO: ${{ gitea.run_number }} + steps: + - uses: actions/checkout@v4 + + - name: Chromium, Xvfb, ffmpeg, NSIS e lingua italiana + run: bash .gitea/scripts/ambiente-prove.sh + + - uses: actions/setup-dotnet@v4 + with: + dotnet-version: "10.0.x" + + - name: Compilazione di tutta la soluzione (avvisi = errori) + run: dotnet build Febe.slnx -c Release -nologo -warnaserror + + - name: Semi del mondo sintetico + id: semi + run: | + seme="${SEME_RICHIESTO:-}" + [ -n "$seme" ] || seme=$((1000 + ${NUMERO:-0})) + if ! [[ "$seme" =~ ^-?[0-9]{1,9}$ ]]; then + echo "Seme non valido: «$seme» (serve un intero di al massimo nove cifre)." >&2 + exit 1 + fi + echo "seme=$seme" >> "$GITHUB_OUTPUT" + echo "Mondo sintetico: seme 13 per tutte le prove, seme $seme per la seconda passata (categoria SitoDiProva)." + echo "Per rifarla: FEBE_SEME_PROVA=$seme dotnet test tests/Febe.Tests --filter \"TestCategory=SitoDiProva\"" + + - name: Prove, seme 13 + run: >- + dotnet test tests/Febe.Tests -c Release --no-build --nologo + --logger "trx;LogFileName=prove-seme-13.trx" --results-directory out/prove + + - name: Prove del sito di prova, seme dell'esecuzione + if: ${{ !cancelled() && steps.semi.outputs.seme != '' }} + env: + FEBE_SEME_PROVA: ${{ steps.semi.outputs.seme }} + run: >- + dotnet test tests/Febe.Tests -c Release --no-build --nologo --filter "TestCategory=SitoDiProva" + --logger "trx;LogFileName=prove-seme-$FEBE_SEME_PROVA.trx" --results-directory out/prove + + - name: Riepilogo delle prove + if: ${{ !cancelled() }} + run: bash .gitea/scripts/riepilogo-prove.sh out/prove 0 + + - name: Risultati delle prove + if: ${{ !cancelled() }} + uses: actions/upload-artifact@v3 + with: + name: risultati-prove + path: out/prove/*.trx + retention-days: 14 + if-no-files-found: warn + + installatore: + needs: prove + runs-on: ubuntu-latest + timeout-minutes: 30 + env: + NUMERO: ${{ gitea.run_number }} steps: - uses: actions/checkout@v4 @@ -20,37 +151,151 @@ jobs: with: dotnet-version: "10.0.x" - - name: Compilazione (avvisi = errori) - run: dotnet build Febe.slnx -c Release -nologo -warnaserror + - name: NSIS e zip + run: | + SUDO=""; [ "$(id -u)" = 0 ] || SUDO=sudo + $SUDO apt-get update -qq + $SUDO apt-get install -y -qq nsis zip > /dev/null - - name: Prove - run: >- - dotnet test tests/Febe.Tests -c Release --no-build --nologo - --logger "trx;LogFileName=prove.trx" --results-directory out/prove + - name: Febe.exe, programma di installazione e zip portabile (versione di prova) + run: | + V=$(sed -n 's:.*\(.*\).*:\1:p' Directory.Build.props | head -n 1) + echo "Versione di questa esecuzione: $V-ci.$NUMERO" + bash installer/costruisci.sh "$V-ci.$NUMERO" - - name: Risultati - if: always() + - name: Artefatti per Windows uses: actions/upload-artifact@v3 with: - name: risultati-prove - path: out/prove/*.trx - if-no-files-found: ignore + name: windows + path: | + out/Febe-Setup-*.exe + out/Febe-*-portabile.zip + retention-days: 14 + if-no-files-found: error immagine: - runs-on: ubuntu-latest needs: prove + runs-on: ubuntu-latest + timeout-minutes: 60 + env: + FLUSSO: verifica + ESECUZIONE: ${{ gitea.run_id }} + NUMERO: ${{ gitea.run_number }} + BUILDER: febe-ci-${{ gitea.run_id }} + PROVA: febe-ci:${{ gitea.run_id }} steps: - uses: actions/checkout@v4 - - name: Costruzione dell'immagine Docker (senza pubblicarla; le prove girano anche dentro la build) + # Ciò che un'esecuzione interrotta (annullata, scaduta) non ha potuto togliere, e un tentativo precedente di + # questa stessa esecuzione. + - name: Resti di esecuzioni interrotte run: | - docker version - docker build -f docker/Dockerfile \ - --build-arg VERSION=ci \ - --build-arg GIT_COMMIT="${GITHUB_SHA::12}" \ - -t febe:ci . + bash .gitea/scripts/pulizia-docker.sh residui 90 + bash .gitea/scripts/pulizia-docker.sh esecuzione "$ESECUZIONE" - - name: L'immagine parte e mostra la pagina di errore senza password + # Registro: la variabile REGISTRY delle Actions, se c'è, altrimenti l'host dell'indirizzo del server (ROOT_URL). + - name: Versione, registro e nomi + id: nome + env: + REGISTRO_SCELTO: ${{ vars.REGISTRY }} + SERVER: ${{ gitea.server_url }} + PROPRIETARIO: ${{ gitea.repository_owner }} run: | - docker run --rm --entrypoint /usr/bin/chromium febe:ci --version - docker run --rm --entrypoint sh febe:ci -c 'locale -a | grep -i it_IT && ls /etc/chromium/policies/managed/' + V=$(sed -n 's:.*\(.*\).*:\1:p' Directory.Build.props | head -n 1) + REGISTRY="$REGISTRO_SCELTO" + [ -n "$REGISTRY" ] || REGISTRY=$(echo "$SERVER" | sed -E 's#^https?://##; s#/.*$##') + OWNER=$(echo "$PROPRIETARIO" | tr '[:upper:]' '[:lower:]') + { + echo "VERSIONE=$V-ci.$NUMERO" + echo "GIT_COMMIT=${GITHUB_SHA::12}" + echo "REGISTRY=$REGISTRY" + echo "IMAGE=$REGISTRY/$OWNER/febe" + echo "ARCHIVIO=${RUNNER_TEMP:-/tmp}/febe-$ESECUZIONE.tar" + } >> "$GITHUB_ENV" + echo "registro=$REGISTRY" >> "$GITHUB_OUTPUT" + echo "Immagine $V-ci.$NUMERO del commit ${GITHUB_SHA::12}, provata come $PROVA; registro $REGISTRY/$OWNER/febe" + + # Un builder buildx di questa esecuzione (con la sua cache), che sa che il registro di casa risponde in HTTP. + - name: Builder buildx dell'esecuzione + uses: docker/setup-buildx-action@v3 + with: + name: febe-ci-${{ gitea.run_id }} + driver: docker-container + buildkitd-config-inline: | + [registry."${{ steps.nome.outputs.registro }}"] + http = true + insecure = true + + - name: Costruzione dell'immagine (dentro girano compilazione e prove) + run: | + bash .gitea/scripts/costruisci-immagine.sh archivio "$ARCHIVIO" "$PROVA" + docker load -i "$ARCHIVIO" + + - name: Prova del contenitore, senza rete + run: bash .gitea/scripts/prova-immagine.sh "$PROVA" "$ESECUZIONE" + + - name: Vulnerabilità dell'immagine (Trivy) + run: bash .gitea/scripts/scansione-immagine.sh "$ARCHIVIO" out/sicurezza + + - name: Rapporto di Trivy + if: ${{ !cancelled() }} + uses: actions/upload-artifact@v3 + with: + name: sicurezza-immagine + path: out/sicurezza/trivy.json + retention-days: 14 + if-no-files-found: ignore + + - name: Pubblicare? + id: segreto + env: + TOKEN: ${{ secrets.REGISTRY_TOKEN }} + EVENTO: ${{ gitea.event_name }} + RIFERIMENTO: ${{ gitea.ref }} + run: | + if [ "$EVENTO" != push ] || [ "$RIFERIMENTO" != refs/heads/main ]; then + echo "Si pubblica solo dopo un push su main: qui l'immagine è costruita, provata e scansionata." + echo "presente=no" >> "$GITHUB_OUTPUT" + elif [ -z "$TOKEN" ]; then + echo "::warning::Manca il segreto REGISTRY_TOKEN: l'immagine di main è costruita, provata e scansionata ma non pubblicata. Aggiungilo (token con package: read and write) e rilancia la verifica di questo commit." + echo "presente=no" >> "$GITHUB_OUTPUT" + else + echo "presente=si" >> "$GITHUB_OUTPUT" + fi + + - name: Pubblicazione come :main e :sha- + if: steps.segreto.outputs.presente == 'si' + env: + TOKEN: ${{ secrets.REGISTRY_TOKEN }} + UTENTE: ${{ gitea.actor }} + run: | + # Le credenziali vanno nella configurazione del client: buildx le passa al builder, il demone non c'entra (e + # proverebbe HTTPS). Non si stampano mai. + CONFIG="${DOCKER_CONFIG:-$HOME/.docker}" + mkdir -p "$CONFIG" + [ -s "$CONFIG/config.json" ] || echo '{}' > "$CONFIG/config.json" + AUTH=$(printf '%s:%s' "$UTENTE" "$TOKEN" | base64 -w0) + jq --arg r "$REGISTRY" --arg a "$AUTH" '.auths[$r].auth = $a' "$CONFIG/config.json" > "$CONFIG/config.json.nuovo" + mv "$CONFIG/config.json.nuovo" "$CONFIG/config.json" + NOMI=("$IMAGE:sha-${GITHUB_SHA::7}") + # :main solo se main è ancora a questo commit: un'esecuzione arrivata in ritardo non lo riporta indietro. + CIMA=$(git ls-remote origin refs/heads/main 2> /dev/null | cut -f1) + if [ "$CIMA" = "$GITHUB_SHA" ]; then + NOMI+=("$IMAGE:main") + elif [ -z "$CIMA" ]; then + echo "::warning::Non riesco a leggere la cima di main: si pubblica solo :sha-${GITHUB_SHA::7} e :main resta dov'è." + else + echo "main è già andato avanti (${CIMA::7}): si pubblica solo :sha-${GITHUB_SHA::7}." + fi + bash .gitea/scripts/costruisci-immagine.sh pubblica "${NOMI[@]}" + + - name: Pulizia (sempre) + if: always() + run: | + CONFIG="${DOCKER_CONFIG:-$HOME/.docker}/config.json" + if [ -s "$CONFIG" ] && [ -n "${REGISTRY:-}" ]; then + jq --arg r "$REGISTRY" 'if .auths then .auths |= del(.[$r]) else . end' "$CONFIG" > "$CONFIG.nuovo" \ + && mv "$CONFIG.nuovo" "$CONFIG" || echo "::warning::Non riesco a togliere le credenziali da $CONFIG." + fi + if [ -n "${ARCHIVIO:-}" ]; then rm -f "$ARCHIVIO"; fi + bash .gitea/scripts/pulizia-docker.sh esecuzione "$ESECUZIONE" diff --git a/docs/decisioni.md b/docs/decisioni.md index ccbb776..faa77b7 100644 --- a/docs/decisioni.md +++ b/docs/decisioni.md @@ -234,3 +234,10 @@ Ogni scelta tecnica presa strada facendo, con data e motivo (specifica §15). | 2026-10-20 | Trivy sull'archivio dell'immagine provata (non dal demone): una vulnerabilità CRITICAL con correzione disponibile ferma il lavoro, le HIGH (e le CRITICAL senza correzione) si riportano nel registro e in `trivy.json` (artefatto di 14 giorni); eccezioni solo in `.trivyignore`, con motivo scritto e scadenza `exp:` | La regola chiesta da Alberto; scansionare l'archivio vuol dire scansionare proprio l'immagine provata, senza dipendere dal socket del demone | | 2026-10-20 | La prova del contenitore (`prova-immagine.sh`) gira sempre con `--network none`: Chromium, criteri, lingua, poi l'avvio come da guida (profilo seccomp, password casuale passata solo nell'ambiente del client) fino a «healthy», `febe --controllo-salute` e l'arresto entro 30 secondi | Regola 1: un'immagine appena costruita non deve poter raggiungere Instagram nemmeno per sbaglio; il controllo di salute passa dalla rete interna del contenitore | | 2026-10-20 | Ciò che la CI crea sul demone porta i suoi segni: etichette `febe.ci.workflow`, `febe.ci.run`, `febe.ci.ref`, `febe.ci.commit` sull'immagine e sui contenitori di prova, nome locale `febe-ci:`, builder `febe-ci-`. `pulizia-docker.sh` toglie solo quello (più le immagini senza nome oltre 72 ore): alla fine di ogni lavoro, all'inizio del lavoro successivo per i resti più vecchi di 90 minuti, e ogni settimana. Mai `system prune`, `builder prune`, `volume prune` | Il demone è lo stesso di Encelado, Mimante e degli altri progetti: la loro cache e le loro immagini non si toccano; un'esecuzione annullata non può pulire da sé, e un lavoro dura al massimo 60 minuti, quindi un resto di 90 minuti è certamente orfano | +| 2026-10-20 | `verifica` a ogni push su qualunque ramo (`branches: ["**"]`, quindi mai sui tag) e a mano (`workflow_dispatch`, con un seme facoltativo); niente `pull_request` | In Gitea i controlli di una richiesta di unione sono gli stati del suo ultimo commit, che il push del ramo ha già verificato; `pull_request` girerebbe sullo stesso commit (`refs/pull/N/head`, non un'unione di prova) e sull'unico runner raddoppierebbe tutto. Niente richieste da fork: un solo autore, rami nello stesso repository | +| 2026-10-20 | Concorrenza di `verifica`: su un ramo l'esecuzione nuova annulla quella in corso; su main ogni commit ha il suo gruppo e nessuna si annulla; `:main` si sposta solo se main è ancora a quel commit | Il runner fa un lavoro alla volta; ogni unione in main deve arrivare a pubblicare la sua `:sha-`, e un'esecuzione in ritardo non deve riportare indietro `:main`. Gitea 28 valuta le espressioni di `concurrency.group` e `cancel-in-progress` (`services/actions/concurrency.go`) | +| 2026-10-20 | Lavoro «prove» nel contenitore `node:24-trixie` (Debian 13 con Node 24), con Chromium, Xvfb, ffmpeg, NSIS e la lingua italiana installati a ogni esecuzione; il riepilogo non ammette prove saltate; seconda passata della categoria `SitoDiProva` con il seme 1000 + numero dell'esecuzione, o quello chiesto a mano | Su Ubuntu Chromium è uno snap; le azioni JavaScript girano dentro il contenitore del lavoro e vogliono Node; un'immagine di CI costruita da noi non può fare da contenitore del lavoro, perché act_runner la scaricherebbe da un registro e quello di casa è in HTTP; nella CI una prova saltata vuol dire un ambiente rotto, non una prova superata | +| 2026-10-20 | Installatore di ogni esecuzione con versione `-ci.` e immagine con etichetta `org.opencontainers.image.version` uguale; dopo ogni unione in main l'immagine va sul registro come `:main` e `:sha-<7 caratteri>`, mai `:latest`, che resta del rilascio | Decisione di Alberto del 20 ottobre; la versione di prova non si confonde con una versione rilasciata e `installer/costruisci.sh` la accetta già | +| 2026-10-20 | Artefatti con `actions/upload-artifact@v3` e `retention-days: 14` (risultati delle prove, installatore e zip, rapporti di sicurezza) | La v4 rifiuta di girare dove il server non è github.com (prende Gitea per GHES) e la sua copia per Gitea sarebbe un'azione nuova, non approvata; il backend v3 di Gitea 28 rispetta `retentionDays` (`routers/api/actions/artifacts.go`) | +| 2026-10-20 | `permissions: contents: read` in `verifica` e `pulizia`; i riepiloghi delle prove e di Trivy vanno nel registro e anche in `GITHUB_STEP_SUMMARY` | Gitea 28 applica `permissions` al gettone del lavoro (docs.gitea.com, «Actions job token permissions»), che così non può scrivere nel repository; i riepiloghi dei lavori esistono da Gitea 1.27 ma compaiono solo se il runner li carica, quindi il registro resta la fonte | +| 2026-10-20 | Ciò che la CI usa di Gitea 28 e di act_runner: `concurrency` con espressioni, `timeout-minutes` dei lavori (lo applica il runner), `workflow_dispatch` con `inputs`, `schedule`, `defaults.run.shell`, `container` del lavoro, contesti `gitea.*`, `vars` e `secrets`; gli stati dei commit si chiamano «verifica / (push)» (`modules/actions/workflows.go`) e solo push, pull_request e release ne creano | Controllato sul codice di Gitea `release/v28` e su docs.gitea.com il 20 ottobre 2026; ciò che solo la prima esecuzione vera può provare è in `docs/processo.md` | diff --git a/tests/Febe.Tests/Packaging/PipelineTests.cs b/tests/Febe.Tests/Packaging/PipelineTests.cs new file mode 100644 index 0000000..06e228e --- /dev/null +++ b/tests/Febe.Tests/Packaging/PipelineTests.cs @@ -0,0 +1,258 @@ +using System.Text.RegularExpressions; +using Febe.Tests.Desktop.Support; +using Febe.Tests.Support; + +namespace Febe.Tests.Packaging; + +/// +/// The CI of the repository (.gitea/workflows/verifica.yml, pulizia.yml and the scripts of .gitea/scripts), read as +/// text: the rules that must survive later edits. Every push of every branch is verified and nothing else triggers +/// it twice; the tests run only through tests/Febe.Tests, with the browser, and again with the seed of the run; the +/// image is published only from main and never as :latest; credentials are never printed; the external tools are +/// pinned and checked; the cleanup touches only what the CI of Febe made; the tried container never has a network. +/// +[TestClass] +public sealed partial class PipelineTests +{ + private static readonly string[] Jobs = ["controlli", "prove", "installatore", "immagine"]; + + [TestMethod] + public void EveryPushOfEveryBranchIsVerifiedOnceAndTagsAreLeftToTheRelease() + { + var workflow = Workflow("verifica.yml"); + StringAssert.Contains(workflow, "on:\n push:\n branches: [\"**\"]\n workflow_dispatch:"); + var code = Code(workflow); + Assert.DoesNotContain("pull_request", code, "a PR shows the status of its head commit, already verified by the push"); + Assert.DoesNotContain("tags:", code, "tags belong to rilascio.yml"); + StringAssert.Contains(code, "cancel-in-progress: ${{ gitea.ref != 'refs/heads/main' }}", "every merge into main runs to the end"); + } + + [TestMethod] + public void TheJobsFollowOneAnotherAndEachHasATimeout() + { + var workflow = Workflow("verifica.yml"); + foreach (var job in Jobs) + { + StringAssert.Contains(Job(workflow, job), "timeout-minutes:", job); + } + + StringAssert.Contains(Job(workflow, "prove"), "needs: controlli"); + StringAssert.Contains(Job(workflow, "installatore"), "needs: prove"); + StringAssert.Contains(Job(workflow, "immagine"), "needs: prove"); + foreach (var other in new[] { "rilascio.yml", "pulizia.yml" }) + { + var text = Workflow(other); + foreach (Match job in JobHeader().Matches(text)) + { + StringAssert.Contains(Job(text, job.Groups["name"].Value), "timeout-minutes:", $"{other}: {job.Groups["name"].Value}"); + } + } + } + + [TestMethod] + public void TheWholeSolutionIsBuiltAndTheTestsRunOnlyThroughTheTestProjectWithTheBrowser() + { + var prove = Job(Workflow("verifica.yml"), "prove"); + StringAssert.Contains(prove, "container:\n image: node:24-trixie", "Debian: Chromium is a real package there, a snap on Ubuntu"); + StringAssert.Contains(prove, "bash .gitea/scripts/ambiente-prove.sh"); + StringAssert.Contains(prove, "dotnet build Febe.slnx -c Release -nologo -warnaserror"); + StringAssert.Contains(prove, "bash .gitea/scripts/riepilogo-prove.sh out/prove 0", "no test may skip itself in the CI"); + + // The second pass: the tests of the synthetic world again, with the seed of the run in the variable the helper reads. + StringAssert.Contains(prove, $"{SyntheticSite.Variable}: ${{{{ steps.semi.outputs.seme }}}}"); + StringAssert.Contains(prove, $"--filter \"TestCategory={SyntheticSite.Category}\""); + + var environment = Script("ambiente-prove.sh"); + foreach (var package in new[] { "chromium", "xvfb", "ffmpeg", "nsis", "locales" }) + { + StringAssert.Contains(environment, package); + } + + // tests/Febe.Tests.Windows runs only on Windows: never «dotnet test» on the solution or without a project. + foreach (var name in new[] { "verifica.yml", "rilascio.yml" }) + { + foreach (Match test in DotnetTest().Matches(Code(Workflow(name)))) + { + Assert.AreEqual("tests/Febe.Tests", test.Groups["target"].Value, $"{name}: {test.Value}"); + } + } + } + + [TestMethod] + public void TheImageIsPublishedOnlyAfterAPushToMainAsMainAndShaNeverAsLatest() + { + var image = Job(Workflow("verifica.yml"), "immagine"); + var decision = Step(image, "Pubblicare?"); + StringAssert.Contains(decision, "[ \"$EVENTO\" != push ] || [ \"$RIFERIMENTO\" != refs/heads/main ]"); + StringAssert.Contains(decision, "::warning::Manca il segreto REGISTRY_TOKEN"); + Assert.DoesNotContain("exit 1", decision, "without the secret the job stays green"); + var publish = Step(image, "Pubblicazione come :main e :sha-"); + StringAssert.Contains(publish, "if: steps.segreto.outputs.presente == 'si'"); + StringAssert.Contains(publish, "\"$IMAGE:sha-${GITHUB_SHA::7}\""); + StringAssert.Contains(publish, "\"$IMAGE:main\""); + StringAssert.Contains(publish, "bash .gitea/scripts/costruisci-immagine.sh pubblica"); + Assert.DoesNotContain(":latest", Code(Workflow("verifica.yml")), ":latest belongs to the release"); + + // Built with buildx, tried without a network and scanned before anything is published; always cleaned up. + StringAssert.Contains(image, "uses: docker/setup-buildx-action@v3"); + StringAssert.Contains(image, "http = true"); + StringAssert.Contains(image, "insecure = true"); + var decide = image.IndexOf("- name: Pubblicare?", StringComparison.Ordinal); + foreach (var gate in new[] { "bash .gitea/scripts/costruisci-immagine.sh archivio", "bash .gitea/scripts/prova-immagine.sh", "bash .gitea/scripts/scansione-immagine.sh" }) + { + var at = image.IndexOf(gate, StringComparison.Ordinal); + Assert.IsTrue(at >= 0 && at < decide, $"«{gate}» comes before the publication"); + } + var cleanup = Step(image, "Pulizia (sempre)"); + StringAssert.Contains(cleanup, "if: always()"); + StringAssert.Contains(cleanup, "bash .gitea/scripts/pulizia-docker.sh esecuzione \"$ESECUZIONE\""); + StringAssert.Contains(cleanup, ".auths |= del(.[$r])", "the credentials leave the client configuration"); + } + + [TestMethod] + public void SecretsAreNeverPrintedNorTheDaemonUsedForTheRegistry() + { + foreach (var (name, text) in AllCiFiles()) + { + var code = Code(text); + Assert.DoesNotContain("docker login", code, name); + Assert.DoesNotContain("docker push", code, name); + Assert.IsFalse(Trace().IsMatch(code), $"{name}: no shell tracing (it would print secrets)"); + + // A secret goes into echo or printf only to be piped or redirected, never to the log. + foreach (var line in code.Split('\n').Where(l => Printing().IsMatch(l))) + { + var secret = SecretReference().Match(line); + if (secret.Success) + { + var after = line[secret.Index..]; + Assert.IsTrue(after.Contains('|', StringComparison.Ordinal) || after.Contains('>', StringComparison.Ordinal), $"{name}: «{line.Trim()}» would print a secret"); + } + } + } + } + + [TestMethod] + public void TheExternalToolsArePinnedAndCheckedAndNoThirdPartyActionRunsThem() + { + var tool = Script("strumento.sh"); + StringAssert.Contains(tool, "versione=\"8.30.1\""); + StringAssert.Contains(tool, "versione=\"0.75.0\""); + Assert.HasCount(2, Sha256().Matches(tool), "one SHA-256 per tool"); + StringAssert.Contains(tool, "sha256sum -c"); + Assert.DoesNotContain("latest", Code(tool)); + foreach (var (name, text) in AllCiFiles()) + { + Assert.DoesNotContain("trivy-action", Code(text), name); + Assert.DoesNotContain("gitleaks-action", Code(text), name); + } + + var secrets = Script("segreti.sh"); + StringAssert.Contains(secrets, "--redact"); + StringAssert.Contains(Job(Workflow("verifica.yml"), "controlli"), "fetch-depth: 0"); + var scan = Script("scansione-immagine.sh"); + StringAssert.Contains(scan, "--severity CRITICAL --ignore-unfixed"); + StringAssert.Contains(scan, "--exit-code 1"); + } + + [TestMethod] + public void TheCleanupTouchesOnlyWhatTheCiOfFebeMade() + { + var cleanup = Code(Script("pulizia-docker.sh")); + foreach (var forbidden in new[] { "system prune", "builder prune", "volume prune", "container prune", "image prune -a", "prune --all", "image prune -f -a" }) + { + Assert.DoesNotContain(forbidden, cleanup, "the daemon is shared with Alberto's other projects"); + } + + Assert.HasCount(1, ImagePrune().Matches(cleanup), "only dangling images, older than three days"); + StringAssert.Contains(cleanup, "docker image prune -f --filter \"until=72h\""); + StringAssert.Contains(cleanup, "--filter \"label=febe.ci.run=$run\""); + StringAssert.Contains(cleanup, "^buildx_buildkit_(febe-ci-[0-9]+)0$"); + + var weekly = Workflow("pulizia.yml"); + StringAssert.Contains(weekly, "schedule:"); + StringAssert.Contains(weekly, "workflow_dispatch:"); + StringAssert.Contains(weekly, "bash .gitea/scripts/pulizia-docker.sh settimanale"); + } + + [TestMethod] + public void TheTriedContainerNeverHasANetwork() + { + var smoke = Code(Script("prova-immagine.sh")); + var runs = DockerRun().Matches(smoke); + Assert.IsGreaterThanOrEqualTo(4, runs.Count); + foreach (Match run in runs) + { + StringAssert.Contains(run.Value, "--network none", "rule 1: the image under test cannot reach any site"); + } + } + + /// The workflows and the scripts of the CI, by name. + private static List<(string Name, string Text)> AllCiFiles() => + [.. Directory.EnumerateFiles(CiPath("workflows")).Concat(Directory.EnumerateFiles(CiPath("scripts"))) + .Select(file => (Path.GetFileName(file), Read(file)))]; + + private static string Workflow(string name) => Read(CiPath("workflows", name)); + + private static string Script(string name) => Read(CiPath("scripts", name)); + + private static string Read(string path) => File.ReadAllText(path).Replace("\r\n", "\n", StringComparison.Ordinal); + + /// A path under .gitea; inconclusive in the build of the image, whose context leaves .gitea out. + private static string CiPath(params string[] parts) + { + var path = Repository.PathOf([".gitea", .. parts]); + var root = Repository.Root()!; + if (!File.Exists(path) && !Directory.Exists(path) && !Directory.Exists(Path.Combine(root, ".git")) && !File.Exists(Path.Combine(root, ".git"))) + { + Assert.Inconclusive("Questa copia del repository non ha .gitea/ (costruzione dell'immagine Docker)."); + } + + return path; + } + + /// The text without comment lines (YAML and shell): what runs, not what the comments say. + private static string Code(string text) => + string.Join('\n', text.Replace("\r\n", "\n", StringComparison.Ordinal).Split('\n').Where(line => !line.TrimStart().StartsWith('#'))); + + /// The block of a job: from « name:» to the next job. + private static string Job(string workflow, string name) + { + var match = Regex.Match(workflow, $@"^ {Regex.Escape(name)}:\n(?(?:(?: .*|\s*)\n)*)", RegexOptions.Multiline); + Assert.IsTrue(match.Success, $"manca il lavoro {name}"); + return match.Groups["body"].Value; + } + + /// The block of a step, from its «- name:» to the next step. + private static string Step(string job, string name) + { + var start = job.IndexOf("- name: " + name, StringComparison.Ordinal); + Assert.IsGreaterThanOrEqualTo(0, start, $"manca il passo «{name}»"); + var next = job.IndexOf("\n - ", start + 1, StringComparison.Ordinal); + return next < 0 ? job[start..] : job[start..next]; + } + + [GeneratedRegex(@"(?<=^jobs:\n(?:.*\n)*?)^ (?[a-z][\w-]*):$", RegexOptions.Multiline)] + private static partial Regex JobHeader(); + + [GeneratedRegex(@"dotnet test(?:\s+(?[^\s-][^\s]*))?")] + private static partial Regex DotnetTest(); + + [GeneratedRegex(@"(?m)^\s*set\s+-[a-wyz]*x|\bbash\s+-x\b")] + private static partial Regex Trace(); + + [GeneratedRegex(@"\b(?:echo|printf)\b")] + private static partial Regex Printing(); + + [GeneratedRegex(@"\$\{?(?:TOKEN|FEBE_PASSWORD|AUTH|REGISTRY_TOKEN|PASSWORD)\b")] + private static partial Regex SecretReference(); + + [GeneratedRegex(@"\b[0-9a-f]{64}\b")] + private static partial Regex Sha256(); + + [GeneratedRegex(@"docker (?:image|container|volume|builder|system) prune")] + private static partial Regex ImagePrune(); + + [GeneratedRegex(@"docker run\b(?:[^\n]*\\\n)*[^\n]*")] + private static partial Regex DockerRun(); +} -- 2.54.1 From bff054dcf64ae707b1069ee3c386442b4c199324 Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Tue, 20 Oct 2026 10:54:26 +0200 Subject: [PATCH 07/17] Repository: modello delle richieste di unione, segnalazioni e proprietari MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ogni richiesta di unione chiede sintesi, perché, che cosa cambia, comandi e risultati delle prove (e che cosa non è stato provato), rischi e ritorno indietro, e la lista delle quattordici regole di §2 della specifica. Due modelli di segnalazione (difetto, proposta) ricordano che segreti e campioni grezzi non vanno mai incollati. CODEOWNERS fa di Alberto il revisore di tutto (in Gitea le regole sono espressioni regolari). Co-Authored-By: Claude Opus 5.5 --- .gitea/CODEOWNERS | 4 ++ .gitea/ISSUE_TEMPLATE/config.yaml | 5 +++ .gitea/ISSUE_TEMPLATE/difetto.md | 36 +++++++++++++++++ .gitea/ISSUE_TEMPLATE/proposta.md | 23 +++++++++++ .gitea/pull_request_template.md | 67 +++++++++++++++++++++++++++++++ 5 files changed, 135 insertions(+) create mode 100644 .gitea/CODEOWNERS create mode 100644 .gitea/ISSUE_TEMPLATE/config.yaml create mode 100644 .gitea/ISSUE_TEMPLATE/difetto.md create mode 100644 .gitea/ISSUE_TEMPLATE/proposta.md create mode 100644 .gitea/pull_request_template.md diff --git a/.gitea/CODEOWNERS b/.gitea/CODEOWNERS new file mode 100644 index 0000000..f1d1052 --- /dev/null +++ b/.gitea/CODEOWNERS @@ -0,0 +1,4 @@ +# Proprietari del codice: Gitea chiede la loro revisione a ogni richiesta di unione che tocca i file indicati. +# In Gitea le regole sono espressioni regolari di Go, non schemi alla maniera di .gitignore (docs.gitea.com, «Code Owners»). +# Alberto è il proprietario di tutto il repository. +.* @Alby96 diff --git a/.gitea/ISSUE_TEMPLATE/config.yaml b/.gitea/ISSUE_TEMPLATE/config.yaml new file mode 100644 index 0000000..3cf5034 --- /dev/null +++ b/.gitea/ISSUE_TEMPLATE/config.yaml @@ -0,0 +1,5 @@ +blank_issues_enabled: true +contact_links: + - name: Guida di Febe + url: https://gitea.encke-hake.ts.net/Alby96/Febe/wiki + about: Installazione, primo collegamento, limiti, problemi comuni e sicurezza diff --git a/.gitea/ISSUE_TEMPLATE/difetto.md b/.gitea/ISSUE_TEMPLATE/difetto.md new file mode 100644 index 0000000..8b451b5 --- /dev/null +++ b/.gitea/ISSUE_TEMPLATE/difetto.md @@ -0,0 +1,36 @@ +--- +name: Difetto +about: Febe fa qualcosa di sbagliato, o non fa ciò che dovrebbe +title: "Difetto: " +--- + + + +## Che cosa succede + + + +## Che cosa ti aspettavi + +## Come rifarlo + +1. +2. + +## Dove + +- Veste: Docker (Unraid, Compose) / Windows (installato, portabile) +- Versione di Febe (Impostazioni ▸ Informazioni, o etichetta dell'immagine): +- Profilo di prudenza: +- Contro Instagram vero o contro il sito di prova: + +## Registro + + + +```text +``` diff --git a/.gitea/ISSUE_TEMPLATE/proposta.md b/.gitea/ISSUE_TEMPLATE/proposta.md new file mode 100644 index 0000000..c8c5be9 --- /dev/null +++ b/.gitea/ISSUE_TEMPLATE/proposta.md @@ -0,0 +1,23 @@ +--- +name: Proposta +about: Una funzione nuova o un cambiamento di comportamento +title: "Proposta: " +--- + +## Il problema + + + +## La proposta + +## Regole di §2 toccate + + + +- [ ] Nessuna +- [ ] Sì, quali e perché: + +## Come capiremo che è fatta + +- diff --git a/.gitea/pull_request_template.md b/.gitea/pull_request_template.md new file mode 100644 index 0000000..c3e2a82 --- /dev/null +++ b/.gitea/pull_request_template.md @@ -0,0 +1,67 @@ + + +## Sintesi + + + +## Perché + + + +## Che cosa cambia + + + +- + +## Come è stato provato + + + +```text +dotnet build Febe.slnx -warnaserror +dotnet test tests/Febe.Tests +``` + +Non provato: + +- + +## Rischi e ritorno indietro + + + +## Controlli prima di unire + +Le regole di §2 della specifica (docs/SPECIFICA.md), che valgono sempre: + +- [ ] 1. Verso Instagram parla solo il browser di Febe: nessuna connessione verso domini di Instagram o Meta, salvo il CDN alle condizioni di §6.5 +- [ ] 2. Il browser si usa così com'è: niente stealth, user agent, impronta, fuso o lingua cambiati, headless, intestazioni riscritte, proxy, più account; comandi CDP solo dall'elenco di §6.1 +- [ ] 3. Niente scavalcamenti: CAPTCHA, verifiche e codici non si risolvono in automatico, Febe si ferma e avvisa +- [ ] 4. Un account, una rete, un motore; i cookie non si copiano da una macchina all'altra +- [ ] 5. Sola lettura: niente mi piace, segui, commenti, messaggi, reazioni +- [ ] 6. Solo ciò che l'account di Alberto vede già +- [ ] 7. Ogni azione del motore verso il sito passa dal Governatore (IGovernor) +- [ ] 8. Al primo segnale di §7.6 ci si ferma, senza nuovi tentativi automatici +- [ ] 9. Nessuna prova, script o verifica contatta Instagram (solo tools/Febe.SitoDiProva) e nessuno apre i campioni grezzi della sonda (solo le copie ripulite di tests/campioni) +- [ ] 10. Nessun formato di risposta inventato: i lettori si scrivono su campioni reali ripuliti +- [ ] 11. Mai password, cookie, gettoni, tasti o corpi di risposta nei registri, nei messaggi di errore o nell'output della CI; i campioni grezzi fuori da git +- [ ] 12. La libreria non cancella e non sostituisce file da sola +- [ ] 13. Nessuna dipendenza fuori dall'elenco chiuso di §3 (Directory.Packages.props), se Alberto non l'ha approvata +- [ ] 14. Resoconto onesto: ciò che non è stato verificato è scritto qui sopra + +E le convenzioni: + +- [ ] La verifica è verde sull'ultimo commit: controlli, prove (nessuna saltata), installatore, immagine +- [ ] Nel motore niente DateTime.Now, Task.Delay o Random diretti (IClock, IRandomSource) +- [ ] Codice e commenti in inglese; interfaccia, documenti e messaggi in italiano +- [ ] Ogni scelta tecnica nuova ha la sua riga in docs/decisioni.md +- [ ] Una schermata cambiata è stata confrontata con il suo mockup (§10.7) +- [ ] Le righe per CHANGELOG.md e docs/stato.md sono scritte qui sotto (le aggiunge chi integra) + +### Per CHANGELOG.md e docs/stato.md + +- -- 2.54.1 From 6e95aef5cc99da77bcb039afd13befd7b978f057 Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Tue, 20 Oct 2026 10:57:22 +0200 Subject: [PATCH 08/17] Documenti: processo, CI ed etichette dell'immagine MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit docs/processo.md descrive il percorso di una modifica come in un'azienda: rami, commit, richieste di unione, controlli richiesti e protezione di main da configurare su Gitea, che cosa garantisce ciascun lavoro della CI, etichette del registro (:main, :sha-, :X.Y.Z, :latest), pulizia, rilievi di sicurezza, rilasci e correzioni urgenti, e che cosa solo la prima esecuzione vera può provare. CLAUDE.md e la guida per lo sviluppo dicevano che la verifica girava a ogni push, e non era vero: ora descrivono la CI com'è. docs/docker.md dice quali etichette ha l'immagine e come risalire all'esecuzione che l'ha costruita. Co-Authored-By: Claude Opus 5.5 --- CLAUDE.md | 7 +- docs/decisioni.md | 1 + docs/docker.md | 19 ++++ docs/guida/Sviluppo.md | 25 ++++-- docs/processo.md | 198 +++++++++++++++++++++++++++++++++++++++++ 5 files changed, 244 insertions(+), 6 deletions(-) create mode 100644 docs/processo.md diff --git a/CLAUDE.md b/CLAUDE.md index 0dc4bf7..f058d64 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -38,6 +38,11 @@ Conserva: tappa in corso, file modificati, controlli ancora da eseguire, domande ## Repository e rilascio - Repository: Gitea di casa, https://gitea.encke-hake.ts.net/Alby96/Febe (ramo main). Non è GitHub: niente strumenti GitHub. -- CI in `.gitea/workflows/`: `verifica.yml` a ogni push e pull request, `rilascio.yml` a ogni tag `vX.Y.Z` (immagine Docker sul registro di Gitea, installatore Windows e release). +- Processo (rami `/`, commit piccoli, una richiesta di unione per ramo, verifica verde per unire in main, commit di unione, rilasci, correzioni urgenti): docs/processo.md. +- CI in `.gitea/workflows/`, script comuni in `.gitea/scripts/`: + - `verifica.yml` a ogni push su qualunque ramo (non sui tag) e a mano, niente pull_request: controlli e gitleaks; compilazione di tutta la soluzione e tutte le prove di `tests/Febe.Tests` con Chromium, Xvfb, ffmpeg e NSIS veri in Debian, nessuna saltata, anche con il seme dell'esecuzione (`FEBE_SEME_PROVA`); installatore e zip `-ci.`; immagine provata senza rete e scansionata con Trivy. Dopo un push su main pubblica `:main` e `:sha-` (con il segreto `REGISTRY_TOKEN`; senza, un avviso). + - `rilascio.yml` a ogni tag `vX.Y.Z`: immagine `:X.Y.Z` (e `:latest`) sul registro di Gitea, installatore Windows e release. + - `pulizia.yml` ogni lunedì: solo i resti della CI di Febe sul demone Docker condiviso. +- Le prove nella CI passano solo da `tests/Febe.Tests`, mai `dotnet test` sulla soluzione intera. - La versione sta solo in `Directory.Build.props` (``); il tag deve coincidere. - Guida per l'uso: wiki del repository (sorgenti in `docs/guida/`). diff --git a/docs/decisioni.md b/docs/decisioni.md index faa77b7..01641a8 100644 --- a/docs/decisioni.md +++ b/docs/decisioni.md @@ -241,3 +241,4 @@ Ogni scelta tecnica presa strada facendo, con data e motivo (specifica §15). | 2026-10-20 | Artefatti con `actions/upload-artifact@v3` e `retention-days: 14` (risultati delle prove, installatore e zip, rapporti di sicurezza) | La v4 rifiuta di girare dove il server non è github.com (prende Gitea per GHES) e la sua copia per Gitea sarebbe un'azione nuova, non approvata; il backend v3 di Gitea 28 rispetta `retentionDays` (`routers/api/actions/artifacts.go`) | | 2026-10-20 | `permissions: contents: read` in `verifica` e `pulizia`; i riepiloghi delle prove e di Trivy vanno nel registro e anche in `GITHUB_STEP_SUMMARY` | Gitea 28 applica `permissions` al gettone del lavoro (docs.gitea.com, «Actions job token permissions»), che così non può scrivere nel repository; i riepiloghi dei lavori esistono da Gitea 1.27 ma compaiono solo se il runner li carica, quindi il registro resta la fonte | | 2026-10-20 | Ciò che la CI usa di Gitea 28 e di act_runner: `concurrency` con espressioni, `timeout-minutes` dei lavori (lo applica il runner), `workflow_dispatch` con `inputs`, `schedule`, `defaults.run.shell`, `container` del lavoro, contesti `gitea.*`, `vars` e `secrets`; gli stati dei commit si chiamano «verifica / (push)» (`modules/actions/workflows.go`) e solo push, pull_request e release ne creano | Controllato sul codice di Gitea `release/v28` e su docs.gitea.com il 20 ottobre 2026; ciò che solo la prima esecuzione vera può provare è in `docs/processo.md` | +| 2026-10-20 | Processo in `docs/processo.md`: rami `/` da `main`, commit piccoli in italiano, una richiesta di unione per ramo con il modello di `.gitea/` (comprese le 14 regole di §2), unione con commit di unione e ramo cancellato; `main` protetto con i quattro lavori di `verifica` come controlli richiesti e «blocca se indietro»; tag `v*` protetti; Alberto proprietario di tutto (`CODEOWNERS`) | Decisione di Alberto del 20 ottobre (processo da grande azienda); con il ramo aggiornato il commit di unione ha lo stesso contenuto del commit verificato, quindi in `main` entra solo codice provato. Le approvazioni richieste dipendono da chi apre le richieste (Gitea non conta quella dell'autore): domanda aperta per Alberto | diff --git a/docs/docker.md b/docs/docker.md index 521d3b2..87ad929 100644 --- a/docs/docker.md +++ b/docs/docker.md @@ -20,6 +20,25 @@ display virtuale (Xvfb) e la libreria su disco. Si usa dal browser di casa; il b - L'immagine si costruisce solo con le prove verdi: la compilazione e tutte le prove girano dentro la costruzione (quelle con il browser vero lì si saltano da sole, perché nello stadio di compilazione non ci sono Chromium e Xvfb; girano nella CI e in sviluppo). +- I pacchetti di Debian sono aggiornati al momento della costruzione (anche le correzioni uscite dopo l'immagine di + base). Prima di ogni pubblicazione la CI fa partire il contenitore senza rete fino al controllo di salute e lo + scansiona con Trivy: una vulnerabilità CRITICAL con correzione disponibile ferma la pubblicazione + (`docs/processo.md`, «Rilievi di sicurezza»). + +## Etichette dell'immagine + +Sul registro di Gitea, `192.168.30.23:3000/alby96/febe`: + +| Etichetta | Che cos'è | Quando cambia | +|---|---|---| +| `:latest` | l'ultima versione rilasciata senza trattino: quella del modello di Unraid e di `compose.yml` | a ogni rilascio stabile | +| `:X.Y.Z` | una versione rilasciata (anche `X.Y.Z-rc.N` per un'anteprima) | mai: serve per tornare a una versione precisa | +| `:main` | l'ultimo commit di `main` che ha passato la verifica | a ogni unione in `main`: per provare, non per l'archivio vero | +| `:sha-<7 caratteri>` | un commit di `main` preciso | mai | + +Ogni immagine costruita dalla CI dice da dove viene, nelle etichette Docker `febe.ci.workflow`, `febe.ci.run`, +`febe.ci.ref` e `febe.ci.commit` e in `org.opencontainers.image.version` e `.revision`: +`docker inspect --format '{{json .Config.Labels}}' `. ## Volumi diff --git a/docs/guida/Sviluppo.md b/docs/guida/Sviluppo.md index 045686d..03e7713 100644 --- a/docs/guida/Sviluppo.md +++ b/docs/guida/Sviluppo.md @@ -129,12 +129,27 @@ da sole). Vedi [Installazione con Docker e Unraid](Installazione-Docker-e-Unraid ## CI e rilascio Il repository è sul Gitea di casa (); la CI usa Gitea Actions in -`.gitea/workflows/`: +`.gitea/workflows/`, con il codice comune in `.gitea/scripts/`. Il processo completo (nomi dei rami, commit, +richieste di unione, protezione di `main`, rilievi di sicurezza, rilasci, correzioni urgenti) è in `docs/processo.md`. -- `verifica.yml`, a ogni push e pull request: compilazione con gli avvisi come errori, tutte le prove, costruzione - dell'immagine Docker (senza pubblicarla) e due controlli sull'immagine (Chromium presente, lingua italiana generata); -- `rilascio.yml`, a ogni tag `vX.Y.Z`: immagine Docker sul registro di Gitea, installatore Windows e release. Al 13 - ottobre 2026 è in preparazione: se il file non c'è ancora in `.gitea/workflows/`, il rilascio non è automatico. +- `verifica.yml`, a ogni push su qualunque ramo e a mano (non sui tag, non sulle richieste di unione, che mostrano lo + stato del loro ultimo commit). Quattro lavori, che sono i controlli richiesti per unire in `main`: + - `controlli`: sintassi degli script, file di testo, versione, progetti della soluzione, JSON, e nessun segreto in + tutta la storia (gitleaks); + - `prove`: compilazione di tutta la soluzione con gli avvisi come errori e tutte le prove di `tests/Febe.Tests` in + un contenitore Debian con Chromium, Xvfb, ffmpeg, NSIS e Node veri: nessuna prova si salta; + - `installatore`: `Febe-Setup--ci..exe` e lo zip portabile, fra gli artefatti per 14 giorni; + - `immagine`: l'immagine Docker, provata senza rete (parte, diventa «healthy», si ferma) e scansionata con Trivy; + dopo un push su `main` va sul registro come `:main` e `:sha-`. Alla fine si toglie tutto ciò che + l'esecuzione ha creato sul demone Docker, che è condiviso con gli altri progetti; +- `rilascio.yml`, a ogni tag `vX.Y.Z`: prove, installatore e zip, immagine provata e scansionata, pubblicata come + `:X.Y.Z` e `:latest` (solo per le versioni senza trattino), poi la release; +- `pulizia.yml`, ogni lunedì e a mano: i resti delle esecuzioni interrotte e le immagini senza nome vecchie. + +Nella CI le prove del sito di prova (categoria `SitoDiProva`) girano due volte: con il seme 13 e con un seme diverso +a ogni esecuzione, scritto nel registro del lavoro. Per rifare un errore con quel seme: +`FEBE_SEME_PROVA= dotnet test tests/Febe.Tests --filter "TestCategory=SitoDiProva"`. I controlli veloci della +CI si lanciano anche a mano: `bash .gitea/scripts/controlli.sh`. La versione sta solo in `Directory.Build.props` (``); il tag deve coincidere. diff --git a/docs/processo.md b/docs/processo.md new file mode 100644 index 0000000..e7fbac4 --- /dev/null +++ b/docs/processo.md @@ -0,0 +1,198 @@ +# Processo: dal ramo al rilascio + +Come una modifica arriva in `main` e da lì a una versione, con le stesse garanzie di un'azienda che non accetta codice +non verificato. Vale per Alberto e per chiunque lavori al repository, persone o agenti. Repository: il Gitea di casa, + (non GitHub: niente strumenti di GitHub). Il motivo di ogni scelta è in +`docs/decisioni.md`, alle righe del 20 ottobre 2026. + +## In breve + +1. Un ramo per filone di lavoro, nato da `main`. +2. Commit piccoli e separati, ciascuno con un messaggio che dice che cosa cambia e perché. +3. A ogni push la verifica parte da sola: controlli, prove, installatore, immagine. +4. Una richiesta di unione per ramo, con il modello compilato, e una revisione. +5. Si unisce in `main` solo con la verifica verde sull'ultimo commit (protezione di `main`), con un commit di unione; + il ramo si cancella. +6. Dopo l'unione la verifica gira su `main` e pubblica l'immagine `:main` e `:sha-`. +7. Un rilascio è un tag `vX.Y.Z` su `main`. + +## Rami + +- Nome: `/`, in minuscolo, parole separate da trattini, in italiano. Tipi: + + | Tipo | Per | + |---|---| + | `funzione/` | una funzione nuova (`funzione/esporta-csv`) | + | `correzione/` | un difetto (`correzione/webview2-avvio`) | + | `urgente/` | una correzione da rilasciare subito (vedi «Correzioni urgenti») | + | `ci/` | flussi, script e immagini della CI (`ci/pipeline-aziendale`) | + | `strumenti/` | strumenti di sviluppo (`strumenti/vscode`) | + | `documenti/` | solo documenti e guida | + | `rilascio/` | la preparazione di una versione (`rilascio/0.2.0`) | + +- Si parte da `main` aggiornato e si resta brevi: giorni, non settimane. Se `main` va avanti, il ramo si aggiorna + (pulsante «Aggiorna il ramo» della richiesta di unione, o `git merge origin/main`) prima di unire. +- Su `main` non si fa push diretto: ci si arriva solo da una richiesta di unione. + +## Commit + +- Piccoli e logici: ogni commit compila e passa le prove da solo (così `git bisect` funziona). +- Messaggio in italiano: la prima riga (al massimo 72 caratteri) dice che cosa cambia; il corpo, dopo una riga vuota, + dice perché. Non un elenco di file. +- I commit scritti con un agente finiscono con una riga vuota e `Co-Authored-By: …` dell'agente. +- Mai nel repository: risultati di compilazione (`bin/`, `obj/`, `out/`), segreti, campioni grezzi della sonda, dati + di Alberto. + +## Richieste di unione + +- Una per ramo, con il modello (`.gitea/pull_request_template.md`): sintesi, perché, che cosa cambia, come è stato + provato (comandi e risultati, e che cosa non è stato provato), rischi e ritorno indietro, le quattordici regole di + §2 della specifica. Le righe per `CHANGELOG.md` e `docs/stato.md` stanno nella richiesta: le aggiunge chi integra. +- Revisione: Alberto è il proprietario di tutto (`.gitea/CODEOWNERS`). Le osservazioni si risolvono con commit nuovi + sullo stesso ramo, non riscrivendo quelli già rivisti. +- Stile di unione: **commit di unione** («Crea un commit di unione»), con il titolo della richiesta; poi il ramo si + cancella («Elimina il ramo dopo l'unione», da tenere attivo nelle impostazioni del repository). +- Tornare indietro: `git revert -m 1 ` in una nuova richiesta di unione. + +## Controlli richiesti e protezione di main + +I controlli richiesti sono i quattro lavori della verifica, come Gitea li riporta sul commit: +`verifica / controlli (push)`, `verifica / prove (push)`, `verifica / installatore (push)`, +`verifica / immagine (push)`. Una richiesta di unione mostra lo stato del suo ultimo commit, che il push del ramo ha +già verificato: per questo la verifica non gira anche su `pull_request`. + +Regola di protezione di `main` (Impostazioni ▸ Rami ▸ Aggiungi regola; la imposta chi integra, una volta che i +quattro controlli sono comparsi almeno una volta): + +| Impostazione | Valore | +|---|---| +| Schema del ramo | `main` | +| Push | disattivato: solo da richiesta di unione | +| Push forzato | disattivato | +| Controllo di stato | attivo, con gli schemi `verifica / controlli (push)`, `verifica / prove (push)`, `verifica / installatore (push)`, `verifica / immagine (push)` | +| Blocca l'unione se la richiesta è indietro rispetto al ramo di base | attivo: con il ramo aggiornato il commit di unione ha lo stesso contenuto del commit verificato | +| Approvazioni richieste | 1 se le richieste le apre un account diverso da quello di Alberto; 0 se le apre lui (Gitea non conta l'approvazione dell'autore) | +| Annulla le approvazioni superate da nuovi commit | attivo | +| Blocca l'unione con revisioni che chiedono modifiche | attivo | +| Anche gli amministratori seguono la regola | attivo | + +E nei tag protetti (Impostazioni ▸ Tag): `v*` creabili solo da Alberto. + +## La CI + +Gitea Actions su un solo act_runner (etichetta `ubuntu-latest`, un lavoro alla volta). I lavori parlano con il demone +Docker del server, lo stesso che costruisce Encelado, Mimante e gli altri progetti di Alberto. I flussi stanno in +`.gitea/workflows/`, il codice comune in `.gitea/scripts/` (si lancia anche a mano). + +| Lavoro | Quando | Che cosa garantisce | +|---|---|---| +| `controlli` | ogni push | sintassi di tutti gli script di shell (`bash -n`, `sh -n`) e righe Unix; flussi senza tabulazioni; nessun segno di conflitto; versione in `Directory.Build.props` valida; ogni progetto di `Febe.slnx` esiste; ogni JSON si legge; nessun segreto in tutta la storia (gitleaks 8.30.1, `--redact`) | +| `prove` | dopo `controlli` | in un contenitore Debian 13 (`node:24-trixie`) con Chromium della distribuzione, Xvfb, ffmpeg, NSIS, Node e la lingua italiana: tutta la soluzione compila con gli avvisi come errori e **tutte** le prove di `tests/Febe.Tests` passano senza saltarsi; quelle della categoria `SitoDiProva` passano anche con il seme dell'esecuzione. Risultati `.trx` fra gli artefatti (14 giorni) | +| `installatore` | dopo `prove` | `Febe.exe` in un file solo, `Febe-Setup--ci..exe` e lo zip portabile si costruiscono, ciascuno sotto i 100 MB; artefatti per 14 giorni | +| `immagine` | dopo `prove` | l'immagine si costruisce con buildx (dentro girano compilazione e prove), il contenitore parte **senza rete** come dice la guida e diventa «healthy», Chromium e la lingua italiana ci sono, si ferma entro 30 secondi; Trivy 0.75.0 non trova vulnerabilità CRITICAL con correzione disponibile. Solo dopo un push su `main`: pubblicazione `:main` e `:sha-` | + +La verifica gira a ogni push su qualunque ramo e a mano (Actions ▸ verifica ▸ Esegui, con un seme facoltativo). Su un +ramo un push nuovo annulla l'esecuzione in corso; su `main` ogni unione arriva fino in fondo. + +Altri flussi: `rilascio.yml` a ogni tag (vedi «Rilasci») e `pulizia.yml` ogni lunedì (vedi «Pulizia»). + +### Il mondo sintetico e il suo seme + +Le prove non contattano mai Instagram: usano il sito di prova (`tools/Febe.SitoDiProva`), con dati sintetici generati +da un seme. Nella CI le prove girano con il seme 13 e quelle della categoria `SitoDiProva` di nuovo con il seme +`1000 + numero dell'esecuzione`, scritto nel registro del passo «Semi del mondo sintetico». Per rifare un errore, in +locale o dalla CI a mano con quel seme: + +```sh +FEBE_SEME_PROVA= dotnet test tests/Febe.Tests --filter "TestCategory=SitoDiProva" +``` + +### Segreti e variabili + +- `REGISTRY_TOKEN` (segreto del repository): token di Alberto con «package: read and write». Senza, `verifica` e + `rilascio` costruiscono, provano e scansionano l'immagine ma non la pubblicano, con un avviso, e restano verdi. +- `REGISTRY` (variabile, facoltativa): il registro come lo raggiunge il runner (`192.168.30.23:3000`); se manca si usa + l'host dell'indirizzo del server Gitea. +- Le credenziali vanno nella configurazione del client Docker del lavoro, mai nel demone, e si tolgono alla fine. + Nessun flusso stampa segreti; `PipelineTests` lo controlla a ogni esecuzione. +- I segreti sono leggibili da qualunque flusso di questo repository, su qualunque ramo: chi può fare push può leggerli. + Per questo il permesso di scrittura sul repository resta ad Alberto e agli account di cui si fida. + +## Registro dei container: le etichette + +Sul registro di Gitea, `192.168.30.23:3000/alby96/febe`: + +| Etichetta | Chi la crea | Quando cambia | Per che cosa | +|---|---|---|---| +| `:latest` | `rilascio`, solo versioni senza trattino | a ogni rilascio stabile | Unraid e Docker Compose | +| `:X.Y.Z` | `rilascio` (anche `X.Y.Z-rc.1` per un'anteprima) | mai | una versione precisa, per tornare indietro | +| `:main` | `verifica`, dopo ogni unione in `main` | a ogni unione (mai all'indietro) | provare `main` su un server di prova; non per l'archivio vero | +| `:sha-<7 caratteri>` | `verifica`, dopo ogni unione in `main` | mai | un commit preciso di `main` | + +Ogni immagine della CI porta le etichette Docker `febe.ci.workflow`, `febe.ci.run`, `febe.ci.ref` e `febe.ci.commit`, +oltre a quelle OCI del Dockerfile: da un'immagine si risale all'esecuzione e al commit. Le `:sha-` si accumulano: una +regola di pulizia dei pacchetti (Impostazioni ▸ Pacchetti ▸ Regole di pulizia) può tenere sempre `latest`, `main` e +le versioni e togliere le `sha-.*` più vecchie di 30 giorni. + +## Pulizia + +Il demone Docker è condiviso con gli altri progetti: la CI di Febe toglie solo ciò che porta i suoi segni (etichetta +`febe.ci.run`, repository locale `febe-ci`, builder `febe-ci-`), più le immagini senza nome più vecchie di +72 ore (`.gitea/scripts/pulizia-docker.sh`). + +| Quando | Che cosa si toglie | +|---|---| +| alla fine di ogni lavoro «immagine», sempre | il contenitore di prova con i suoi volumi anonimi, l'immagine provata, il builder buildx dell'esecuzione con la sua cache, l'archivio dell'immagine, le credenziali del registro | +| all'inizio di ogni lavoro «immagine» | i resti di esecuzioni interrotte più vecchi di 90 minuti (un lavoro dura al massimo 60 minuti) e di un tentativo precedente della stessa esecuzione | +| ogni lunedì e a mano (`pulizia.yml`) | gli stessi resti, l'immagine `febe:ci` del vecchio flusso se nessuno la usa, le immagini senza nome più vecchie di 72 ore | +| mai | immagini, contenitori e volumi degli altri progetti; la cache di costruzione del demone; i volumi con un nome; le immagini col nome del registro | + +## Rilievi di sicurezza + +- **gitleaks** (lavoro `controlli`). Un segreto vero si **revoca subito** (gettone di Telegram da BotFather, token di + Gitea dalle impostazioni dell'utente) e se ne crea uno nuovo: toglierlo dalla storia non basta, perché qualcuno può + averlo già. Solo dopo, se serve, si riscrive la storia, d'accordo con Alberto. Un falso allarme (un dato di prova + finto, già controllato) si toglie aggiungendo la sua impronta («Fingerprint», nel registro del lavoro o nel + rapporto `rapporto-gitleaks`) a `.gitleaksignore`, con un commento sulla riga sopra: che cos'è, chi l'ha + controllato, quando. Mai disattivare una regola. +- **Trivy** (lavoro `immagine`, anche nel rilascio). Una vulnerabilità CRITICAL con correzione disponibile ferma il + lavoro e l'immagine non si pubblica. Che cosa fare: per un pacchetto di Debian di solito basta rilanciare (il + Dockerfile applica gli aggiornamenti della distribuzione); per una dipendenza .NET si aggiorna la sua versione in + `Directory.Packages.props` (una dipendenza nuova va chiesta ad Alberto); per il runtime .NET si ricostruisce con + l'SDK aggiornato. Le HIGH, e le CRITICAL ancora senza correzione, non fermano nulla ma si guardano nel rapporto + `sicurezza-immagine` (`trivy.json`) e, se riguardano ciò che Febe usa, diventano una segnalazione. Un'eccezione si + scrive solo in `.trivyignore`, alla radice: l'identificativo con una scadenza (`CVE-AAAA-NNNN exp:AAAA-MM-GG`, al + massimo 90 giorni) e, sulla riga sopra, il motivo e chi l'ha deciso. +- Strumenti: gitleaks e Trivy sono gli unici strumenti esterni della CI, approvati da Alberto, e girano solo nella + CI. Si aggiornano cambiando versione e impronta SHA-256 in `.gitea/scripts/strumento.sh`, in una richiesta di + unione con una riga in `docs/decisioni.md`, preferendo versioni uscite da almeno due settimane. + +## Rilasci + +1. In un ramo `rilascio/X.Y.Z`: `` in `Directory.Build.props`, la sezione `## X.Y.Z` di `CHANGELOG.md` (è il + testo delle note della release), `docs/stato.md`. Richiesta di unione, verifica verde, unione. +2. Sul commit di unione in `main`: `git tag -a vX.Y.Z -m "Febe X.Y.Z"` e `git push origin vX.Y.Z`. +3. `rilascio.yml` controlla che il tag coincida con ``, rifà le prove, costruisce installatore e zip, + costruisce, prova e scansiona l'immagine, la pubblica come `:X.Y.Z` (e `:latest` se la versione non ha trattini) e + crea la release con installatore, zip, modello di Unraid e archivio per Compose. +4. Un'anteprima è `vX.Y.Z-rc.N`: stessa strada, `:latest` non si sposta e la release è segnata come anteprima (come + ogni versione `0.x`). +5. Se manca `REGISTRY_TOKEN` la release esce senza immagine e lo dice; aggiunto il segreto, si rilancia il flusso del + tag e le note si correggono. + +## Correzioni urgenti + +- Se `main` contiene solo ciò che si vuole rilasciare: ramo `urgente/` da `main`, richiesta di unione con la + verifica verde come sempre (nessuna scorciatoia), poi un rilascio di correzione (`X.Y.Z+1`) come sopra. +- Se `main` contiene già lavoro da non rilasciare: ramo `rilascio/X.Y` dal tag della versione in uso, la correzione con + `git cherry-pick` (o scritta lì), `` a `X.Y.Z+1`, tag `vX.Y.Z+1` su quel ramo (il rilascio parte da + qualunque tag); poi la stessa correzione entra in `main` con la sua richiesta di unione. + +## Che cosa solo la prima esecuzione vera può provare + +Qui non ci sono runner né demone Docker: i flussi sono stati controllati come testo (struttura, espressioni, `bash -n` +di ogni blocco `run`), gli script con un client Docker finto. Restano da vedere alla prima esecuzione: il contenitore +`node:24-trixie` con le azioni dentro; le prove con il browser nel contenitore (nessuna saltata); `upload-artifact@v3` +con `retention-days`; la concorrenza; il builder buildx con il nome dell'esecuzione; la prova del contenitore senza +rete fino a «healthy»; il download e la scansione di Trivy (e se trova CRITICAL da correggere); gitleaks sulla storia; +la pubblicazione su `main` con il segreto; la pulizia settimanale sul demone vero. -- 2.54.1 From f243118f362814485eba83a78dfc8bbd4eebe768 Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Tue, 20 Oct 2026 11:08:41 +0200 Subject: [PATCH 09/17] =?UTF-8?q?CI:=20gitleaks=20sulla=20storia=20del=20c?= =?UTF-8?q?ommit=20verificato=20e=20pi=C3=B9=20memoria=20per=20Chromium?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit gitleaks leggeva i commit di tutti i rami scaricati: un rilievo su un ramo avrebbe fermato anche tutti gli altri. Ora legge ogni commit da cui discende quello verificato, e ogni ramo si controlla al suo push (main a ogni unione). Il contenitore delle prove ha 1 GB di memoria condivisa invece dei 64 MB predefiniti, che il Chromium senza finestra delle prove dell'interfaccia può esaurire. Co-Authored-By: Claude Opus 5.5 --- .gitea/scripts/segreti.sh | 12 ++++++------ .gitea/workflows/verifica.yml | 4 +++- docs/decisioni.md | 2 +- 3 files changed, 10 insertions(+), 8 deletions(-) diff --git a/.gitea/scripts/segreti.sh b/.gitea/scripts/segreti.sh index 0882922..f4df3f4 100755 --- a/.gitea/scripts/segreti.sh +++ b/.gitea/scripts/segreti.sh @@ -1,8 +1,8 @@ #!/usr/bin/env bash -# Cerca segreti (gettoni, chiavi, password) in tutta la storia del repository con gitleaks, a versione fissa -# (strumento.sh): ogni commit di ogni ramo e tag scaricato, non solo l'ultimo. Un segreto non compare mai per intero: -# --redact lo sostituisce con REDACTED nel registro e nel rapporto, e qui si stampano solo regola, file, riga, commit -# e impronta del rilievo. +# Cerca segreti (gettoni, chiavi, password) con gitleaks, a versione fissa (strumento.sh), in tutta la storia del +# commit verificato: ogni commit da cui discende, non solo l'ultimo. Ogni ramo si controlla al suo push (main a ogni +# unione), così un rilievo su un ramo non blocca gli altri. Un segreto non compare mai per intero: --redact lo +# sostituisce con REDACTED nel registro e nel rapporto, e qui si stampano solo regola, file, riga, commit e impronta. # # .gitea/scripts/segreti.sh [cartella del rapporto] # @@ -24,12 +24,12 @@ bash "$radice/.gitea/scripts/strumento.sh" gitleaks "$strumenti" mkdir -p "$rapporti" rapporto="$rapporti/gitleaks.json" -argomenti=(git "$radice" --redact --no-banner --no-color --exit-code 1 --log-level warn +argomenti=(git "$radice" --log-opts="--full-history HEAD" --redact --no-banner --no-color --exit-code 1 --log-level warn --report-format json --report-path "$rapporto") [[ -f "$radice/.gitleaks.toml" ]] && argomenti+=(--config "$radice/.gitleaks.toml") [[ -f "$radice/.gitleaksignore" ]] && argomenti+=(--gitleaks-ignore-path "$radice/.gitleaksignore") -commit=$(git -C "$radice" rev-list --all --count) +commit=$(git -C "$radice" rev-list --count HEAD) stato=0 "$strumenti/gitleaks" "${argomenti[@]}" || stato=$? if ((stato == 0)); then diff --git a/.gitea/workflows/verifica.yml b/.gitea/workflows/verifica.yml index 312bdd0..f316598 100644 --- a/.gitea/workflows/verifica.yml +++ b/.gitea/workflows/verifica.yml @@ -54,7 +54,7 @@ jobs: runs-on: ubuntu-latest timeout-minutes: 10 steps: - # Tutta la storia, di tutti i rami e i tag: gitleaks la legge commit per commit. + # Tutta la storia: gitleaks legge ogni commit da cui discende quello verificato. - uses: actions/checkout@v4 with: fetch-depth: 0 @@ -80,8 +80,10 @@ jobs: timeout-minutes: 60 # Debian 13 con Node 24: Chromium vero della distribuzione, come nell'immagine di Febe (su Ubuntu è uno snap), e # Node per le azioni e per la prova della pagina di accesso. + # Memoria condivisa più ampia dei 64 MB predefiniti: le prove dell'interfaccia usano un Chromium senza finestra. container: image: node:24-trixie + options: --shm-size=1g env: FEBE_CHROMIUM: /usr/bin/chromium SEME_RICHIESTO: ${{ gitea.event.inputs.seme }} diff --git a/docs/decisioni.md b/docs/decisioni.md index 01641a8..df8639d 100644 --- a/docs/decisioni.md +++ b/docs/decisioni.md @@ -230,7 +230,7 @@ Ogni scelta tecnica presa strada facendo, con data e motivo (specifica §15). | 2026-10-20 | Dockerfile: i file che il restore legge (soluzione, `Directory.*.props`, progetti) si trovano da soli in uno stadio `progetti` invece che da un elenco scritto a mano; lo stadio finale applica gli aggiornamenti della distribuzione (`apt-get upgrade`) prima di installare i pacchetti | Un progetto nuovo in `Febe.slnx` (come `tests/Febe.Tests.Windows`) non rompe più la costruzione dell'immagine e il restore resta in cache (BuildKit confronta il contenuto copiato); la scansione Trivy della CI non deve trovare correzioni di Debian già pubblicate ma non applicate perché l'immagine di base è più vecchia | | 2026-10-20 | Codice comune della CI in script di `.gitea/scripts/` (lanciati con `bash`), non in azioni composite locali | Uno script si prova con `bash -n` nel lavoro «controlli» e si lancia anche a mano; le azioni composite di act hanno comportamenti propri (ambiente, `if`, passi finali) che qui non si possono provare prima della prima esecuzione vera | | 2026-10-20 | Strumenti esterni della CI: solo gitleaks 8.30.1 e Trivy 0.75.0 (approvati da Alberto il 20 ottobre, solo nella CI), scaricati dalle release come binari e installati solo se l'impronta SHA-256 scritta in `strumento.sh` coincide (verificata sull'archivio, sul file `*_checksums.txt` e sull'impronta mostrata da GitHub); nessuna azione di terzi per eseguirli | `trivy-action` e `setup-trivy` furono compromesse a marzo 2026 (CVE-2026-33634, Trivy 0.69.4–0.69.6): un'etichetta si sposta, un'impronta no. Trivy 0.75.0 e non 0.76.0: almeno due settimane di vita prima di entrare nella CI | -| 2026-10-20 | gitleaks su tutta la storia (`fetch-depth: 0`, tutti i rami e i tag) con `--redact`; nessun `.gitleaks.toml` né elenco di eccezioni per ora: un'approssimazione locale delle 221 regole predefinite (le espressioni regolari pubblicate, applicate da uno script nostro: gitleaks non gira fuori dalla CI) non ha trovato rilievi veri, e i gettoni finti delle prove non hanno la forma completa che le regole cercano | Un falso allarme futuro si toglie con la sua impronta in `.gitleaksignore` e un commento accanto, mai disattivando una regola; un segreto vero si revoca prima di tutto (`docs/processo.md`) | +| 2026-10-20 | gitleaks su tutta la storia del commit verificato (`fetch-depth: 0`, ogni commit da cui discende; ogni ramo si controlla al suo push, così il rilievo di un ramo non blocca gli altri) con `--redact`; nessun `.gitleaks.toml` né elenco di eccezioni per ora: un'approssimazione locale delle 221 regole predefinite (le espressioni regolari pubblicate, applicate da uno script nostro: gitleaks non gira fuori dalla CI) non ha trovato rilievi veri, e i gettoni finti delle prove non hanno la forma completa che le regole cercano | Un falso allarme futuro si toglie con la sua impronta in `.gitleaksignore` e un commento accanto, mai disattivando una regola; un segreto vero si revoca prima di tutto (`docs/processo.md`) | | 2026-10-20 | Trivy sull'archivio dell'immagine provata (non dal demone): una vulnerabilità CRITICAL con correzione disponibile ferma il lavoro, le HIGH (e le CRITICAL senza correzione) si riportano nel registro e in `trivy.json` (artefatto di 14 giorni); eccezioni solo in `.trivyignore`, con motivo scritto e scadenza `exp:` | La regola chiesta da Alberto; scansionare l'archivio vuol dire scansionare proprio l'immagine provata, senza dipendere dal socket del demone | | 2026-10-20 | La prova del contenitore (`prova-immagine.sh`) gira sempre con `--network none`: Chromium, criteri, lingua, poi l'avvio come da guida (profilo seccomp, password casuale passata solo nell'ambiente del client) fino a «healthy», `febe --controllo-salute` e l'arresto entro 30 secondi | Regola 1: un'immagine appena costruita non deve poter raggiungere Instagram nemmeno per sbaglio; il controllo di salute passa dalla rete interna del contenitore | | 2026-10-20 | Ciò che la CI crea sul demone porta i suoi segni: etichette `febe.ci.workflow`, `febe.ci.run`, `febe.ci.ref`, `febe.ci.commit` sull'immagine e sui contenitori di prova, nome locale `febe-ci:`, builder `febe-ci-`. `pulizia-docker.sh` toglie solo quello (più le immagini senza nome oltre 72 ore): alla fine di ogni lavoro, all'inizio del lavoro successivo per i resti più vecchi di 90 minuti, e ogni settimana. Mai `system prune`, `builder prune`, `volume prune` | Il demone è lo stesso di Encelado, Mimante e degli altri progetti: la loro cache e le loro immagini non si toccano; un'esecuzione annullata non può pulire da sé, e un lavoro dura al massimo 60 minuti, quindi un resto di 90 minuti è certamente orfano | -- 2.54.1 From 5397d31e138ce15063a9e53c9b18c7d1f04f5837 Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Tue, 20 Oct 2026 11:10:04 +0200 Subject: [PATCH 10/17] CI: il seme delle prove si controlla prima di preparare l'ambiente Un seme chiesto a mano e sbagliato fermava il lavoro solo dopo l'installazione di Chromium e la compilazione; ora il passo dei semi viene subito dopo il checkout, e i minuti del runner non si sprecano. Co-Authored-By: Claude Opus 5.5 --- .gitea/workflows/verifica.yml | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/.gitea/workflows/verifica.yml b/.gitea/workflows/verifica.yml index f316598..862b077 100644 --- a/.gitea/workflows/verifica.yml +++ b/.gitea/workflows/verifica.yml @@ -91,16 +91,7 @@ jobs: steps: - uses: actions/checkout@v4 - - name: Chromium, Xvfb, ffmpeg, NSIS e lingua italiana - run: bash .gitea/scripts/ambiente-prove.sh - - - uses: actions/setup-dotnet@v4 - with: - dotnet-version: "10.0.x" - - - name: Compilazione di tutta la soluzione (avvisi = errori) - run: dotnet build Febe.slnx -c Release -nologo -warnaserror - + # Prima di tutto, così un seme chiesto a mano e sbagliato ferma subito il lavoro. - name: Semi del mondo sintetico id: semi run: | @@ -114,6 +105,16 @@ jobs: echo "Mondo sintetico: seme 13 per tutte le prove, seme $seme per la seconda passata (categoria SitoDiProva)." echo "Per rifarla: FEBE_SEME_PROVA=$seme dotnet test tests/Febe.Tests --filter \"TestCategory=SitoDiProva\"" + - name: Chromium, Xvfb, ffmpeg, NSIS e lingua italiana + run: bash .gitea/scripts/ambiente-prove.sh + + - uses: actions/setup-dotnet@v4 + with: + dotnet-version: "10.0.x" + + - name: Compilazione di tutta la soluzione (avvisi = errori) + run: dotnet build Febe.slnx -c Release -nologo -warnaserror + - name: Prove, seme 13 run: >- dotnet test tests/Febe.Tests -c Release --no-build --nologo -- 2.54.1 From 1bff405384e2ef7a4d1c58d8cabc15ac49dd92c4 Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Tue, 20 Oct 2026 12:04:32 +0200 Subject: [PATCH 11/17] CI: la pulizia sceglie solo per segni che nessuna immagine porta e non tocca mai un Febe vero MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Le etichette febe.ci.* stanno anche nelle immagini pubblicate (:main, :sha-, :X.Y.Z, :latest) e Docker le copia in ogni contenitore creato da quelle: un Febe vero avviato sullo stesso demone del runner le portava, e la pulizia lo toglieva con docker rm -f -v insieme ai suoi volumi anonimi. Con un rilascio rilanciato, che ha lo stesso numero di esecuzione dell'immagine pubblicata, succedeva subito, e l'immagine col nome del registro spariva con docker image rm -f. Ora le etichette dell'immagine dicono solo da dove viene. I contenitori di prova portano febe.ci.prova=, che mette solo prova-immagine.sh con docker run --label e che nessuna immagine porta, e devono chiamarsi febe-prova-; nei giri di pulizia (residui, settimanale) si tolgono solo se fermi, uno ancora acceso si segnala con il comando per toglierlo. Le immagini si tolgono solo per il nome locale febe-ci:, mai per identificativo né con -f: un nome del registro sulla stessa immagine resta, un'immagine in uso resta. I builder si tolgono solo se il contenitore gira l'immagine di buildkit. Le immagini senza nome restano alla pulizia oltre 72 ore. PipelineTests fa girare la pulizia contro un client Docker finto (tests/Febe.Tests/Packaging/fake-docker.sh) con un Febe vero acceso e uno fermo che portano le etichette delle loro immagini, e vieta i filtri sulle etichette di provenienza e la rimozione forzata delle immagini. Rilievo bloccante della revisione (pulizia-contenitori-non-ci). Co-Authored-By: Claude Opus 5.5 --- .gitea/scripts/costruisci-immagine.sh | 6 +- .gitea/scripts/prova-immagine.sh | 19 +- .gitea/scripts/pulizia-docker.sh | 172 ++++++++--- .gitea/workflows/pulizia.yml | 10 +- docs/decisioni.md | 2 +- docs/docker.md | 4 +- docs/processo.md | 26 +- tests/Febe.Tests/Packaging/PipelineTests.cs | 231 ++++++++++++++- tests/Febe.Tests/Packaging/fake-docker.sh | 302 ++++++++++++++++++++ 9 files changed, 707 insertions(+), 65 deletions(-) create mode 100644 tests/Febe.Tests/Packaging/fake-docker.sh diff --git a/.gitea/scripts/costruisci-immagine.sh b/.gitea/scripts/costruisci-immagine.sh index 5e58b96..a4cff5d 100755 --- a/.gitea/scripts/costruisci-immagine.sh +++ b/.gitea/scripts/costruisci-immagine.sh @@ -9,8 +9,10 @@ # parla mai con il registro (proverebbe HTTPS) # # Variabili richieste: BUILDER, VERSIONE, GIT_COMMIT, FLUSSO (verifica o rilascio), ESECUZIONE (gitea.run_id). -# Le etichette febe.ci.* dicono quale flusso, esecuzione, ramo e commit hanno costruito l'immagine; la pulizia -# (pulizia-docker.sh) riconosce da lì ciò che è della CI di Febe. +# Le etichette febe.ci.* dicono quale flusso, esecuzione, ramo e commit hanno costruito l'immagine. Non servono alla +# pulizia: stanno anche nelle immagini pubblicate e Docker le copia in ogni contenitore creato da quelle, anche in un +# Febe vero. Per questo qui non si mette mai febe.ci.prova, il segno dei soli contenitori di prova (prova-immagine.sh): +# lo controlla PipelineTests. set -euo pipefail modo="${1:?Indica il modo: archivio o pubblica.}" diff --git a/.gitea/scripts/prova-immagine.sh b/.gitea/scripts/prova-immagine.sh index 426fc75..87e3214 100755 --- a/.gitea/scripts/prova-immagine.sh +++ b/.gitea/scripts/prova-immagine.sh @@ -1,8 +1,11 @@ #!/usr/bin/env bash # Prova dell'immagine appena costruita, sul demone Docker del runner. Ogni contenitore gira SENZA RETE # (--network none): Febe non può raggiungere alcun sito, tanto meno Instagram (regola 1), e il controllo di salute -# passa dalla rete interna del contenitore. Ogni contenitore porta l'etichetta febe.ci.run dell'esecuzione: se il -# lavoro si interrompe, lo toglie pulizia-docker.sh. +# passa dalla rete interna del contenitore. +# Ogni contenitore porta l'etichetta febe.ci.prova=, messa qui con «docker run --label» e mai in +# un'immagine: è il segno con cui pulizia-docker.sh riconosce un contenitore di prova, insieme al nome +# febe-prova-. Le etichette febe.ci.* dell'immagine non bastano: Docker le copia in ogni contenitore, anche +# in un Febe vero avviato da un'immagine pubblicata. # # .gitea/scripts/prova-immagine.sh [esecuzione] # @@ -17,10 +20,18 @@ set -euo pipefail immagine="${1:?Indica quale immagine provare.}" esecuzione="${2:-${ESECUZIONE:-locale}}" radice="$(git rev-parse --show-toplevel)" -etichette=(--label "febe.ci.workflow=${FLUSSO:-prova}" --label "febe.ci.run=$esecuzione") +etichette=(--label "febe.ci.prova=$esecuzione") nome="febe-prova-$esecuzione" -togli() { docker rm -f -v "$nome" > /dev/null 2>&1 || true; } +# Toglie il contenitore di prova di questa esecuzione (anche quello di un tentativo precedente), ma solo se porta il +# segno della prova: un contenitore con lo stesso nome e senza segno resta, e «docker run --name» si ferma. +togli() { + local segno + segno=$(docker container inspect -f '{{index .Config.Labels "febe.ci.prova"}}' "$nome" 2> /dev/null) || return 0 + if [[ "$segno" == "$esecuzione" ]]; then + docker rm -f -v "$nome" > /dev/null 2>&1 || true + fi +} trap togli EXIT togli diff --git a/.gitea/scripts/pulizia-docker.sh b/.gitea/scripts/pulizia-docker.sh index dff35b0..9081122 100755 --- a/.gitea/scripts/pulizia-docker.sh +++ b/.gitea/scripts/pulizia-docker.sh @@ -1,24 +1,36 @@ #!/usr/bin/env bash # Pulizia di ciò che la CI di Febe lascia sul demone Docker del runner. È lo stesso demone che costruisce Encelado, -# Mimante e gli altri progetti di Alberto: si tocca solo ciò che porta i segni della CI di Febe, più le immagini senza -# nome («dangling») più vecchie di tre giorni. Mai altro, e mai la cache di costruzione del demone (è condivisa). +# Mimante e gli altri progetti di Alberto, e ci può girare anche un Febe vero: si tocca solo ciò che si può provare +# creato dalla CI, più le immagini senza nome («dangling») più vecchie di tre giorni. Mai altro, e mai la cache di +# costruzione del demone (è condivisa). # -# I segni della CI di Febe: -# - contenitori con l'etichetta febe.ci.run (le prove dell'immagine, fatte con --label); -# - immagini del repository locale «febe-ci» (le immagini provate; mai quelle col nome del registro) con la stessa -# etichetta, o senza nome ma con quell'etichetta; -# - builder buildx di nome febe-ci-: il contenitore buildx_buildkit_febe-ci-0 e il suo volume -# …_state, che contengono la cache di costruzione di quell'esecuzione; +# Le etichette febe.ci.workflow, febe.ci.run, febe.ci.ref e febe.ci.commit dicono da dove viene un'immagine, ma NON +# scelgono che cosa togliere: stanno anche nelle immagini pubblicate (:main, :sha-, :X.Y.Z, :latest), e Docker le copia +# in ogni contenitore creato da quelle immagini, quindi le porta anche un Febe vero. Ciò che si toglie si riconosce così: +# - contenitori di prova: l'etichetta febe.ci.prova=, che mette solo prova-immagine.sh con +# «docker run --label» e che nessuna immagine porta (lo controlla PipelineTests), E il nome esatto +# febe-prova- (gli altri contenitori della prova, senza nome, girano con --rm e Docker li +# toglie da sé appena finiscono); +# - immagini provate: il nome locale febe-ci:, tolto per nome, mai per identificativo e mai con -f. Se la +# stessa immagine ha anche un nome del registro, si toglie solo febe-ci:; se un contenitore la usa, resta; +# - builder buildx: il contenitore buildx_buildkit_febe-ci-0, con l'immagine moby/buildkit, e il suo +# volume …_state, che contengono la cache di costruzione di quell'esecuzione; # - l'immagine febe:ci lasciata dal vecchio flusso di verifica (prima del 20 ottobre 2026), se nessuno la usa. # -# pulizia-docker.sh esecuzione tutto ciò che ha creato l'esecuzione (alla fine del lavoro, sempre) +# pulizia-docker.sh esecuzione tutto ciò che ha creato l'esecuzione (all'inizio e alla fine del suo +# lavoro «immagine», sempre) # pulizia-docker.sh residui [minuti] i resti di esecuzioni interrotte, più vecchi di N minuti (predefinito 90: un # lavoro dura al massimo 60 minuti, quindi nessuno di essi è ancora vivo) # pulizia-docker.sh settimanale residui, febe:ci, immagini senza nome più vecchie di 72 ore (flusso «pulizia») # -# Un oggetto già sparito non è un errore: la pulizia si può ripetere. Nei modi «esecuzione» e «residui» un errore +# Nei modi «residui» e «settimanale» un contenitore di prova si toglie solo se è fermo. Uno ancora acceso dopo 90 minuti +# (il suo lavoro è stato ucciso proprio durante la prova del contenitore) resta dov'è: lo si segnala, con il comando per +# toglierlo a mano. I builder sono l'eccezione: sono sempre accesi e la loro cache se ne va solo togliendo il +# contenitore; si riconoscono dal nome esatto e dall'immagine di buildkit, mai da un'etichetta. +# +# Un oggetto già sparito non è un errore: la pulizia si può ripetere. Nei modi «esecuzione» e «residui» un problema # diventa un avviso (un lavoro verde non diventa rosso per la pulizia, che il flusso settimanale ripete); nel modo -# «settimanale» fa fallire il lavoro. +# «settimanale» fa fallire il lavoro, perché qualcuno lo guardi. set -uo pipefail modo="${1:-}" @@ -39,35 +51,67 @@ eta_minuti() { echo $((($(date -u +%s) - secondi) / 60)) } +# I contenitori di prova della CI, uno per riga «id nome»: l'etichetta febe.ci.prova (dell'esecuzione indicata, o di +# qualunque se il primo argomento è vuoto) e il nome esatto febe-prova-. Gli stati che seguono +# restringono la scelta (Docker li unisce in OR). Esce con 1 se Docker non risponde. +contenitori_di_prova() { + local run="$1" + shift + local stati=() stato elenco id nome valore + for stato in "$@"; do stati+=(--filter "status=$stato"); done + elenco=$(docker ps -a --no-trunc --filter "label=febe.ci.prova${run:+=$run}" "${stati[@]}" \ + --format '{{.ID}} {{.Names}} {{.Label "febe.ci.prova"}}') || return 1 + while read -r id nome valore; do + [[ -n "${id:-}" && "${valore:-}" =~ ^[0-9]+$ && "${nome:-}" == "febe-prova-$valore" ]] || continue + [[ -z "$run" || "$valore" == "$run" ]] || continue + echo "$id $nome" + done <<< "$elenco" +} + +# Toglie un contenitore con i suoi volumi anonimi. Con «forza» anche se è acceso: solo per quelli dell'esecuzione +# stessa e per i builder. togli_contenitore() { - local id="$1" nome - nome=$(docker inspect -f '{{.Name}}' "$id" 2>/dev/null) || return 0 - if docker rm -f -v "$id" > /dev/null 2>&1; then - echo " contenitore ${nome#/} tolto" - else - avviso "Non riesco a togliere il contenitore ${nome#/}." + local id="$1" nome="$2" opzioni=(-v) + [[ "${3:-}" == forza ]] && opzioni=(-f -v) + if docker rm "${opzioni[@]}" "$id" > /dev/null 2>&1; then + echo " contenitore $nome tolto" + elif docker container inspect "$id" > /dev/null 2>&1; then + avviso "Non riesco a togliere il contenitore $nome." fi } +# Toglie il nome locale febe-ci:, mai l'immagine per identificativo e mai con -f: se l'immagine ha anche un +# altro nome (del registro, per esempio) quello resta; se un contenitore la usa, resta tutto. togli_immagine() { - local id="$1" nomi - nomi=$(docker image inspect -f '{{join .RepoTags ", "}}' "$id" 2>/dev/null) || return 0 - if docker image rm -f "$id" > /dev/null 2>&1; then - echo " immagine ${nomi:-$id} tolta" + local riferimento="$1" nomi + [[ "$riferimento" =~ ^febe-ci:[0-9]+$ ]] || { avviso "Nome di immagine inatteso: «$riferimento»."; return 0; } + nomi=$(docker image inspect -f '{{len .RepoTags}}' "$riferimento" 2>/dev/null) || return 0 + if [[ "$nomi" == 1 && -n "$(docker ps -a -q --filter "ancestor=$riferimento")" ]]; then + echo " immagine $riferimento in uso da un contenitore: resta" + return 0 + fi + if docker image rm "$riferimento" > /dev/null 2>&1; then + echo " immagine $riferimento tolta" else - avviso "Non riesco a togliere l'immagine ${nomi:-$id}." + avviso "Non riesco a togliere l'immagine $riferimento." fi } # Un builder buildx della CI: prima con buildx (se questo client lo conosce), poi contenitore e volume per nome, perché -# un lavoro diverso da quello che l'ha creato non ne ha la configurazione. +# un lavoro diverso da quello che l'ha creato non ne ha la configurazione. Il contenitore si toglie solo se gira +# l'immagine di buildkit, e il volume solo quando il contenitore non c'è più. togli_builder() { local builder="$1" [[ "$builder" =~ ^febe-ci-[0-9]+$ ]] || { avviso "Nome di builder inatteso: «$builder»."; return 0; } docker buildx rm -f "$builder" > /dev/null 2>&1 && echo " builder $builder tolto" - local contenitore="buildx_buildkit_${builder}0" - if docker inspect "$contenitore" > /dev/null 2>&1; then - togli_contenitore "$contenitore" + local contenitore="buildx_buildkit_${builder}0" immagine + if immagine=$(docker container inspect -f '{{.Config.Image}}' "$contenitore" 2>/dev/null); then + if [[ "$immagine" != *moby/buildkit* ]]; then + avviso "Il contenitore $contenitore non è un builder buildx (immagine «$immagine»): resta." + return 0 + fi + togli_contenitore "$contenitore" "$contenitore" forza + docker container inspect "$contenitore" > /dev/null 2>&1 && return 0 fi if docker volume inspect "${contenitore}_state" > /dev/null 2>&1; then if docker volume rm -f "${contenitore}_state" > /dev/null 2>&1; then @@ -82,9 +126,15 @@ esecuzione() { local run="${1:-}" [[ "$run" =~ ^[0-9]+$ ]] || { echo "Indica il numero dell'esecuzione (gitea.run_id), non «$run»." >&2; exit 2; } echo "== Pulizia dell'esecuzione $run" - local id - for id in $(docker ps -a -q --filter "label=febe.ci.run=$run"); do togli_contenitore "$id"; done - for id in $(docker image ls -q --no-trunc --filter "label=febe.ci.run=$run" | sort -u); do togli_immagine "$id"; done + local elenco id nome + if elenco=$(contenitori_di_prova "$run"); then + while read -r id nome; do + [[ -n "${id:-}" ]] && togli_contenitore "$id" "$nome" forza + done <<< "$elenco" + else + avviso "Non riesco a elencare i contenitori di prova dell'esecuzione $run." + fi + togli_immagine "febe-ci:$run" togli_builder "febe-ci-$run" } @@ -92,21 +142,55 @@ residui() { local minuti="${1:-90}" [[ "$minuti" =~ ^[0-9]+$ ]] || { echo "I minuti devono essere un numero, non «$minuti»." >&2; exit 2; } echo "== Resti di esecuzioni interrotte, più vecchi di $minuti minuti" - local id nome - for id in $(docker ps -a -q --filter "label=febe.ci.run"); do - (($(eta_minuti "$(docker inspect -f '{{.Created}}' "$id" 2>/dev/null)") >= minuti)) && togli_contenitore "$id" - done - for id in $( { docker image ls -q --no-trunc --filter "reference=febe-ci" --filter "label=febe.ci.run" - docker image ls -q --no-trunc --filter "dangling=true" --filter "label=febe.ci.run"; } | sort -u); do - (($(eta_minuti "$(docker image inspect -f '{{.Created}}' "$id" 2>/dev/null)") >= minuti)) && togli_immagine "$id" - done - # Il filtro per nome di Docker cerca una parte del nome: il nome esatto si controlla qui. - while read -r id nome; do - [[ -n "${id:-}" ]] || continue - nome="${nome#/}" - [[ "$nome" =~ ^buildx_buildkit_(febe-ci-[0-9]+)0$ ]] || continue - (($(eta_minuti "$(docker inspect -f '{{.Created}}' "$id" 2>/dev/null)") >= minuti)) && togli_builder "${BASH_REMATCH[1]}" - done < <(docker ps -a --no-trunc --filter "name=buildx_buildkit_febe-ci-" --format '{{.ID}} {{.Names}}') + local elenco id nome eta riferimento + + # Contenitori di prova fermi: si tolgono. Senza -f: se nel frattempo uno ripartisse, Docker lo lascia stare. + if elenco=$(contenitori_di_prova "" exited created dead); then + while read -r id nome; do + [[ -n "${id:-}" ]] || continue + eta=$(eta_minuti "$(docker container inspect -f '{{.Created}}' "$id" 2>/dev/null)") + ((eta >= minuti)) && togli_contenitore "$id" "$nome" + done <<< "$elenco" + else + avviso "Non riesco a elencare i contenitori di prova fermi." + fi + + # Contenitori di prova ancora accesi: non si toccano, si segnalano. + if elenco=$(contenitori_di_prova "" running restarting paused); then + while read -r id nome; do + [[ -n "${id:-}" ]] || continue + eta=$(eta_minuti "$(docker container inspect -f '{{.Created}}' "$id" 2>/dev/null)") + if ((eta >= minuti)); then + avviso "Il contenitore di prova $nome è acceso da $eta minuti: il suo lavoro si è interrotto durante la prova. La pulizia non toglie contenitori accesi; se nessuna esecuzione lo usa più, toglilo a mano: docker rm -f -v $nome" + fi + done <<< "$elenco" + else + avviso "Non riesco a elencare i contenitori di prova accesi." + fi + + # Immagini provate: solo i nomi febe-ci:. + if elenco=$(docker image ls --filter "reference=febe-ci" --format '{{.Repository}}:{{.Tag}}'); then + while read -r riferimento; do + [[ "${riferimento:-}" =~ ^febe-ci:[0-9]+$ ]] || continue + eta=$(eta_minuti "$(docker image inspect -f '{{.Created}}' "$riferimento" 2>/dev/null)") + ((eta >= minuti)) && togli_immagine "$riferimento" + done <<< "$elenco" + else + avviso "Non riesco a elencare le immagini febe-ci." + fi + + # Builder buildx. Il filtro per nome di Docker cerca una parte del nome: il nome esatto si controlla qui. + if elenco=$(docker ps -a --no-trunc --filter "name=buildx_buildkit_febe-ci-" --format '{{.ID}} {{.Names}}'); then + while read -r id nome; do + [[ -n "${id:-}" ]] || continue + nome="${nome#/}" + [[ "$nome" =~ ^buildx_buildkit_(febe-ci-[0-9]+)0$ ]] || continue + eta=$(eta_minuti "$(docker container inspect -f '{{.Created}}' "$id" 2>/dev/null)") + ((eta >= minuti)) && togli_builder "${BASH_REMATCH[1]}" + done <<< "$elenco" + else + avviso "Non riesco a elencare i builder buildx." + fi } settimanale() { diff --git a/.gitea/workflows/pulizia.yml b/.gitea/workflows/pulizia.yml index 7f5b538..aaa8de7 100644 --- a/.gitea/workflows/pulizia.yml +++ b/.gitea/workflows/pulizia.yml @@ -2,10 +2,12 @@ # Docker del runner. # Ogni esecuzione di verifica e di rilascio toglie già ciò che crea; qui si toglie ciò che resta di esecuzioni # interrotte (annullate o scadute) e ciò che invecchia. Il demone è lo stesso di Encelado, Mimante e degli altri -# progetti di Alberto: si toccano solo oggetti con i segni della CI di Febe (etichetta febe.ci.run, repository locale -# febe-ci, builder febe-ci-) e le immagini senza nome più vecchie di 72 ore. Mai le immagini degli altri -# progetti, mai la cache di costruzione del demone, mai i volumi con un nome. Dettagli in .gitea/scripts/pulizia-docker.sh -# e in docs/processo.md, «Pulizia». +# progetti di Alberto, e ci può girare un Febe vero: si toccano solo i contenitori di prova fermi (etichetta +# febe.ci.prova e nome febe-prova-, mai le etichette febe.ci.* che un Febe vero eredita dall'immagine), i +# nomi locali febe-ci:, i builder febe-ci- e le immagini senza nome più vecchie di 72 ore. Mai +# le immagini degli altri progetti, mai la cache di costruzione del demone, mai i volumi con un nome. Un contenitore di +# prova ancora acceso si segnala e il lavoro diventa rosso. Dettagli in .gitea/scripts/pulizia-docker.sh e in +# docs/processo.md, «Pulizia». name: pulizia on: diff --git a/docs/decisioni.md b/docs/decisioni.md index df8639d..2a15cc7 100644 --- a/docs/decisioni.md +++ b/docs/decisioni.md @@ -233,7 +233,7 @@ Ogni scelta tecnica presa strada facendo, con data e motivo (specifica §15). | 2026-10-20 | gitleaks su tutta la storia del commit verificato (`fetch-depth: 0`, ogni commit da cui discende; ogni ramo si controlla al suo push, così il rilievo di un ramo non blocca gli altri) con `--redact`; nessun `.gitleaks.toml` né elenco di eccezioni per ora: un'approssimazione locale delle 221 regole predefinite (le espressioni regolari pubblicate, applicate da uno script nostro: gitleaks non gira fuori dalla CI) non ha trovato rilievi veri, e i gettoni finti delle prove non hanno la forma completa che le regole cercano | Un falso allarme futuro si toglie con la sua impronta in `.gitleaksignore` e un commento accanto, mai disattivando una regola; un segreto vero si revoca prima di tutto (`docs/processo.md`) | | 2026-10-20 | Trivy sull'archivio dell'immagine provata (non dal demone): una vulnerabilità CRITICAL con correzione disponibile ferma il lavoro, le HIGH (e le CRITICAL senza correzione) si riportano nel registro e in `trivy.json` (artefatto di 14 giorni); eccezioni solo in `.trivyignore`, con motivo scritto e scadenza `exp:` | La regola chiesta da Alberto; scansionare l'archivio vuol dire scansionare proprio l'immagine provata, senza dipendere dal socket del demone | | 2026-10-20 | La prova del contenitore (`prova-immagine.sh`) gira sempre con `--network none`: Chromium, criteri, lingua, poi l'avvio come da guida (profilo seccomp, password casuale passata solo nell'ambiente del client) fino a «healthy», `febe --controllo-salute` e l'arresto entro 30 secondi | Regola 1: un'immagine appena costruita non deve poter raggiungere Instagram nemmeno per sbaglio; il controllo di salute passa dalla rete interna del contenitore | -| 2026-10-20 | Ciò che la CI crea sul demone porta i suoi segni: etichette `febe.ci.workflow`, `febe.ci.run`, `febe.ci.ref`, `febe.ci.commit` sull'immagine e sui contenitori di prova, nome locale `febe-ci:`, builder `febe-ci-`. `pulizia-docker.sh` toglie solo quello (più le immagini senza nome oltre 72 ore): alla fine di ogni lavoro, all'inizio del lavoro successivo per i resti più vecchi di 90 minuti, e ogni settimana. Mai `system prune`, `builder prune`, `volume prune` | Il demone è lo stesso di Encelado, Mimante e degli altri progetti: la loro cache e le loro immagini non si toccano; un'esecuzione annullata non può pulire da sé, e un lavoro dura al massimo 60 minuti, quindi un resto di 90 minuti è certamente orfano | +| 2026-10-20 | Le etichette `febe.ci.workflow`, `febe.ci.run`, `febe.ci.ref`, `febe.ci.commit` dell'immagine dicono solo da dove viene; `pulizia-docker.sh` sceglie che cosa togliere da segni che nessuna immagine porta: contenitori di prova con l'etichetta `febe.ci.prova=` (messa solo da `docker run --label` in `prova-immagine.sh`) e il nome esatto `febe-prova-`; immagini solo per il nome locale `febe-ci:`, mai per identificativo né con `-f`; builder per nome esatto e immagine `moby/buildkit`. Alla fine di ogni lavoro tutto ciò dell'esecuzione; all'inizio del lavoro successivo e ogni settimana i resti più vecchi di 90 minuti, ma dei contenitori di prova solo quelli fermi (uno acceso si segnala); più le immagini senza nome oltre 72 ore. Mai `system prune`, `builder prune`, `volume prune`. `PipelineTests` fa girare la pulizia contro un client Docker finto con un Febe vero acceso e uno fermo | Docker copia le etichette dell'immagine in ogni contenitore: un Febe vero avviato da `:main`, `:X.Y.Z` o `:latest` sullo stesso demone porta `febe.ci.run`, e un rilascio rilanciato ha lo stesso numero di esecuzione dell'immagine pubblicata (rilievo bloccante della revisione). Il demone è lo stesso di Encelado, Mimante e degli altri progetti; un lavoro dura al massimo 60 minuti, quindi un resto di 90 minuti è orfano; i builder sono sempre accesi e la loro cache se ne va solo con il contenitore | | 2026-10-20 | `verifica` a ogni push su qualunque ramo (`branches: ["**"]`, quindi mai sui tag) e a mano (`workflow_dispatch`, con un seme facoltativo); niente `pull_request` | In Gitea i controlli di una richiesta di unione sono gli stati del suo ultimo commit, che il push del ramo ha già verificato; `pull_request` girerebbe sullo stesso commit (`refs/pull/N/head`, non un'unione di prova) e sull'unico runner raddoppierebbe tutto. Niente richieste da fork: un solo autore, rami nello stesso repository | | 2026-10-20 | Concorrenza di `verifica`: su un ramo l'esecuzione nuova annulla quella in corso; su main ogni commit ha il suo gruppo e nessuna si annulla; `:main` si sposta solo se main è ancora a quel commit | Il runner fa un lavoro alla volta; ogni unione in main deve arrivare a pubblicare la sua `:sha-`, e un'esecuzione in ritardo non deve riportare indietro `:main`. Gitea 28 valuta le espressioni di `concurrency.group` e `cancel-in-progress` (`services/actions/concurrency.go`) | | 2026-10-20 | Lavoro «prove» nel contenitore `node:24-trixie` (Debian 13 con Node 24), con Chromium, Xvfb, ffmpeg, NSIS e la lingua italiana installati a ogni esecuzione; il riepilogo non ammette prove saltate; seconda passata della categoria `SitoDiProva` con il seme 1000 + numero dell'esecuzione, o quello chiesto a mano | Su Ubuntu Chromium è uno snap; le azioni JavaScript girano dentro il contenitore del lavoro e vogliono Node; un'immagine di CI costruita da noi non può fare da contenitore del lavoro, perché act_runner la scaricherebbe da un registro e quello di casa è in HTTP; nella CI una prova saltata vuol dire un ambiente rotto, non una prova superata | diff --git a/docs/docker.md b/docs/docker.md index 87ad929..37a82e4 100644 --- a/docs/docker.md +++ b/docs/docker.md @@ -38,7 +38,9 @@ Sul registro di Gitea, `192.168.30.23:3000/alby96/febe`: Ogni immagine costruita dalla CI dice da dove viene, nelle etichette Docker `febe.ci.workflow`, `febe.ci.run`, `febe.ci.ref` e `febe.ci.commit` e in `org.opencontainers.image.version` e `.revision`: -`docker inspect --format '{{json .Config.Labels}}' `. +`docker inspect --format '{{json .Config.Labels}}' `. Docker copia queste etichette anche nel contenitore di +Febe: la pulizia della CI non le usa per scegliere che cosa togliere, quindi un Febe sullo stesso Docker del runner +della CI non viene mai toccato. ## Volumi diff --git a/docs/processo.md b/docs/processo.md index e7fbac4..5b59756 100644 --- a/docs/processo.md +++ b/docs/processo.md @@ -130,22 +130,36 @@ Sul registro di Gitea, `192.168.30.23:3000/alby96/febe`: | `:sha-<7 caratteri>` | `verifica`, dopo ogni unione in `main` | mai | un commit preciso di `main` | Ogni immagine della CI porta le etichette Docker `febe.ci.workflow`, `febe.ci.run`, `febe.ci.ref` e `febe.ci.commit`, -oltre a quelle OCI del Dockerfile: da un'immagine si risale all'esecuzione e al commit. Le `:sha-` si accumulano: una +oltre a quelle OCI del Dockerfile: da un'immagine si risale all'esecuzione e al commit. Docker le copia in ogni +contenitore creato dall'immagine, anche in un Febe vero: per questo la pulizia non le usa mai per scegliere che cosa +togliere (vedi «Pulizia»). Le `:sha-` si accumulano: una regola di pulizia dei pacchetti (Impostazioni ▸ Pacchetti ▸ Regole di pulizia) può tenere sempre `latest`, `main` e le versioni e togliere le `sha-.*` più vecchie di 30 giorni. ## Pulizia -Il demone Docker è condiviso con gli altri progetti: la CI di Febe toglie solo ciò che porta i suoi segni (etichetta -`febe.ci.run`, repository locale `febe-ci`, builder `febe-ci-`), più le immagini senza nome più vecchie di -72 ore (`.gitea/scripts/pulizia-docker.sh`). +Il demone Docker è condiviso con gli altri progetti, e ci può girare anche un Febe vero, avviato da un'immagine che la +CI ha pubblicato e che quindi porta le sue etichette `febe.ci.*`. La CI di Febe toglie solo ciò che può provare suo +(`.gitea/scripts/pulizia-docker.sh`): + +- contenitori di prova: l'etichetta `febe.ci.prova=`, che mette solo `prova-immagine.sh` con + `docker run --label` e che nessuna immagine porta (lo controlla `PipelineTests`), e insieme il nome esatto + `febe-prova-`; +- immagini provate: il nome locale `febe-ci:`, tolto per nome, mai per identificativo e mai con `-f`. Se la + stessa immagine ha anche un nome del registro, quello resta; se un contenitore la usa, resta tutto; +- builder buildx: il contenitore `buildx_buildkit_febe-ci-0` con l'immagine `moby/buildkit` e il suo volume + `…_state`; +- più le immagini senza nome più vecchie di 72 ore che nessun contenitore usa. + +`PipelineTests` fa girare la pulizia contro un demone finto (`tests/Febe.Tests/Packaging/fake-docker.sh`) con un Febe +vero acceso e uno fermo che portano le etichette delle loro immagini: non li deve toccare. | Quando | Che cosa si toglie | |---|---| | alla fine di ogni lavoro «immagine», sempre | il contenitore di prova con i suoi volumi anonimi, l'immagine provata, il builder buildx dell'esecuzione con la sua cache, l'archivio dell'immagine, le credenziali del registro | -| all'inizio di ogni lavoro «immagine» | i resti di esecuzioni interrotte più vecchi di 90 minuti (un lavoro dura al massimo 60 minuti) e di un tentativo precedente della stessa esecuzione | +| all'inizio di ogni lavoro «immagine» | i resti di esecuzioni interrotte più vecchi di 90 minuti (un lavoro dura al massimo 60 minuti): contenitori di prova **fermi**, immagini `febe-ci:`, builder; e ciò che ha lasciato un tentativo precedente della stessa esecuzione | | ogni lunedì e a mano (`pulizia.yml`) | gli stessi resti, l'immagine `febe:ci` del vecchio flusso se nessuno la usa, le immagini senza nome più vecchie di 72 ore | -| mai | immagini, contenitori e volumi degli altri progetti; la cache di costruzione del demone; i volumi con un nome; le immagini col nome del registro | +| mai | immagini, contenitori e volumi degli altri progetti; un contenitore Febe che non sia di prova, anche se porta le etichette `febe.ci.*`; un contenitore di prova ancora acceso di un'altra esecuzione (si segnala con un avviso e il comando per toglierlo: il flusso settimanale diventa rosso); la cache di costruzione del demone; i volumi con un nome; le immagini col nome del registro | ## Rilievi di sicurezza diff --git a/tests/Febe.Tests/Packaging/PipelineTests.cs b/tests/Febe.Tests/Packaging/PipelineTests.cs index 06e228e..0f11e54 100644 --- a/tests/Febe.Tests/Packaging/PipelineTests.cs +++ b/tests/Febe.Tests/Packaging/PipelineTests.cs @@ -1,3 +1,4 @@ +using System.Diagnostics; using System.Text.RegularExpressions; using Febe.Tests.Desktop.Support; using Febe.Tests.Support; @@ -9,13 +10,16 @@ namespace Febe.Tests.Packaging; /// text: the rules that must survive later edits. Every push of every branch is verified and nothing else triggers /// it twice; the tests run only through tests/Febe.Tests, with the browser, and again with the seed of the run; the /// image is published only from main and never as :latest; credentials are never printed; the external tools are -/// pinned and checked; the cleanup touches only what the CI of Febe made; the tried container never has a network. +/// pinned and checked; the cleanup touches only what the CI of Febe made, never a real Febe on the same daemon; the +/// tried container never has a network. /// [TestClass] public sealed partial class PipelineTests { private static readonly string[] Jobs = ["controlli", "prove", "installatore", "immagine"]; + public TestContext TestContext { get; set; } = null!; + [TestMethod] public void EveryPushOfEveryBranchIsVerifiedOnceAndTagsAreLeftToTheRelease() { @@ -166,9 +170,24 @@ public sealed partial class PipelineTests Assert.HasCount(1, ImagePrune().Matches(cleanup), "only dangling images, older than three days"); StringAssert.Contains(cleanup, "docker image prune -f --filter \"until=72h\""); - StringAssert.Contains(cleanup, "--filter \"label=febe.ci.run=$run\""); StringAssert.Contains(cleanup, "^buildx_buildkit_(febe-ci-[0-9]+)0$"); + // The febe.ci.* labels of the image are in every container made from a published image, a real Febe too: they + // never choose what goes. Containers are chosen by febe.ci.prova (and their exact name), the builders by name, + // and an image only by its local name febe-ci:, never by id and never forced. + Assert.IsFalse(ProvenanceLabelFilter().IsMatch(cleanup), "the cleanup filters on febe.ci.prova only"); + foreach (var line in cleanup.Split('\n').Where(l => l.Contains("docker ps", StringComparison.Ordinal))) + { + Assert.IsTrue( + line.Contains("--filter \"label=febe.ci.prova", StringComparison.Ordinal) || line.Contains("--filter \"name=buildx_buildkit_febe-ci-\"", StringComparison.Ordinal) || line.Contains("--filter \"ancestor=", StringComparison.Ordinal), + $"«{line.Trim()}» lists containers without the mark of the tried container"); + } + + StringAssert.Contains(cleanup, "\"febe-prova-$valore\"", "the name must match the mark"); + StringAssert.Contains(cleanup, "contenitori_di_prova \"\" exited created dead", "the sweeps take only stopped tried containers"); + Assert.IsFalse(ForcedImageRemoval().IsMatch(cleanup), "an image is never removed by force"); + StringAssert.Contains(cleanup, "[[ \"$riferimento\" =~ ^febe-ci:[0-9]+$ ]]"); + var weekly = Workflow("pulizia.yml"); StringAssert.Contains(weekly, "schedule:"); StringAssert.Contains(weekly, "workflow_dispatch:"); @@ -176,7 +195,7 @@ public sealed partial class PipelineTests } [TestMethod] - public void TheTriedContainerNeverHasANetwork() + public void TheTriedContainerNeverHasANetworkAndAlwaysCarriesTheMarkNoImageHas() { var smoke = Code(Script("prova-immagine.sh")); var runs = DockerRun().Matches(smoke); @@ -184,7 +203,207 @@ public sealed partial class PipelineTests foreach (Match run in runs) { StringAssert.Contains(run.Value, "--network none", "rule 1: the image under test cannot reach any site"); + StringAssert.Contains(run.Value, "\"${etichette[@]}\"", "every tried container carries the mark the cleanup looks for"); } + + StringAssert.Contains(smoke, "etichette=(--label \"febe.ci.prova=$esecuzione\")"); + StringAssert.Contains(smoke, "nome=\"febe-prova-$esecuzione\""); + + // Docker copies the labels of an image into every container made from it: the mark must never be in an image. + Assert.DoesNotContain("febe.ci.prova", Code(Script("costruisci-immagine.sh"))); + Assert.DoesNotContain("febe.ci.prova", Code(Read(Repository.PathOf("docker", "Dockerfile")))); + } + + [TestMethod] + [Timeout(180_000, CooperativeCancellation = true)] + public async Task OnADaemonSharedWithARealFebeTheCleanupTakesOnlyWhatTheCiMade() + { + var script = CiPath("scripts", "pulizia-docker.sh"); + var bash = BashForScripts(); + if (bash is null) + { + Assert.Inconclusive("Manca bash (su Windows serve Git Bash): la prova della pulizia su un demone finto si salta."); + } + + Assert.IsTrue(File.Exists(script)); + + // At the start or the end of a run (a release run again keeps its id, so the published image has the same + // febe.ci.run as the run): only the tried container, the local name and the builder of that run. + var run = await RunCleanupAsync(bash, FakeDaemon.Full, "esecuzione", "777"); + Assert.AreEqual(0, run.Code, run.Report); + Assert.DoesNotContain("::warning::", run.Output, run.Report); + CollectionAssert.AreEquivalent(FakeDaemon.ContainersOf(FakeDaemon.Full).Except(["c-prova-777", "b-777"]).ToList(), run.Containers, run.Report); + CollectionAssert.AreEquivalent(FakeDaemon.ImagesWithout777(), run.Images, run.Report); + CollectionAssert.AreEquivalent(FakeDaemon.Volumes.Except(["buildx_buildkit_febe-ci-7770_state"]).ToList(), run.Volumes, run.Report); + + // Leftovers of interrupted runs: stopped tried containers, febe-ci images and builders older than 90 minutes. + var leftovers = await RunCleanupAsync(bash, FakeDaemon.Full, "residui", "90"); + Assert.AreEqual(0, leftovers.Code, leftovers.Report); + CollectionAssert.AreEquivalent(FakeDaemon.ContainersOf(FakeDaemon.Full).Except(["c-prova-555", "b-vecchio"]).ToList(), leftovers.Containers, leftovers.Report); + CollectionAssert.AreEquivalent(FakeDaemon.ImagesWithout777("img-ci555"), leftovers.Images, leftovers.Report); + CollectionAssert.AreEquivalent(FakeDaemon.Volumes.Except(["buildx_buildkit_febe-ci-4560_state"]).ToList(), leftovers.Volumes, leftovers.Report); + StringAssert.Contains(leftovers.Output, "::warning::Il contenitore di prova febe-prova-556 è acceso", "a running tried container is reported, not removed"); + StringAssert.Contains(leftovers.Output, "::warning::Il contenitore buildx_buildkit_febe-ci-4570 non è un builder buildx", leftovers.Report); + + // Every week, on a daemon without anything odd: the same, the old febe:ci and the dangling images older than + // 72 hours that no container uses. Green. + var weekly = await RunCleanupAsync(bash, FakeDaemon.Clean, "settimanale"); + Assert.AreEqual(0, weekly.Code, weekly.Report); + CollectionAssert.AreEquivalent(FakeDaemon.ContainersOf(FakeDaemon.Clean).Except(["c-prova-555", "b-vecchio"]).ToList(), weekly.Containers, weekly.Report); + CollectionAssert.AreEquivalent(FakeDaemon.ImagesWithout777("img-ci555", "img-ci556", "img-legacy", "img-penzolante-vecchia"), weekly.Images, weekly.Report); + + // With something left for a person to look at, the weekly cleanup goes red. + var noticed = await RunCleanupAsync(bash, FakeDaemon.Full, "settimanale"); + Assert.AreEqual(1, noticed.Code, noticed.Report); + CollectionAssert.Contains(noticed.Containers, "c-prova-556"); + CollectionAssert.Contains(noticed.Containers, "c-febe-vero"); + } + + /// + /// The daemon the cleanup runs against in + /// (format in fake-docker.sh). A real Febe started from :latest and one from :main carry the febe.ci.* labels of + /// their images, as Docker gives them; the image of the release also has the local name of run 777. + /// + private static class FakeDaemon + { + public static readonly string[] Full = + [ + "c-febe-vero|febe|running|43200|192.168.30.23:3000/alby96/febe:latest|img-rilascio|febe.ci.workflow=rilascio,febe.ci.run=777,febe.ci.ref=v0.1.0", + "c-febe-fermo|febe-main|exited|43200|192.168.30.23:3000/alby96/febe:main|img-main|febe.ci.workflow=verifica,febe.ci.run=888", + "c-febe-antico|febe-antico|exited|20000|img-penzolante-in-uso|img-penzolante-in-uso|febe.ci.run=111", + "c-prova-777|febe-prova-777|running|5|febe-ci:777|img-rilascio|febe.ci.workflow=rilascio,febe.ci.run=777,febe.ci.prova=777", + "c-prova-555|febe-prova-555|exited|300|febe-ci:555|img-ci555|febe.ci.run=555,febe.ci.prova=555", + "c-prova-556|febe-prova-556|running|300|febe-ci:556|img-ci556|febe.ci.run=556,febe.ci.prova=556", + "c-prova-557|febe-prova-557|exited|10|febe-ci:557|img-ci557|febe.ci.run=557,febe.ci.prova=557", + "c-nome-strano|febe-prova-558-bis|exited|300|encelado:latest|img-encelado|febe.ci.prova=558", + "c-segno-diverso|febe-prova-559|exited|300|encelado:latest|img-encelado|febe.ci.prova=560", + "c-senza-segno|febe-prova-561|exited|300|encelado:latest|img-encelado|", + "c-encelado|encelado|exited|5000|encelado:latest|img-encelado|", + "b-vecchio|buildx_buildkit_febe-ci-4560|running|300|moby/buildkit:buildx-stable-1|img-buildkit|", + "b-finto|buildx_buildkit_febe-ci-4570|running|300|encelado:latest|img-encelado|", + "b-giovane|buildx_buildkit_febe-ci-7890|running|10|moby/buildkit:buildx-stable-1|img-buildkit|", + "b-altro|altro_buildx_buildkit_febe-ci-10|running|300|moby/buildkit:buildx-stable-1|img-buildkit|", + "b-777|buildx_buildkit_febe-ci-7770|running|20|moby/buildkit:buildx-stable-1|img-buildkit|", + ]; + + /// The same daemon without the running tried container and the builder that is not one. + public static readonly string[] Clean = [.. Full.Where(c => !c.StartsWith("c-prova-556|", StringComparison.Ordinal) && !c.StartsWith("b-finto|", StringComparison.Ordinal))]; + + public static readonly string[] Images = + [ + "img-rilascio|192.168.30.23:3000/alby96/febe:latest,192.168.30.23:3000/alby96/febe:0.1.0,febe-ci:777|43200|febe.ci.run=777", + "img-main|192.168.30.23:3000/alby96/febe:main|43200|febe.ci.run=888", + "img-ci555|febe-ci:555|300|febe.ci.run=555", + "img-ci556|febe-ci:556|300|febe.ci.run=556", + "img-ci557|febe-ci:557|10|febe.ci.run=557", + "img-penzolante-febe||300|febe.ci.run=999", + "img-penzolante-vecchia||6000|", + "img-penzolante-in-uso||20000|febe.ci.run=111", + "img-encelado|encelado:latest|5000|", + "img-buildkit|moby/buildkit:buildx-stable-1|50000|", + "img-legacy|febe:ci|6000|", + ]; + + public static readonly string[] Volumes = + [ + "buildx_buildkit_febe-ci-4560_state", + "buildx_buildkit_febe-ci-4570_state", + "buildx_buildkit_febe-ci-7890_state", + "buildx_buildkit_febe-ci-7770_state", + "encelado-dati", + ]; + + public static List ContainersOf(string[] world) => [.. world.Select(c => c[..c.IndexOf('|', StringComparison.Ordinal)])]; + + /// + /// «id|names» of each image once febe-ci:777 is gone (the image of the release keeps its registry names), without + /// the images given. + /// + public static List ImagesWithout777(params string[] gone) => + [ + .. Images + .Select(i => string.Join('|', i.Split('|')[..2]).Replace(",febe-ci:777", string.Empty, StringComparison.Ordinal)) + .Where(i => !gone.Contains(i[..i.IndexOf('|', StringComparison.Ordinal)])), + ]; + } + + private sealed record CleanupRun(int Code, string Output, string Errors, List Containers, List Images, List Volumes) + { + public string Report => $"codice {Code}\n{Output}\n{Errors}"; + } + + /// + /// pulizia-docker.sh against the fake daemon. DOCKER_HOST points nowhere: even if a real docker client came first on + /// the PATH it could not reach a daemon, and the test fails because the fake recorded no call. + /// + private async Task RunCleanupAsync(string bash, string[] containers, params string[] arguments) + { + using var world = new TempFolder("febe-pulizia"); + var bin = world.Combine("bin"); + Directory.CreateDirectory(bin); + var docker = Path.Combine(bin, "docker"); + File.Copy(Repository.PathOf("tests", "Febe.Tests", "Packaging", "fake-docker.sh"), docker); + if (!OperatingSystem.IsWindows()) + { + File.SetUnixFileMode(docker, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute); + } + + await WriteLinesAsync(world.Combine("containers"), containers); + await WriteLinesAsync(world.Combine("images"), FakeDaemon.Images); + await WriteLinesAsync(world.Combine("volumes"), FakeDaemon.Volumes); + + var start = new ProcessStartInfo(bash) + { + WorkingDirectory = Repository.Root()!, + RedirectStandardOutput = true, + RedirectStandardError = true, + StandardOutputEncoding = System.Text.Encoding.UTF8, + StandardErrorEncoding = System.Text.Encoding.UTF8, + }; + start.ArgumentList.Add(".gitea/scripts/pulizia-docker.sh"); + foreach (var argument in arguments) + { + start.ArgumentList.Add(argument); + } + + start.Environment["PATH"] = bin + Path.PathSeparator + Environment.GetEnvironmentVariable("PATH"); + start.Environment["FAKE_DOCKER_WORLD"] = world.Path.Replace('\\', '/'); + start.Environment["DOCKER_HOST"] = OperatingSystem.IsWindows() ? "npipe:////./pipe/febe-nessun-demone" : "unix:///nonexistent/febe-nessun-demone.sock"; + start.Environment.Remove("DOCKER_CONTEXT"); + using var process = Process.Start(start)!; + var output = process.StandardOutput.ReadToEndAsync(TestContext.CancellationToken); + var errors = process.StandardError.ReadToEndAsync(TestContext.CancellationToken); + await process.WaitForExitAsync(TestContext.CancellationToken); + + var result = new CleanupRun( + process.ExitCode, + (await output).Replace("\r\n", "\n", StringComparison.Ordinal), + await errors, + FakeDaemon.ContainersOf([.. await ReadLinesAsync(world.Combine("containers"))]), + [.. (await ReadLinesAsync(world.Combine("images"))).Select(i => string.Join('|', i.Split('|')[..2]))], + await ReadLinesAsync(world.Combine("volumes"))); + var calls = world.Combine("calls"); + Assert.IsTrue(File.Exists(calls) && (await File.ReadAllTextAsync(calls, TestContext.CancellationToken)).Contains("docker ps", StringComparison.Ordinal), $"the fake docker client was not the one called\n{result.Report}"); + Assert.DoesNotContain("unexpected call", result.Errors, result.Report); + return result; + } + + private async Task WriteLinesAsync(string path, IEnumerable lines) => + await File.WriteAllTextAsync(path, string.Concat(lines.Select(line => line + "\n")), TestContext.CancellationToken); + + private async Task> ReadLinesAsync(string path) => + [.. (await File.ReadAllTextAsync(path, TestContext.CancellationToken)).Split('\n', StringSplitOptions.RemoveEmptyEntries)]; + + /// bash for the scripts of the CI: the system one on Linux, Git Bash on Windows (not the one of WSL). + private static string? BashForScripts() + { + if (OperatingSystem.IsWindows()) + { + var git = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "Git", "bin", "bash.exe"); + return File.Exists(git) ? git : null; + } + + return new[] { "/bin/bash", "/usr/bin/bash" }.FirstOrDefault(File.Exists); } /// The workflows and the scripts of the CI, by name. @@ -255,4 +474,10 @@ public sealed partial class PipelineTests [GeneratedRegex(@"docker run\b(?:[^\n]*\\\n)*[^\n]*")] private static partial Regex DockerRun(); + + [GeneratedRegex(@"label=febe\.ci\.(?!prova\b)")] + private static partial Regex ProvenanceLabelFilter(); + + [GeneratedRegex(@"docker (?:image rm|rmi)\s+(?:-\w+\s+)*-\w*f")] + private static partial Regex ForcedImageRemoval(); } diff --git a/tests/Febe.Tests/Packaging/fake-docker.sh b/tests/Febe.Tests/Packaging/fake-docker.sh new file mode 100644 index 0000000..dd0d23c --- /dev/null +++ b/tests/Febe.Tests/Packaging/fake-docker.sh @@ -0,0 +1,302 @@ +#!/usr/bin/env bash +# A fake docker client for PipelineTests: .gitea/scripts/pulizia-docker.sh runs against a small daemon written in text +# files, and the test reads what is left. No daemon, no network. It models only what the cleanup relies on, the way +# Docker does it: +# - filters of «ps»: label filters must all match, the values of any other key are alternatives (status, name as a +# regular expression, ancestor by name or id); +# - «rm» refuses a running container without -f; +# - «image rm » only untags when the image has other names, and refuses an image a container uses (always if the +# container runs, without -f if it is stopped); +# - «image prune --filter until=72h» takes only images without a name, older than 72 hours, used by no container. +# Any other call is an error (exit 3), so the test sees every command the cleanup starts to use. +# +# $FAKE_DOCKER_WORLD/containers id|name|state|minutes ago|image as given to «docker run»|image id|labels +# (labels as Docker gives them to the container: those of the image plus those of «run») +# $FAKE_DOCKER_WORLD/images id|names (comma separated; empty: dangling)|minutes ago|labels +# $FAKE_DOCKER_WORLD/volumes one name per line +# $FAKE_DOCKER_WORLD/calls every call, one per line (written here) +set -uo pipefail + +world="${FAKE_DOCKER_WORLD:?}" +printf 'docker %s\n' "$*" >> "$world/calls" +now=$(date -u +%s) +touch "$world/containers" "$world/images" "$world/volumes" + +unexpected() { + echo "fake docker: unexpected call: $*" >&2 + exit 3 +} + +created() { date -u -d "@$((now - $1 * 60))" +%Y-%m-%dT%H:%M:%S.123456789Z; } + +# The value of a label, or $3 when it is missing («docker ps» prints nothing, «inspect» prints ). +label_value() { + local labels=",$1," key="$2" rest + [[ "$labels" == *",$key="* ]] || { echo "${3:-}"; return; } + rest="${labels#*,"$key"=}" + echo "${rest%%,*}" +} + +has_label() { + local labels=",$1," want="$2" + if [[ "$want" == *=* ]]; then + [[ "$labels" == *",$want,"* ]] + else + [[ "$labels" == *",$want="* ]] + fi +} + +# Image id for a name or an id; empty when there is none. +resolve_image() { + local ref="$1" id names age labels + while IFS='|' read -r id names age labels; do + [[ -n "$id" ]] || continue + if [[ "$id" == "$ref" || ",$names," == *",$ref,"* ]]; then + echo "$id" + return + fi + done < "$world/images" +} + +# The image line for an id; empty when there is none. +image_line() { + local line + while IFS= read -r line; do + [[ -n "$line" && "${line%%|*}" == "$1" ]] && { echo "$line"; return; } + done < "$world/images" +} + +# The container line for an id or a name; empty when there is none. +find_container() { + local ref="$1" line id name rest + while IFS= read -r line; do + IFS='|' read -r id name rest <<< "$line" + if [[ -n "$id" && ("$id" == "$ref" || "$name" == "$ref") ]]; then + echo "$line" + return + fi + done < "$world/containers" +} + +# Rewrites a world file without the lines whose first field is $2. +drop() { + local file="$1" id="$2" line + : > "$file.new" + while IFS= read -r line; do + [[ "${line%%|*}" == "$id" ]] || printf '%s\n' "$line" >> "$file.new" + done < "$file" + mv "$file.new" "$file" +} + +used_by() { + local image="$1" want="$2" id name state age config image_id labels + while IFS='|' read -r id name state age config image_id labels; do + [[ -n "$id" && "$image_id" == "$image" ]] || continue + [[ "$want" == any || "$state" == running ]] && return 0 + done < "$world/containers" + return 1 +} + +matches() { + local name="$1" state="$2" image_id="$3" labels="$4" + shift 4 + local -A seen=() ok=() + local filter key value + for filter in "$@"; do + key="${filter%%=*}" + value="${filter#*=}" + case "$key" in + label) has_label "$labels" "$value" || return 1 ;; + status) seen[$key]=1; [[ "$state" == "$value" ]] && ok[$key]=1 ;; + name) seen[$key]=1; [[ "$name" =~ $value ]] && ok[$key]=1 ;; + ancestor) seen[$key]=1; [[ -n "$image_id" && "$(resolve_image "$value")" == "$image_id" ]] && ok[$key]=1 ;; + *) unexpected "filter $filter" ;; + esac + done + for key in "${!seen[@]}"; do + [[ -n "${ok[$key]:-}" ]] || return 1 + done + return 0 +} + +ps_command() { + local quiet=0 format='{{.ID}} {{.Names}}' filters=() + while (($#)); do + case "$1" in + -a | --no-trunc) ;; + -q) quiet=1 ;; + --filter) filters+=("$2"); shift ;; + --format) format="$2"; shift ;; + *) unexpected "ps $1" ;; + esac + shift + done + local id name state age config image_id labels out key + while IFS='|' read -r id name state age config image_id labels; do + [[ -n "$id" ]] || continue + matches "$name" "$state" "$image_id" "$labels" "${filters[@]}" || continue + if ((quiet)); then + echo "$id" + continue + fi + out="${format//"{{.ID}}"/$id}" + out="${out//"{{.Names}}"/$name}" + while [[ "$out" =~ \{\{\.Label\ \"([^\"]+)\"\}\} ]]; do + key="${BASH_REMATCH[1]}" + out="${out/"${BASH_REMATCH[0]}"/$(label_value "$labels" "$key" "")}" + done + printf '%s\n' "$out" + done < "$world/containers" + return 0 +} + +container_inspect() { + local format="" + [[ "${1:-}" == -f ]] && { format="$2"; shift 2; } + local line id name state age config image_id labels + line=$(find_container "${1:?}") + [[ -n "$line" ]] || { echo "Error: No such container: $1" >&2; exit 1; } + IFS='|' read -r id name state age config image_id labels <<< "$line" + case "$format" in + "") echo "[{\"Id\": \"$id\"}]" ;; + "{{.Created}}") created "$age" ;; + "{{.Config.Image}}") echo "$config" ;; + "{{.Name}}") echo "/$name" ;; + '{{index .Config.Labels "febe.ci.prova"}}') label_value "$labels" febe.ci.prova "" ;; + *) unexpected "container inspect -f $format" ;; + esac +} + +rm_command() { + local force=0 + while [[ "${1:-}" == -* ]]; do + case "$1" in + -f) force=1 ;; + -v) ;; + *) unexpected "rm $1" ;; + esac + shift + done + local line id name state rest + line=$(find_container "${1:?}") + [[ -n "$line" ]] || { echo "Error: No such container: $1" >&2; exit 1; } + IFS='|' read -r id name state rest <<< "$line" + if [[ "$state" == running && "$force" == 0 ]]; then + echo "Error: cannot remove container \"/$name\": container is running: stop the container before removing or force remove" >&2 + exit 1 + fi + drop "$world/containers" "$id" +} + +image_ls() { + local format="" reference="" + while (($#)); do + case "$1" in + --filter) [[ "$2" == reference=* ]] || unexpected "image ls --filter $2"; reference="${2#reference=}"; shift ;; + --format) format="$2"; shift ;; + *) unexpected "image ls $1" ;; + esac + shift + done + [[ "$format" == "{{.Repository}}:{{.Tag}}" ]] || unexpected "image ls --format $format" + local id names age labels tag + while IFS='|' read -r id names age labels; do + [[ -n "$id" ]] || continue + IFS=',' read -r -a tags <<< "$names" + for tag in "${tags[@]}"; do + [[ -z "$reference" || "${tag%:*}" == "$reference" || "$tag" == "$reference" ]] && echo "$tag" + done + done < "$world/images" + return 0 +} + +image_inspect() { + local format="" + [[ "${1:-}" == -f ]] && { format="$2"; shift 2; } + local wanted id names age labels + wanted=$(resolve_image "${1:?}") + [[ -n "$wanted" ]] || { echo "Error: No such image: $1" >&2; exit 1; } + while IFS='|' read -r id names age labels; do + [[ "$id" == "$wanted" ]] || continue + case "$format" in + "") echo "[{\"Id\": \"$id\"}]" ;; + "{{.Created}}") created "$age" ;; + "{{len .RepoTags}}") if [[ -z "$names" ]]; then echo 0; else IFS=',' read -r -a tags <<< "$names"; echo "${#tags[@]}"; fi ;; + *) unexpected "image inspect -f $format" ;; + esac + done < "$world/images" +} + +image_rm() { + local force=0 + [[ "${1:-}" == -f ]] && { force=1; shift; } + local ref="${1:?}" wanted id names age labels left="" tag + wanted=$(resolve_image "$ref") + [[ -n "$wanted" ]] || { echo "Error: No such image: $ref" >&2; exit 1; } + IFS='|' read -r id names age labels <<< "$(image_line "$wanted")" + tags=() + [[ -z "$names" ]] || IFS=',' read -r -a tags <<< "$names" + if [[ "$ref" != "$id" && ${#tags[@]} -gt 1 ]]; then + for tag in "${tags[@]}"; do [[ "$tag" == "$ref" ]] || left="${left:+$left,}$tag"; done + drop "$world/images" "$id" + printf '%s|%s|%s|%s +' "$id" "$left" "$age" "$labels" >> "$world/images" + echo "Untagged: $ref" + return 0 + fi + if [[ "$ref" == "$id" && ${#tags[@]} -gt 1 && "$force" == 0 ]]; then + echo "Error: conflict: unable to delete $id (must be forced) - image is referenced in multiple repositories" >&2 + exit 1 + fi + if used_by "$id" running || { [[ "$force" == 0 ]] && used_by "$id" any; }; then + echo "Error: conflict: unable to remove repository reference \"$ref\" - container is using its referenced image" >&2 + exit 1 + fi + drop "$world/images" "$id" + echo "Deleted: $id" +} + +image_prune() { + [[ "$*" == "-f --filter until=72h" ]] || unexpected "image prune $*" + local id names age labels gone=() + while IFS='|' read -r id names age labels; do + [[ -n "$id" && -z "$names" && "$age" -ge $((72 * 60)) ]] || continue + used_by "$id" any || gone+=("$id") + done < "$world/images" + for id in "${gone[@]}"; do + drop "$world/images" "$id" + echo "deleted: $id" + done + echo "Total reclaimed space: 0B" +} + +case "${1:-}" in + ps) shift; ps_command "$@" ;; + container) [[ "${2:-}" == inspect ]] || unexpected "$*"; shift 2; container_inspect "$@" ;; + rm) shift; rm_command "$@" ;; + image) + sub="${2:-}" + shift 2 + case "$sub" in + ls) image_ls "$@" ;; + inspect) image_inspect "$@" ;; + rm) image_rm "$@" ;; + prune) image_prune "$@" ;; + *) unexpected "image $sub" ;; + esac + ;; + buildx) [[ "${2:-}" == rm ]] || unexpected "$*"; echo "ERROR: no builder \"${4:-}\" found" >&2; exit 1 ;; + volume) + case "${2:-}" in + inspect) grep -qxF -- "${3:?}" "$world/volumes" || { echo "Error: no such volume: $3" >&2; exit 1; } ;; + rm) + [[ "${3:-}" == -f ]] || unexpected "$*" + grep -vxF -- "${4:?}" "$world/volumes" > "$world/volumes.new" + mv "$world/volumes.new" "$world/volumes" + ;; + *) unexpected "$*" ;; + esac + ;; + system) [[ "${2:-}" == df ]] || unexpected "$*"; echo "TYPE TOTAL ACTIVE SIZE RECLAIMABLE" ;; + *) unexpected "$*" ;; +esac -- 2.54.1 From 56fd29be807bea6dc7a08a7dcbf2f4566dddbc51 Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Tue, 20 Oct 2026 12:04:42 +0200 Subject: [PATCH 12/17] CI: se la cima di main non si legge, avviso e pubblicazione della sola :sha- Il passo di pubblicazione gira con bash -e -o pipefail: un errore di git ls-remote chiudeva il passo prima dell'avviso previsto, e il lavoro immagine di main diventava rosso senza pubblicare nemmeno :sha-. Ora l'assegnazione ha un ripiego vuoto e si arriva all'avviso, come promettono il commento e docs/decisioni.md. Rilievo ls-remote-set-e della revisione. Co-Authored-By: Claude Opus 5.5 --- .gitea/workflows/verifica.yml | 4 +++- tests/Febe.Tests/Packaging/PipelineTests.cs | 1 + 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/.gitea/workflows/verifica.yml b/.gitea/workflows/verifica.yml index 862b077..93885f0 100644 --- a/.gitea/workflows/verifica.yml +++ b/.gitea/workflows/verifica.yml @@ -282,7 +282,9 @@ jobs: mv "$CONFIG/config.json.nuovo" "$CONFIG/config.json" NOMI=("$IMAGE:sha-${GITHUB_SHA::7}") # :main solo se main è ancora a questo commit: un'esecuzione arrivata in ritardo non lo riporta indietro. - CIMA=$(git ls-remote origin refs/heads/main 2> /dev/null | cut -f1) + # Il passo gira con «bash -e -o pipefail»: senza «|| CIMA=""» un errore di ls-remote chiuderebbe il passo + # prima dell'avviso, e non uscirebbe nemmeno la :sha-. + CIMA=$(git ls-remote origin refs/heads/main 2> /dev/null | cut -f1) || CIMA="" if [ "$CIMA" = "$GITHUB_SHA" ]; then NOMI+=("$IMAGE:main") elif [ -z "$CIMA" ]; then diff --git a/tests/Febe.Tests/Packaging/PipelineTests.cs b/tests/Febe.Tests/Packaging/PipelineTests.cs index 0f11e54..dae448b 100644 --- a/tests/Febe.Tests/Packaging/PipelineTests.cs +++ b/tests/Febe.Tests/Packaging/PipelineTests.cs @@ -95,6 +95,7 @@ public sealed partial class PipelineTests StringAssert.Contains(publish, "\"$IMAGE:sha-${GITHUB_SHA::7}\""); StringAssert.Contains(publish, "\"$IMAGE:main\""); StringAssert.Contains(publish, "bash .gitea/scripts/costruisci-immagine.sh pubblica"); + StringAssert.Contains(publish, "| cut -f1) || CIMA=\"\"", "under bash -e an unreadable main must reach the warning and still publish :sha-"); Assert.DoesNotContain(":latest", Code(Workflow("verifica.yml")), ":latest belongs to the release"); // Built with buildx, tried without a network and scanned before anything is published; always cleaned up. -- 2.54.1 From 5e7cb73a8583ca299871687ed76cc7e32e2cab36 Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Tue, 20 Oct 2026 12:04:55 +0200 Subject: [PATCH 13/17] =?UTF-8?q?CI:=20un'esecuzione=20a=20mano=20non=20an?= =?UTF-8?q?nulla=20pi=C3=B9=20la=20verifica=20del=20push?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Il gruppo di concorrenza dipendeva solo dal ref: una verifica lanciata a mano su un ramo (per esempio con un seme, per rifare un errore) annullava quella del push in corso sullo stesso ramo. In Gitea un lavoro annullato lascia sul commit lo stato «failure» e workflow_dispatch non scrive stati, quindi la richiesta di unione restava bloccata sui controlli richiesti. Ora l'evento fa parte del gruppo. Rilievo dispatch-annulla-push della revisione. Co-Authored-By: Claude Opus 5.5 --- .gitea/workflows/verifica.yml | 6 ++++-- docs/decisioni.md | 2 +- docs/processo.md | 4 +++- tests/Febe.Tests/Packaging/PipelineTests.cs | 3 +++ 4 files changed, 11 insertions(+), 4 deletions(-) diff --git a/.gitea/workflows/verifica.yml b/.gitea/workflows/verifica.yml index 93885f0..6092d5d 100644 --- a/.gitea/workflows/verifica.yml +++ b/.gitea/workflows/verifica.yml @@ -35,9 +35,11 @@ permissions: contents: read # Su un ramo conta l'ultimo push: l'esecuzione precedente si annulla. Su main ogni commit ha il suo gruppo, così ogni -# unione arriva fino in fondo e pubblica la sua :sha-. +# unione arriva fino in fondo e pubblica la sua :sha-. L'evento fa parte del gruppo: un'esecuzione a mano non annulla +# mai quella di un push, che è l'unica a scrivere gli stati del commit richiesti per unire (un lavoro annullato lascia +# lo stato «failure», e workflow_dispatch non ne scrive). concurrency: - group: verifica-${{ gitea.ref }}${{ gitea.ref == 'refs/heads/main' && format('-{0}', gitea.sha) || '' }} + group: verifica-${{ gitea.event_name }}-${{ gitea.ref }}${{ gitea.ref == 'refs/heads/main' && format('-{0}', gitea.sha) || '' }} cancel-in-progress: ${{ gitea.ref != 'refs/heads/main' }} defaults: diff --git a/docs/decisioni.md b/docs/decisioni.md index 2a15cc7..f476607 100644 --- a/docs/decisioni.md +++ b/docs/decisioni.md @@ -235,7 +235,7 @@ Ogni scelta tecnica presa strada facendo, con data e motivo (specifica §15). | 2026-10-20 | La prova del contenitore (`prova-immagine.sh`) gira sempre con `--network none`: Chromium, criteri, lingua, poi l'avvio come da guida (profilo seccomp, password casuale passata solo nell'ambiente del client) fino a «healthy», `febe --controllo-salute` e l'arresto entro 30 secondi | Regola 1: un'immagine appena costruita non deve poter raggiungere Instagram nemmeno per sbaglio; il controllo di salute passa dalla rete interna del contenitore | | 2026-10-20 | Le etichette `febe.ci.workflow`, `febe.ci.run`, `febe.ci.ref`, `febe.ci.commit` dell'immagine dicono solo da dove viene; `pulizia-docker.sh` sceglie che cosa togliere da segni che nessuna immagine porta: contenitori di prova con l'etichetta `febe.ci.prova=` (messa solo da `docker run --label` in `prova-immagine.sh`) e il nome esatto `febe-prova-`; immagini solo per il nome locale `febe-ci:`, mai per identificativo né con `-f`; builder per nome esatto e immagine `moby/buildkit`. Alla fine di ogni lavoro tutto ciò dell'esecuzione; all'inizio del lavoro successivo e ogni settimana i resti più vecchi di 90 minuti, ma dei contenitori di prova solo quelli fermi (uno acceso si segnala); più le immagini senza nome oltre 72 ore. Mai `system prune`, `builder prune`, `volume prune`. `PipelineTests` fa girare la pulizia contro un client Docker finto con un Febe vero acceso e uno fermo | Docker copia le etichette dell'immagine in ogni contenitore: un Febe vero avviato da `:main`, `:X.Y.Z` o `:latest` sullo stesso demone porta `febe.ci.run`, e un rilascio rilanciato ha lo stesso numero di esecuzione dell'immagine pubblicata (rilievo bloccante della revisione). Il demone è lo stesso di Encelado, Mimante e degli altri progetti; un lavoro dura al massimo 60 minuti, quindi un resto di 90 minuti è orfano; i builder sono sempre accesi e la loro cache se ne va solo con il contenitore | | 2026-10-20 | `verifica` a ogni push su qualunque ramo (`branches: ["**"]`, quindi mai sui tag) e a mano (`workflow_dispatch`, con un seme facoltativo); niente `pull_request` | In Gitea i controlli di una richiesta di unione sono gli stati del suo ultimo commit, che il push del ramo ha già verificato; `pull_request` girerebbe sullo stesso commit (`refs/pull/N/head`, non un'unione di prova) e sull'unico runner raddoppierebbe tutto. Niente richieste da fork: un solo autore, rami nello stesso repository | -| 2026-10-20 | Concorrenza di `verifica`: su un ramo l'esecuzione nuova annulla quella in corso; su main ogni commit ha il suo gruppo e nessuna si annulla; `:main` si sposta solo se main è ancora a quel commit | Il runner fa un lavoro alla volta; ogni unione in main deve arrivare a pubblicare la sua `:sha-`, e un'esecuzione in ritardo non deve riportare indietro `:main`. Gitea 28 valuta le espressioni di `concurrency.group` e `cancel-in-progress` (`services/actions/concurrency.go`) | +| 2026-10-20 | Concorrenza di `verifica`: il gruppo comprende l'evento e il ramo; su un ramo l'esecuzione nuova annulla quella in corso dello stesso evento; su main ogni commit ha il suo gruppo e nessuna si annulla; `:main` si sposta solo se main è ancora a quel commit, e se la cima di main non si legge si pubblica solo `:sha-` con un avviso | Il runner fa un lavoro alla volta; ogni unione in main deve arrivare a pubblicare la sua `:sha-`, e un'esecuzione in ritardo non deve riportare indietro `:main`. Con l'evento nel gruppo un'esecuzione a mano non annulla quella del push: in Gitea un lavoro annullato lascia lo stato «failure» e `workflow_dispatch` non scrive stati, quindi la richiesta di unione resterebbe bloccata. Gitea 28 valuta le espressioni di `concurrency.group` e `cancel-in-progress` (`services/actions/concurrency.go`) | | 2026-10-20 | Lavoro «prove» nel contenitore `node:24-trixie` (Debian 13 con Node 24), con Chromium, Xvfb, ffmpeg, NSIS e la lingua italiana installati a ogni esecuzione; il riepilogo non ammette prove saltate; seconda passata della categoria `SitoDiProva` con il seme 1000 + numero dell'esecuzione, o quello chiesto a mano | Su Ubuntu Chromium è uno snap; le azioni JavaScript girano dentro il contenitore del lavoro e vogliono Node; un'immagine di CI costruita da noi non può fare da contenitore del lavoro, perché act_runner la scaricherebbe da un registro e quello di casa è in HTTP; nella CI una prova saltata vuol dire un ambiente rotto, non una prova superata | | 2026-10-20 | Installatore di ogni esecuzione con versione `-ci.` e immagine con etichetta `org.opencontainers.image.version` uguale; dopo ogni unione in main l'immagine va sul registro come `:main` e `:sha-<7 caratteri>`, mai `:latest`, che resta del rilascio | Decisione di Alberto del 20 ottobre; la versione di prova non si confonde con una versione rilasciata e `installer/costruisci.sh` la accetta già | | 2026-10-20 | Artefatti con `actions/upload-artifact@v3` e `retention-days: 14` (risultati delle prove, installatore e zip, rapporti di sicurezza) | La v4 rifiuta di girare dove il server non è github.com (prende Gitea per GHES) e la sua copia per Gitea sarebbe un'azione nuova, non approvata; il backend v3 di Gitea 28 rispetta `retentionDays` (`routers/api/actions/artifacts.go`) | diff --git a/docs/processo.md b/docs/processo.md index 5b59756..0874328 100644 --- a/docs/processo.md +++ b/docs/processo.md @@ -92,7 +92,9 @@ Docker del server, lo stesso che costruisce Encelado, Mimante e gli altri proget | `immagine` | dopo `prove` | l'immagine si costruisce con buildx (dentro girano compilazione e prove), il contenitore parte **senza rete** come dice la guida e diventa «healthy», Chromium e la lingua italiana ci sono, si ferma entro 30 secondi; Trivy 0.75.0 non trova vulnerabilità CRITICAL con correzione disponibile. Solo dopo un push su `main`: pubblicazione `:main` e `:sha-` | La verifica gira a ogni push su qualunque ramo e a mano (Actions ▸ verifica ▸ Esegui, con un seme facoltativo). Su un -ramo un push nuovo annulla l'esecuzione in corso; su `main` ogni unione arriva fino in fondo. +ramo un push nuovo annulla l'esecuzione in corso; su `main` ogni unione arriva fino in fondo. Un'esecuzione a mano non +annulla mai quella di un push (l'evento fa parte del gruppo di concorrenza): solo il push scrive gli stati del commit +che servono per unire, e un lavoro annullato lascerebbe lo stato «failure». Altri flussi: `rilascio.yml` a ogni tag (vedi «Rilasci») e `pulizia.yml` ogni lunedì (vedi «Pulizia»). diff --git a/tests/Febe.Tests/Packaging/PipelineTests.cs b/tests/Febe.Tests/Packaging/PipelineTests.cs index dae448b..0f84f08 100644 --- a/tests/Febe.Tests/Packaging/PipelineTests.cs +++ b/tests/Febe.Tests/Packaging/PipelineTests.cs @@ -29,6 +29,9 @@ public sealed partial class PipelineTests Assert.DoesNotContain("pull_request", code, "a PR shows the status of its head commit, already verified by the push"); Assert.DoesNotContain("tags:", code, "tags belong to rilascio.yml"); StringAssert.Contains(code, "cancel-in-progress: ${{ gitea.ref != 'refs/heads/main' }}", "every merge into main runs to the end"); + + // A run started by hand never cancels the run of a push: only that one writes the statuses a merge needs. + StringAssert.Contains(code, "group: verifica-${{ gitea.event_name }}-${{ gitea.ref }}"); } [TestMethod] -- 2.54.1 From 2144f755dc9e2c3c8f0e77e0e97330b1a3cfccce Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Tue, 20 Oct 2026 12:04:55 +0200 Subject: [PATCH 14/17] CI: l'immagine di main si pubblica solo dopo l'installatore MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Il lavoro immagine dipendeva solo da prove: :main e :sha- uscivano anche con l'installatore rosso o non ancora finito, mentre docs/docker.md dice che :main è l'ultimo commit di main che ha passato la verifica. Ora needs: [prove, installatore]; sull'unico runner i lavori vanno comunque uno alla volta, quindi la durata non cambia. Rilievo main-senza-installatore della revisione. Co-Authored-By: Claude Opus 5.5 --- .gitea/workflows/verifica.yml | 12 +++++++----- docs/decisioni.md | 1 + docs/guida/Sviluppo.md | 6 +++--- docs/processo.md | 2 +- tests/Febe.Tests/Packaging/PipelineTests.cs | 2 +- 5 files changed, 13 insertions(+), 10 deletions(-) diff --git a/.gitea/workflows/verifica.yml b/.gitea/workflows/verifica.yml index 6092d5d..5c76c53 100644 --- a/.gitea/workflows/verifica.yml +++ b/.gitea/workflows/verifica.yml @@ -8,10 +8,10 @@ # Il mondo sintetico del sito di prova ha il seme 13 e, per la categoria SitoDiProva, anche il seme di # questa esecuzione, scritto nel registro per rifare un errore; # installatore Febe-Setup--ci..exe e lo zip portabile, artefatti per 14 giorni; -# immagine l'immagine Docker costruita con buildx, provata senza rete (parte, salute, Chromium, it_IT) e -# scansionata con Trivy (si ferma per una CRITICAL con correzione); solo dopo un push su main la -# pubblica come :main e :sha-<7 caratteri> (:latest resta al rilascio). Alla fine, sempre, toglie -# immagini, contenitori, cache e builder di questa esecuzione. +# immagine dopo l'installatore: l'immagine Docker costruita con buildx, provata senza rete (parte, salute, +# Chromium, it_IT) e scansionata con Trivy (si ferma per una CRITICAL con correzione); solo dopo un push +# su main la pubblica come :main e :sha-<7 caratteri> (:latest resta al rilascio). Alla fine, sempre, +# toglie immagini, contenitori, cache e builder di questa esecuzione. # # Niente «pull_request»: in Gitea una richiesta di unione mostra lo stato del suo ultimo commit, che il push del ramo # ha già verificato; pull_request rifarebbe tutto sullo stesso commit (refs/pull/N/head) sull'unico runner. @@ -178,8 +178,10 @@ jobs: retention-days: 14 if-no-files-found: error + # Dopo l'installatore, non solo dopo le prove: :main e :sha- escono solo da un commit con tutta la verifica verde. + # Sull'unico runner i lavori vanno comunque uno alla volta, quindi la durata non cambia. immagine: - needs: prove + needs: [prove, installatore] runs-on: ubuntu-latest timeout-minutes: 60 env: diff --git a/docs/decisioni.md b/docs/decisioni.md index f476607..dbdc41e 100644 --- a/docs/decisioni.md +++ b/docs/decisioni.md @@ -242,3 +242,4 @@ Ogni scelta tecnica presa strada facendo, con data e motivo (specifica §15). | 2026-10-20 | `permissions: contents: read` in `verifica` e `pulizia`; i riepiloghi delle prove e di Trivy vanno nel registro e anche in `GITHUB_STEP_SUMMARY` | Gitea 28 applica `permissions` al gettone del lavoro (docs.gitea.com, «Actions job token permissions»), che così non può scrivere nel repository; i riepiloghi dei lavori esistono da Gitea 1.27 ma compaiono solo se il runner li carica, quindi il registro resta la fonte | | 2026-10-20 | Ciò che la CI usa di Gitea 28 e di act_runner: `concurrency` con espressioni, `timeout-minutes` dei lavori (lo applica il runner), `workflow_dispatch` con `inputs`, `schedule`, `defaults.run.shell`, `container` del lavoro, contesti `gitea.*`, `vars` e `secrets`; gli stati dei commit si chiamano «verifica / (push)» (`modules/actions/workflows.go`) e solo push, pull_request e release ne creano | Controllato sul codice di Gitea `release/v28` e su docs.gitea.com il 20 ottobre 2026; ciò che solo la prima esecuzione vera può provare è in `docs/processo.md` | | 2026-10-20 | Processo in `docs/processo.md`: rami `/` da `main`, commit piccoli in italiano, una richiesta di unione per ramo con il modello di `.gitea/` (comprese le 14 regole di §2), unione con commit di unione e ramo cancellato; `main` protetto con i quattro lavori di `verifica` come controlli richiesti e «blocca se indietro»; tag `v*` protetti; Alberto proprietario di tutto (`CODEOWNERS`) | Decisione di Alberto del 20 ottobre (processo da grande azienda); con il ramo aggiornato il commit di unione ha lo stesso contenuto del commit verificato, quindi in `main` entra solo codice provato. Le approvazioni richieste dipendono da chi apre le richieste (Gitea non conta quella dell'autore): domanda aperta per Alberto | +| 2026-10-20 | Nella verifica il lavoro «immagine» viene dopo «prove» e «installatore» (`needs: [prove, installatore]`) | `:main` e `:sha-` devono uscire solo da un commit con tutta la verifica verde, come dice `docs/docker.md`; sull'unico runner i lavori vanno comunque uno alla volta, quindi la durata non cambia. Su un ramo, se l'installatore fallisce l'immagine si salta: la richiesta di unione è già bloccata dall'installatore | diff --git a/docs/guida/Sviluppo.md b/docs/guida/Sviluppo.md index 03e7713..907e8f1 100644 --- a/docs/guida/Sviluppo.md +++ b/docs/guida/Sviluppo.md @@ -139,9 +139,9 @@ richieste di unione, protezione di `main`, rilievi di sicurezza, rilasci, correz - `prove`: compilazione di tutta la soluzione con gli avvisi come errori e tutte le prove di `tests/Febe.Tests` in un contenitore Debian con Chromium, Xvfb, ffmpeg, NSIS e Node veri: nessuna prova si salta; - `installatore`: `Febe-Setup--ci..exe` e lo zip portabile, fra gli artefatti per 14 giorni; - - `immagine`: l'immagine Docker, provata senza rete (parte, diventa «healthy», si ferma) e scansionata con Trivy; - dopo un push su `main` va sul registro come `:main` e `:sha-`. Alla fine si toglie tutto ciò che - l'esecuzione ha creato sul demone Docker, che è condiviso con gli altri progetti; + - `immagine`, dopo l'installatore: l'immagine Docker, provata senza rete (parte, diventa «healthy», si ferma) e + scansionata con Trivy; dopo un push su `main` va sul registro come `:main` e `:sha-`. Alla fine si toglie + tutto ciò che l'esecuzione ha creato sul demone Docker, che è condiviso con gli altri progetti; - `rilascio.yml`, a ogni tag `vX.Y.Z`: prove, installatore e zip, immagine provata e scansionata, pubblicata come `:X.Y.Z` e `:latest` (solo per le versioni senza trattino), poi la release; - `pulizia.yml`, ogni lunedì e a mano: i resti delle esecuzioni interrotte e le immagini senza nome vecchie. diff --git a/docs/processo.md b/docs/processo.md index 0874328..00fbd3d 100644 --- a/docs/processo.md +++ b/docs/processo.md @@ -89,7 +89,7 @@ Docker del server, lo stesso che costruisce Encelado, Mimante e gli altri proget | `controlli` | ogni push | sintassi di tutti gli script di shell (`bash -n`, `sh -n`) e righe Unix; flussi senza tabulazioni; nessun segno di conflitto; versione in `Directory.Build.props` valida; ogni progetto di `Febe.slnx` esiste; ogni JSON si legge; nessun segreto in tutta la storia (gitleaks 8.30.1, `--redact`) | | `prove` | dopo `controlli` | in un contenitore Debian 13 (`node:24-trixie`) con Chromium della distribuzione, Xvfb, ffmpeg, NSIS, Node e la lingua italiana: tutta la soluzione compila con gli avvisi come errori e **tutte** le prove di `tests/Febe.Tests` passano senza saltarsi; quelle della categoria `SitoDiProva` passano anche con il seme dell'esecuzione. Risultati `.trx` fra gli artefatti (14 giorni) | | `installatore` | dopo `prove` | `Febe.exe` in un file solo, `Febe-Setup--ci..exe` e lo zip portabile si costruiscono, ciascuno sotto i 100 MB; artefatti per 14 giorni | -| `immagine` | dopo `prove` | l'immagine si costruisce con buildx (dentro girano compilazione e prove), il contenitore parte **senza rete** come dice la guida e diventa «healthy», Chromium e la lingua italiana ci sono, si ferma entro 30 secondi; Trivy 0.75.0 non trova vulnerabilità CRITICAL con correzione disponibile. Solo dopo un push su `main`: pubblicazione `:main` e `:sha-` | +| `immagine` | dopo `installatore` (così `:main` e `:sha-` escono solo da un commit con tutta la verifica verde) | l'immagine si costruisce con buildx (dentro girano compilazione e prove), il contenitore parte **senza rete** come dice la guida e diventa «healthy», Chromium e la lingua italiana ci sono, si ferma entro 30 secondi; Trivy 0.75.0 non trova vulnerabilità CRITICAL con correzione disponibile. Solo dopo un push su `main`: pubblicazione `:main` e `:sha-` | La verifica gira a ogni push su qualunque ramo e a mano (Actions ▸ verifica ▸ Esegui, con un seme facoltativo). Su un ramo un push nuovo annulla l'esecuzione in corso; su `main` ogni unione arriva fino in fondo. Un'esecuzione a mano non diff --git a/tests/Febe.Tests/Packaging/PipelineTests.cs b/tests/Febe.Tests/Packaging/PipelineTests.cs index 0f84f08..445f880 100644 --- a/tests/Febe.Tests/Packaging/PipelineTests.cs +++ b/tests/Febe.Tests/Packaging/PipelineTests.cs @@ -45,7 +45,7 @@ public sealed partial class PipelineTests StringAssert.Contains(Job(workflow, "prove"), "needs: controlli"); StringAssert.Contains(Job(workflow, "installatore"), "needs: prove"); - StringAssert.Contains(Job(workflow, "immagine"), "needs: prove"); + StringAssert.Contains(Job(workflow, "immagine"), "needs: [prove, installatore]", ":main comes only from a commit whose whole verification is green"); foreach (var other in new[] { "rilascio.yml", "pulizia.yml" }) { var text = Workflow(other); -- 2.54.1 From 010ba794be2e19bd97dbbae1b5415cb3d1b42c8b Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Tue, 20 Oct 2026 12:10:22 +0200 Subject: [PATCH 15/17] Rilascio: l'immagine si pubblica solo dopo l'installatore MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Come nella verifica, il lavoro «immagine» del rilascio aspetta anche «windows»: con l'installatore rosso la release non esce, e allora non devono uscire nemmeno :X.Y.Z e :latest. Sull'unico runner i lavori vanno comunque uno alla volta, quindi la durata non cambia. Co-Authored-By: Claude Opus 5.5 --- .gitea/workflows/rilascio.yml | 12 +++++++----- docs/decisioni.md | 1 + 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/.gitea/workflows/rilascio.yml b/.gitea/workflows/rilascio.yml index 90284b9..3497b4b 100644 --- a/.gitea/workflows/rilascio.yml +++ b/.gitea/workflows/rilascio.yml @@ -3,10 +3,11 @@ # e tutte le prove passano. Senza prove verdi non si costruisce né si rilascia nulla; # 2. windows: Febe.exe in un file solo, il programma di installazione NSIS e lo zip portabile (installer/costruisci.sh, # gira su Linux); -# 3. immagine: l'immagine Docker (le prove girano anche dentro la build), provata senza rete e scansionata con Trivy -# come nella verifica (una CRITICAL con correzione ferma tutto), poi pubblicata sul registro dei container di -# Gitea come //febe:X.Y.Z e :latest (solo per le versioni senza trattino). Il lavoro dice -# se l'ha pubblicata, e alla fine toglie sempre immagini, contenitori, cache e builder dell'esecuzione; +# 3. immagine: dopo l'installatore, l'immagine Docker (le prove girano anche dentro la build), provata senza rete e +# scansionata con Trivy come nella verifica (una CRITICAL con correzione ferma tutto), poi pubblicata sul registro +# dei container di Gitea come //febe:X.Y.Z e :latest (solo per le versioni senza +# trattino). Il lavoro dice se l'ha pubblicata, e alla fine toglie sempre immagini, contenitori, cache e builder +# dell'esecuzione; # 4. release: solo dopo le prove, l'installatore e l'immagine. Crea la release (o la completa, se esiste già) con # installatore, zip portabile, modello Unraid e l'archivio per Docker Compose (compose.yml con il profilo seccomp # accanto); le note dicono dove sta l'immagine, o che non è stata pubblicata. @@ -92,7 +93,8 @@ jobs: immagine: runs-on: ubuntu-latest - needs: prove + # Dopo l'installatore: :X.Y.Z e :latest escono solo se anche la release potrà uscire. + needs: [prove, windows] timeout-minutes: 60 env: FLUSSO: rilascio diff --git a/docs/decisioni.md b/docs/decisioni.md index dbdc41e..5e2105a 100644 --- a/docs/decisioni.md +++ b/docs/decisioni.md @@ -243,3 +243,4 @@ Ogni scelta tecnica presa strada facendo, con data e motivo (specifica §15). | 2026-10-20 | Ciò che la CI usa di Gitea 28 e di act_runner: `concurrency` con espressioni, `timeout-minutes` dei lavori (lo applica il runner), `workflow_dispatch` con `inputs`, `schedule`, `defaults.run.shell`, `container` del lavoro, contesti `gitea.*`, `vars` e `secrets`; gli stati dei commit si chiamano «verifica / (push)» (`modules/actions/workflows.go`) e solo push, pull_request e release ne creano | Controllato sul codice di Gitea `release/v28` e su docs.gitea.com il 20 ottobre 2026; ciò che solo la prima esecuzione vera può provare è in `docs/processo.md` | | 2026-10-20 | Processo in `docs/processo.md`: rami `/` da `main`, commit piccoli in italiano, una richiesta di unione per ramo con il modello di `.gitea/` (comprese le 14 regole di §2), unione con commit di unione e ramo cancellato; `main` protetto con i quattro lavori di `verifica` come controlli richiesti e «blocca se indietro»; tag `v*` protetti; Alberto proprietario di tutto (`CODEOWNERS`) | Decisione di Alberto del 20 ottobre (processo da grande azienda); con il ramo aggiornato il commit di unione ha lo stesso contenuto del commit verificato, quindi in `main` entra solo codice provato. Le approvazioni richieste dipendono da chi apre le richieste (Gitea non conta quella dell'autore): domanda aperta per Alberto | | 2026-10-20 | Nella verifica il lavoro «immagine» viene dopo «prove» e «installatore» (`needs: [prove, installatore]`) | `:main` e `:sha-` devono uscire solo da un commit con tutta la verifica verde, come dice `docs/docker.md`; sull'unico runner i lavori vanno comunque uno alla volta, quindi la durata non cambia. Su un ramo, se l'installatore fallisce l'immagine si salta: la richiesta di unione è già bloccata dall'installatore | +| 2026-10-20 | Anche nel rilascio il lavoro «immagine» viene dopo «prove» e «windows» (`needs: [prove, windows]`) | Come nella verifica: `:X.Y.Z` e `:latest` si pubblicano solo se anche la release potrà uscire; prima, con l'installatore rosso, l'immagine usciva senza release | -- 2.54.1 From d9da3b07cbf595f101aebd4733f432481534d531 Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Tue, 20 Oct 2026 12:19:04 +0200 Subject: [PATCH 16/17] Prove: la struttura del rilascio vuole l'immagine dopo l'installatore MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit La prova sul flusso del rilascio chiedeva ancora «needs: prove» per il lavoro «immagine»: ora controlla «needs: [prove, windows]», la regola introdotta nel commit precedente. Co-Authored-By: Claude Opus 5.5 --- tests/Febe.Tests/Packaging/PackagingTests.cs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/Febe.Tests/Packaging/PackagingTests.cs b/tests/Febe.Tests/Packaging/PackagingTests.cs index 4b10664..3602251 100644 --- a/tests/Febe.Tests/Packaging/PackagingTests.cs +++ b/tests/Febe.Tests/Packaging/PackagingTests.cs @@ -128,8 +128,9 @@ public sealed partial class PackagingTests StringAssert.Contains(prove, "dotnet build Febe.slnx -c Release -nologo -warnaserror"); StringAssert.Contains(prove, "dotnet test tests/Febe.Tests -c Release --no-build"); StringAssert.Contains(Job(workflow, "windows"), "needs: prove"); + // The image waits for the installer too: :X.Y.Z and :latest are published only when the release can follow. var image = Job(workflow, "immagine"); - StringAssert.Contains(image, "needs: prove"); + StringAssert.Contains(image, "needs: [prove, windows]"); // pkg-3: the release needs the tests, the installer and the image job, which says whether it published. var release = Job(workflow, "release"); -- 2.54.1 From 5f968c69d921c9a774b3fee17bcc724779221f7a Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Tue, 20 Oct 2026 13:53:52 +0200 Subject: [PATCH 17/17] =?UTF-8?q?Sito=20di=20prova:=20/benvenuto,=20la=20?= =?UTF-8?q?=C2=ABpagina=20di=20accesso=C2=BB=20che=20Febe=20apre,=20esiste?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Il Collegamento di Febe, con il sito di prova, apre /benvenuto come pagina di accesso, ma il sito rispondeva «Pagina non trovata»: la sessione si apriva lo stesso (il cookie arriva con ogni pagina), però chi prova vedeva un errore. Ora è una pagina di solo testo che dice di tornare a Febe e premere «Ho finito»; nessun modulo, nessuna password. Una prova senza browser lo controlla, con qualunque seme. Co-Authored-By: Claude Opus 5.5 --- .../Collection/SyntheticSiteSeedTests.cs | 17 +++++++++++++++++ tools/Febe.SitoDiProva/LEGGIMI.md | 1 + tools/Febe.SitoDiProva/Pages.cs | 7 +++++++ tools/Febe.SitoDiProva/TestSite.cs | 4 ++++ 4 files changed, 29 insertions(+) diff --git a/tests/Febe.Tests/Collection/SyntheticSiteSeedTests.cs b/tests/Febe.Tests/Collection/SyntheticSiteSeedTests.cs index 2c43a0b..97fafce 100644 --- a/tests/Febe.Tests/Collection/SyntheticSiteSeedTests.cs +++ b/tests/Febe.Tests/Collection/SyntheticSiteSeedTests.cs @@ -138,6 +138,23 @@ public sealed partial class SyntheticSiteSeedTests } } + [TestMethod] + [Timeout(30_000, CooperativeCancellation = true)] + public async Task TheLoginAddressOfTheTestSiteIsAWelcomePageThatOpensTheSession() + { + // Febe opens /benvenuto as the «pagina di accesso» of the test site (LoginUrl of DesktopOptions and ServerOptions). + await using var site = await SyntheticSite.StartAsync(); + using var client = new HttpClient(new SocketsHttpHandler { UseProxy = false, UseCookies = false }); + using var response = await client.GetAsync(new Uri(site.Url("/benvenuto")), TestContext.CancellationToken); + Assert.AreEqual(System.Net.HttpStatusCode.OK, response.StatusCode); + var html = await response.Content.ReadAsStringAsync(TestContext.CancellationToken); + StringAssert.Contains(html, "Ho finito"); + Assert.DoesNotContain(" c.StartsWith(TestSite.SessionCookie + "=", StringComparison.Ordinal)), + "The visit opens the session of the site."); + } + [TestMethod] [Timeout(60_000, CooperativeCancellation = true)] public async Task TheReadersReadWhatTheSiteServesWithTheSeedOfThisRun() diff --git a/tools/Febe.SitoDiProva/LEGGIMI.md b/tools/Febe.SitoDiProva/LEGGIMI.md index 285ff27..607de78 100644 --- a/tools/Febe.SitoDiProva/LEGGIMI.md +++ b/tools/Febe.SitoDiProva/LEGGIMI.md @@ -53,6 +53,7 @@ storie attive di Marta è anche nella raccolta «Estate», con lo **stesso ident | `/post/{codice}/` | pagina di un post, con tutti i file | | `/verifica` | pagina di verifica, semplice testo | | `/sessione-scaduta` | pagina di sessione terminata, semplice testo (non è un modulo di accesso) | +| `/benvenuto` | quella che Febe apre come «pagina di accesso» del sito di prova (Collegamento): semplice testo, nessun modulo; la visita apre la sessione, come ogni pagina | La mappa dei bersagli di queste pagine è `src/Febe.Core/Config/bersagli.prova.json` (copiata accanto al programma in `config/`), i segnali di arresto sono in `segnali.prova.json`. diff --git a/tools/Febe.SitoDiProva/Pages.cs b/tools/Febe.SitoDiProva/Pages.cs index 7536f44..df27c6f 100644 --- a/tools/Febe.SitoDiProva/Pages.cs +++ b/tools/Febe.SitoDiProva/Pages.cs @@ -76,6 +76,13 @@ internal static class Pages public static string NotFound() => Layout("Pagina non trovata", "nessuna", string.Empty, "

Pagina non trovata

"); + /// What Febe opens as the login page of the test site: there is nothing to type, the visit opens the session. + public static string Welcome() => Layout("Benvenuto", "nessuna", string.Empty, """ +

Benvenuto nel sito di prova

+

Qui non c'è nessuna password: il sito di prova ti considera entrato appena apri una sua pagina. Torna a Febe e + premi «Ho finito».

+ """); + private static string Layout(string title, string page, string attributes, string main) => $""" diff --git a/tools/Febe.SitoDiProva/TestSite.cs b/tools/Febe.SitoDiProva/TestSite.cs index 0908faa..0c8fc88 100644 --- a/tools/Febe.SitoDiProva/TestSite.cs +++ b/tools/Febe.SitoDiProva/TestSite.cs @@ -215,6 +215,10 @@ public sealed class TestSite : IAsyncDisposable case []: html = Pages.Home(); break; + case ["benvenuto"]: + // The «pagina di accesso» Febe opens on the test site (LoginUrl): the cookie above already opened the session. + html = Pages.Welcome(); + break; case ["profilo", var user, ..] when World.FindByUsername(user) is null: html = Pages.ProfileNotFound(user); status = 404; -- 2.54.1