diff --git a/CHANGELOG.md b/CHANGELOG.md index cb8ebb6..8dc7c6e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,10 @@ an example value. See `deploy/host/README.md`. ## [Unreleased] +### Fixed + +- Released container images showed the version and tags of the previous release, for example `14.24-1` after `14.25-1` was released, in the "Released" view of the CVEs tab and wherever else the image's tags are shown. The tags were read once and never again. They are now re-read when the release project publishes, once a day, and at startup. When the tags change, the image is rescanned straight away instead of at the next nightly scan. + ## [0.2.12] - 2026-11-17 ### Added diff --git a/backend/internal/mq/consumer.go b/backend/internal/mq/consumer.go index 63e2a54..415b17f 100644 --- a/backend/internal/mq/consumer.go +++ b/backend/internal/mq/consumer.go @@ -178,8 +178,18 @@ func (c *Consumer) handle(ctx context.Context, msg amqp.Delivery) { key := strings.TrimPrefix(msg.RoutingKey, c.prefix+".") switch { case key == "repo.published": - // Release projects: BinariesCheckTask handles publish detection; ignore MQ repo events. + // Release projects: BinariesCheckTask handles publish detection. A + // publish there can be a new release, which changes no build state, + // so re-read the tags of the project's containers. if kind == obs.KindRelease { + containers, err := store.QueryContainersByProject(c.db, m.Project) + if err != nil { + slog.Warn("mq: get release containers for publish signal", "project", m.Project, "err", err) + return + } + for _, pkg := range containers { + c.ws.Signal(pkg) + } return } finished, err := store.GetFinishedPackagesByProject(c.db, m.Project) diff --git a/backend/internal/mq/consumer_test.go b/backend/internal/mq/consumer_test.go index 08ee9bb..c04f424 100644 --- a/backend/internal/mq/consumer_test.go +++ b/backend/internal/mq/consumer_test.go @@ -162,6 +162,55 @@ func TestRepoPublishedWakesOnlyMatchingRepo(t *testing.T) { } } +// repo.published on a release project can mean a new release, which changes +// no build state: the project's containers must be woken to re-read their +// tags, and only the containers. +func TestRepoPublishedWakesReleaseContainers(t *testing.T) { + db, err := store.Open(":memory:") + if err != nil { + t.Fatal(err) + } + defer db.Close() + ws := workingset.New(4, 30*time.Second, 5*time.Minute, 4) + inst := obs.NewInstance(obs.InstanceInfo{Name: "openSUSE", Slug: "opensuse", Root: "isv:percona", WebURL: "https://build.opensuse.org", MQRoutingPrefix: "opensuse.obs"}, nil) + fleet := obs.NewFleet(inst) + c := NewConsumer(fleet.Default(), fleet, db, hubpkg.New(), ws) + + now := time.Now().UTC() + yes, no := true, false + for _, pkg := range []*model.Package{ + {Project: "ppg:releases:14:containers", Name: "img", IsRelease: true, IsContainer: &yes, + RollupState: model.RollupPublished, ContainerTags: []string{"14.24-1", "14"}, UpdatedAt: now}, + {Project: "ppg:releases:14:containers", Name: "rpm", IsRelease: true, IsContainer: &no, + RollupState: model.RollupPublished, UpdatedAt: now}, + {Project: "ppg:releases:15:containers", Name: "other", IsRelease: true, IsContainer: &yes, + RollupState: model.RollupPublished, ContainerTags: []string{"15.19-1", "15"}, UpdatedAt: now}, + } { + if err := store.UpsertPackageState(db, pkg, now); err != nil { + t.Fatal(err) + } + } + + body, _ := json.Marshal(map[string]string{ + "project": "isv:percona:ppg:releases:14:containers", "repo": "ubi9", + }) + c.handle(context.Background(), amqp.Delivery{RoutingKey: "opensuse.obs.repo.published", Body: body}) + + select { + case job := <-ws.Dispatch(): + if got := job.Pkgs[0]; got.Name != "img" { + t.Fatalf("dispatched %q, want img", got.Name) + } + case <-time.After(time.Second): + t.Fatal("repo.published did not wake the release container") + } + select { + case job := <-ws.Dispatch(): + t.Fatalf("unexpected extra dispatch: %s", job.Pkgs[0].Name) + case <-time.After(100 * time.Millisecond): + } +} + func twoInstanceFleet() (*obs.Fleet, *obs.Instance, *obs.Instance) { x := obs.NewInstance(obs.InstanceInfo{Name: "openSUSE", Slug: "opensuse", Root: "isv:percona", WebURL: "https://build.opensuse.org", MQRoutingPrefix: "opensuse.obs"}, nil) y := obs.NewInstance(obs.InstanceInfo{Name: "Percona", Slug: "percona", Root: "percona", WebURL: "https://obs.example.com", MQRoutingPrefix: "percona.obs"}, nil) diff --git a/backend/internal/obs/poller.go b/backend/internal/obs/poller.go index 5303af4..de99459 100644 --- a/backend/internal/obs/poller.go +++ b/backend/internal/obs/poller.go @@ -28,10 +28,20 @@ type Poller struct { hub *hubpkg.Hub ws *workingset.WorkingSet gate PollGate + // releaseTagsAt records, per release project, when its published + // containers were last queued for a tag refresh. In memory only, so a + // restart refreshes every release project on the first tick. + releaseTagsAt map[string]time.Time } +// releaseTagsInterval is how often a published release container's tags are +// re-read. A new release into the same project changes no build state, so +// without this (and the MQ repo.published signal) the stored version would +// stay at the first one seen. +const releaseTagsInterval = 24 * time.Hour + func NewPoller(client *Fleet, db *sql.DB, interval time.Duration, h *hubpkg.Hub, ws *workingset.WorkingSet, gate PollGate) *Poller { - return &Poller{client: client, db: db, interval: interval, hub: h, ws: ws, gate: gate} + return &Poller{client: client, db: db, interval: interval, hub: h, ws: ws, gate: gate, releaseTagsAt: map[string]time.Time{}} } // Run blocks until ctx is cancelled. It ticks immediately on first call @@ -130,6 +140,11 @@ func (p *Poller) tick(ctx context.Context) { } } + refreshReleaseTags := kind == KindRelease && time.Since(p.releaseTagsAt[project]) >= releaseTagsInterval + if refreshReleaseTags { + p.releaseTagsAt[project] = time.Now() + } + tags := ProjectTags(project) for pkgName, targets := range byPkg { key := project + "/" + pkgName @@ -177,8 +192,10 @@ func (p *Poller) tick(ctx context.Context) { continue } } - // Add to working set only if there is work remaining. - containerNeedsTags := pkg.IsContainer != nil && *pkg.IsContainer && len(pkg.ContainerTags) == 0 + // Add to working set only if there is work remaining, or the + // container's tags are due for their periodic re-read. + isContainer := pkg.IsContainer != nil && *pkg.IsContainer + containerNeedsTags := isContainer && (len(pkg.ContainerTags) == 0 || refreshReleaseTags) if pkg.RollupState != model.RollupPublished || pkg.IsContainer == nil || containerNeedsTags { p.ws.Add(pkg) } diff --git a/backend/internal/obs/poller_test.go b/backend/internal/obs/poller_test.go index 8654838..d675775 100644 --- a/backend/internal/obs/poller_test.go +++ b/backend/internal/obs/poller_test.go @@ -437,3 +437,72 @@ func waitFor(t *testing.T, cond func() bool) { } t.Fatal("condition not met within 2s") } + +// A published release container that already has tags must still be queued +// for a tag re-read on the first tick after startup, and then not again +// until releaseTagsInterval has passed: a new release into the same project +// changes no build state, so nothing else would refresh its version. +func TestPollerRefreshesReleaseContainerTags(t *testing.T) { + db, err := store.Open(":memory:") + if err != nil { + t.Fatal(err) + } + defer db.Close() + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch { + case strings.HasPrefix(r.URL.Path, "/search/project/id"): + w.Write([]byte(``)) + case r.URL.Path == "/build/isv:percona:ppg:releases:14:containers/_result": + w.Write([]byte(``)) + default: + http.NotFound(w, r) + } + })) + defer srv.Close() + fleet := NewFleet(NewInstance(InstanceInfo{Slug: "opensuse", Root: "isv:percona"}, NewClient(srv.URL, "u", "p"))) + + now := time.Now().UTC() + yes, no := true, false + for _, pkg := range []*model.Package{ + {Project: "ppg:releases:14:containers", Name: "img", IsRelease: true, IsContainer: &yes, + RollupState: model.RollupPublished, Version: "14.24-1", ContainerTags: []string{"14.24-1", "14"}, UpdatedAt: now}, + {Project: "ppg:releases:14:containers", Name: "rpm", IsRelease: true, IsContainer: &no, + RollupState: model.RollupPublished, Version: "14.24-1", UpdatedAt: now}, + } { + if err := store.UpsertPackageState(db, pkg, now); err != nil { + t.Fatal(err) + } + } + + ws := workingset.New(64, time.Minute, time.Minute, 4) + p := NewPoller(fleet, db, time.Minute, hubpkg.New(), ws, nil) + + dispatched := func() []string { + var names []string + for { + select { + case job := <-ws.Dispatch(): + for _, pkg := range job.Pkgs { + names = append(names, pkg.Name) + ws.Remove(pkg.Project + "/" + pkg.Name) + } + case <-time.After(100 * time.Millisecond): + return names + } + } + } + + p.tick(context.Background()) + if got := dispatched(); len(got) != 1 || got[0] != "img" { + t.Fatalf("first tick dispatched %v, want [img]", got) + } + p.tick(context.Background()) + if got := dispatched(); len(got) != 0 { + t.Fatalf("second tick dispatched %v, want nothing", got) + } + p.releaseTagsAt["ppg:releases:14:containers"] = time.Now().Add(-releaseTagsInterval) + p.tick(context.Background()) + if got := dispatched(); len(got) != 1 || got[0] != "img" { + t.Fatalf("tick after the interval dispatched %v, want [img]", got) + } +} diff --git a/backend/internal/store/cve.go b/backend/internal/store/cve.go index 2ba233e..821a006 100644 --- a/backend/internal/store/cve.go +++ b/backend/internal/store/cve.go @@ -262,6 +262,17 @@ func QueryPublishedContainers(db *sql.DB) ([]*model.Package, error) { return scanPackages(db, rows) } +// QueryContainersByProject returns the confirmed container packages of one project. +func QueryContainersByProject(db *sql.DB, project string) ([]*model.Package, error) { + rows, err := db.Query(`SELECT`+packageSelectCols+` + FROM packages WHERE project = ? AND is_container = 1`, project) + if err != nil { + return nil, err + } + defer rows.Close() + return scanPackages(db, rows) +} + // GetPackage returns a single package by primary key, or nil if not found. func GetPackage(db *sql.DB, project, name string) (*model.Package, error) { rows, err := db.Query(`SELECT`+packageSelectCols+` diff --git a/backend/internal/worker/worker.go b/backend/internal/worker/worker.go index b486593..3b5d412 100644 --- a/backend/internal/worker/worker.go +++ b/backend/internal/worker/worker.go @@ -5,6 +5,7 @@ import ( "database/sql" "fmt" "log/slog" + "slices" "strings" "time" @@ -114,7 +115,7 @@ func (p *Pool) ProcessOnce(ctx context.Context, pkg *model.Package, env *obs.Env // Snapshot rollup state before tasks run so we can detect the transition. prevRollupState := pkg.RollupState - prevContainerTagCount := len(pkg.ContainerTags) + prevContainerTags := slices.Clone(pkg.ContainerTags) // Snapshot target state before task chain. // BuildReasonPackages is a slice field — deep copy to avoid aliasing. @@ -170,14 +171,15 @@ func (p *Pool) ProcessOnce(ctx context.Context, pkg *model.Package, env *obs.Env // Enqueue a CVE scan on two conditions: // 1. Normal path: rollup just transitioned to published (dev containers, PR containers). - // 2. Release path: package was already published but container tags were just populated - // for the first time (release containers arrive with tags missing; ContainerTagsTask - // fills them in, which never triggers condition 1). - tagsJustPopulated := prevContainerTagCount == 0 && len(pkg.ContainerTags) > 0 + // 2. Release path: package was already published but its container tags changed. + // Release containers arrive with tags missing and ContainerTagsTask fills them in; + // later a new release replaces them. Neither triggers condition 1, and the + // stored scan would otherwise describe the previous image until the nightly rescan. + tagsChanged := !slices.Equal(prevContainerTags, pkg.ContainerTags) if p.scanner != nil && pkg.IsContainer != nil && *pkg.IsContainer && pkg.RollupState == model.RollupPublished && - (prevRollupState != model.RollupPublished || tagsJustPopulated) && + (prevRollupState != model.RollupPublished || tagsChanged) && len(pkg.ContainerTags) > 0 { p.scanner.Enqueue(cve.ScanRequest{ Project: pkg.Project, diff --git a/backend/internal/worker/worker_test.go b/backend/internal/worker/worker_test.go index 3aa374a..e69247c 100644 --- a/backend/internal/worker/worker_test.go +++ b/backend/internal/worker/worker_test.go @@ -13,6 +13,7 @@ import ( "testing" "time" + "github.com/percona/obs-dashboard/internal/cve" hubpkg "github.com/percona/obs-dashboard/internal/hub" "github.com/percona/obs-dashboard/internal/model" "github.com/percona/obs-dashboard/internal/obs" @@ -1154,3 +1155,46 @@ func TestProcessJobBatchFallsBackPerPackageOnFetchError(t *testing.T) { t.Errorf("rollups = %s/%s, want succeeded/succeeded", pkgA.RollupState, pkgB.RollupState) } } + +type setTagsTask struct{ tags []string } + +func (t setTagsTask) Run(_ context.Context, _ *obs.Fleet, pkg *model.Package, _ *obs.Env) error { + pkg.ContainerTags = t.tags + pkg.Version = t.tags[0] + return nil +} + +// A published release container whose tags change (a new release landed) +// must be rescanned: its stored scan describes the previous image. Unchanged +// tags must not trigger a scan. +func TestProcessOnceRescansReleaseContainerWhenTagsChange(t *testing.T) { + db := openDB(t) + ws := workingset.New(10, 30*time.Second, 5*time.Minute, 4) + var scans []cve.ScanRequest + scanner := cve.NewScanner(db, hubpkg.New(), 0, cve.WithEnqueueFn(func(r cve.ScanRequest) { scans = append(scans, r) })) + + newPkg := func() *model.Package { + isContainer := true + return &model.Package{ + Project: "ppg:releases:14:containers", Name: "img", IsRelease: true, IsContainer: &isContainer, + RollupState: model.RollupPublished, Version: "14.24-1", ContainerTags: []string{"14.24-1", "14"}, + UpdatedAt: time.Now().UTC(), + } + } + + same := worker.NewPool(1, nil, []worker.Task{setTagsTask{[]string{"14.24-1", "14"}}}, nil, db, hubpkg.New(), ws, scanner) + same.ProcessOnce(context.Background(), newPkg(), nil) + if len(scans) != 0 { + t.Fatalf("unchanged tags enqueued %d scans, want 0", len(scans)) + } + + changed := worker.NewPool(1, nil, []worker.Task{setTagsTask{[]string{"14.25-1", "14"}}}, nil, db, hubpkg.New(), ws, scanner) + changed.ProcessOnce(context.Background(), newPkg(), nil) + if len(scans) != 1 || scans[0].Package != "img" || scans[0].PrimaryTag != "14" { + t.Fatalf("changed tags enqueued %+v, want one scan of img:14", scans) + } + got, err := store.GetPackage(db, "ppg:releases:14:containers", "img") + if err != nil || got == nil || got.Version != "14.25-1" { + t.Fatalf("stored version = %+v (err=%v), want 14.25-1", got, err) + } +}