Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 4 additions & 0 deletions CHANGELOG.md
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
12 changes: 11 additions & 1 deletion backend/internal/mq/consumer.go
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand Down
49 changes: 49 additions & 0 deletions backend/internal/mq/consumer_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand Down
23 changes: 20 additions & 3 deletions backend/internal/obs/poller.go
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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)
}
Expand Down
69 changes: 69 additions & 0 deletions backend/internal/obs/poller_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -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(`<collection><project name="isv:percona:ppg:releases:14:containers"/></collection>`))
case r.URL.Path == "/build/isv:percona:ppg:releases:14:containers/_result":
w.Write([]byte(`<resultlist><result repository="ubi9" arch="x86_64" state="published"><status package="img" code="disabled"/><status package="rpm" code="disabled"/></result></resultlist>`))
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)
}
}
11 changes: 11 additions & 0 deletions backend/internal/store/cve.go
Original file line number Diff line number Diff line change
Expand Up @@ -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+`
Expand Down
14 changes: 8 additions & 6 deletions backend/internal/worker/worker.go
Original file line number Diff line number Diff line change
Expand Up @@ -5,6 +5,7 @@ import (
"database/sql"
"fmt"
"log/slog"
"slices"
"strings"
"time"

Expand Down Expand Up @@ -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.
Expand Down Expand Up @@ -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,
Expand Down
44 changes: 44 additions & 0 deletions backend/internal/worker/worker_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -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"
Expand Down Expand Up @@ -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)
}
}
Loading