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)
+ }
+}