The review found two faults. The tool paged on through a state of any size, one replay of the bucket per page; it now reads one page of each of its own states and, when the state holds more, answers that page capped, with the keys read and the state's size from its info, never asking a second page and never refusing. And the retiring of superseded done builds keyed the newest reservation and release by module alone, so a standing 0.2 would retire a done 0.1.x; both are now found per module and series (MAJOR.MINOR). Builds: design 47 H H-A-292, H-A-293, H-A-291 (1), H-A-290 (5)
539 lines
25 KiB
Go
539 lines
25 KiB
Go
package versions
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"maps"
|
|
"slices"
|
|
"strings"
|
|
"sync"
|
|
"sync/atomic"
|
|
"testing"
|
|
"testing/synctest"
|
|
"time"
|
|
|
|
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog"
|
|
)
|
|
|
|
type queueMem struct {
|
|
*reserveMem
|
|
bytes uint64
|
|
// listings counts the listings of one holder's keys (a filter `<holder>.*.*`), what a drain's pass lists.
|
|
listings atomic.Int32
|
|
}
|
|
|
|
func (q *queueMem) Bytes(context.Context) (uint64, error) { return q.bytes, nil }
|
|
|
|
func (q *queueMem) KeysOf(ctx context.Context, filter string) ([]string, error) {
|
|
if strings.HasSuffix(filter, ".*.*") && filter != QueueFilter {
|
|
q.listings.Add(1)
|
|
}
|
|
return q.reserveMem.KeysOf(ctx, filter)
|
|
}
|
|
|
|
// republishBed is a Republisher over memory states: reservations of module m (a bundle by the oci seat and a Go package by
|
|
// the Go seat), one holder module `oci` that claims the oci seat, and a Send and a Unreleased that record.
|
|
type republishBed struct {
|
|
*Republisher
|
|
reserved *reserveMem
|
|
queue *queueMem
|
|
now time.Time
|
|
mu sync.Mutex // sent and said, which a holder's sends at once write
|
|
sent []Publish
|
|
said []string
|
|
ended []string
|
|
refuse string // the words Send fails with, empty for none
|
|
// holders are the registry seats' holders the seat-holders view names (design 47 G A-416).
|
|
holders map[string][]string
|
|
}
|
|
|
|
func newRepublishBed(t *testing.T) *republishBed {
|
|
t.Helper()
|
|
b := &republishBed{reserved: &reserveMem{mem: newMem()}, queue: &queueMem{reserveMem: &reserveMem{mem: newMem()}}, now: time.Date(2026, 11, 11, 12, 0, 0, 0, time.UTC)}
|
|
res := &Reserver{Store: b.reserved, Now: func() time.Time { return b.now }, ReleasedOf: func(context.Context, string) ([]string, error) { return nil, nil }}
|
|
b.Republisher = &Republisher{Reserved: res, Queue: b.queue, Now: func() time.Time { return b.now }, Go: func(f func()) { f() },
|
|
Entry: func(_ context.Context, fp string) (meshcatalog.CatalogEntry, error) {
|
|
if fp == "src2:holder" {
|
|
return meshcatalog.CatalogEntry{Serves: []string{SeatArtifacts + ".publish", SeatArtifacts + ".versions"}}, nil
|
|
}
|
|
m := strings.TrimPrefix(fp, "src2:")
|
|
return meshcatalog.CatalogEntry{Artifacts: []meshcatalog.Artifact{
|
|
{Ref: m + ":prog", Kind: "bundle", Language: "go"},
|
|
{Ref: m + ":lib", Kind: "package", Language: "go", Package: &meshcatalog.ArtifactPackage{Ecosystem: "go", Name: "git.novox.be/novox/" + m + "/go"}}}}, nil
|
|
},
|
|
Send: func(_ context.Context, p Publish) error {
|
|
b.mu.Lock()
|
|
defer b.mu.Unlock()
|
|
b.sent = append(b.sent, p)
|
|
if b.refuse != "" {
|
|
return errors.New(b.refuse)
|
|
}
|
|
return nil
|
|
},
|
|
Unreleased: func(_ context.Context, v ReservedVersion, why string) {
|
|
b.mu.Lock()
|
|
defer b.mu.Unlock()
|
|
b.said = append(b.said, v.Module+" "+v.Version+": "+why)
|
|
},
|
|
Ended: func(_ context.Context, module, version string) {
|
|
b.mu.Lock()
|
|
defer b.mu.Unlock()
|
|
b.ended = append(b.ended, module+" "+version)
|
|
},
|
|
Logf: t.Logf}
|
|
b.Holders = func(seat string) []string { return b.holders[seat] }
|
|
return b
|
|
}
|
|
|
|
// reserve reserves and builds a version of module m (its patch given by the reservation order), its build ended long ago.
|
|
func (b *republishBed) reserve(t *testing.T, module string) ReservedVersion {
|
|
t.Helper()
|
|
b.now = b.now.Add(time.Minute)
|
|
ctx := context.Background()
|
|
v, err := b.Reserved.Reserve(ctx, module, "0.1", []string{module + ":prog", module + ":lib"}, Source{Fingerprint: "src2:" + module})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for ref, d := range map[string]string{module + ":prog": "sha256:aa", module + ":lib": "sha256:bb"} {
|
|
if _, err := b.Reserved.Built(ctx, module, v.Version, ref, d, nil); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
b.now = b.now.Add(UnreleasedBound + time.Minute)
|
|
return v
|
|
}
|
|
|
|
// TestRepublish: design 47 G §588 (A-73, A-76): a reserved version left unpublished is published again, on a registry
|
|
// holder's running and on its node's returned, once per message by its stream sequence, as a publish by digest with no parts,
|
|
// at most the setting's number per event, newest first; an artifact no store holds is said once and not tried again.
|
|
func TestRepublish(t *testing.T) {
|
|
ctx := context.Background()
|
|
t.Run("a done build is published as a digest with no parts, to its seat's holder", func(t *testing.T) {
|
|
b := newRepublishBed(t)
|
|
v := b.reserve(t, "m")
|
|
b.holders = map[string][]string{SeatArtifacts: {"oci"}}
|
|
if v.Fingerprint != "src2:m" {
|
|
t.Fatalf("the reservation keeps the entry's fingerprint: %q", v.Fingerprint)
|
|
}
|
|
if q, err := b.Republish(ctx, "", ""); err != nil || len(b.sent) != 1 || fmt.Sprint(q) != "[m "+v.Version+"]" {
|
|
t.Fatalf("queued %v sent %d (%v), want 1", q, len(b.sent), err)
|
|
}
|
|
p := b.sent[0]
|
|
if p.Seat != SeatArtifacts || p.Name != "m/prog" || p.Kind != "bundle" || p.Version != v.Version || p.Digest != "sha256:aa" || p.Fingerprint != "src2:m" ||
|
|
p.Transfer != "republish-m-"+strings.ReplaceAll(v.Version, ".", "-")+"-prog" || strings.ContainsAny(p.Transfer, "/. *>") {
|
|
t.Errorf("sent %+v, want the bundle by digest to the oci seat, the Go package left to its own seat's holder", p)
|
|
}
|
|
if keys, _ := b.queue.KeysOf(ctx, AllFilter); len(keys) != 0 {
|
|
t.Errorf("a key stays in the queue after its outcome: %v", keys)
|
|
}
|
|
})
|
|
t.Run("an entry that cannot be read stops neither the other versions nor the drain", func(t *testing.T) {
|
|
b := newRepublishBed(t)
|
|
b.reserve(t, "m1")
|
|
b.reserve(t, "m2") // newest: queued before m1's entry is met
|
|
entry := b.Entry
|
|
b.Entry = func(ctx context.Context, fp string) (meshcatalog.CatalogEntry, error) {
|
|
if fp == "src2:m1" {
|
|
return meshcatalog.CatalogEntry{}, errors.New("no entry of fingerprint src2:m1 is kept")
|
|
}
|
|
return entry(ctx, fp)
|
|
}
|
|
b.holders = map[string][]string{SeatArtifacts: {"oci"}}
|
|
if _, err := b.Republish(ctx, "", ""); err == nil || !strings.Contains(err.Error(), "src2:m1") {
|
|
t.Errorf("the unreadable entry is not said: %v", err)
|
|
}
|
|
if len(b.sent) != 1 || !strings.HasPrefix(b.sent[0].Name, "m2/") {
|
|
t.Errorf("sent %+v, want m2 drained though m1's entry cannot be read", b.sent)
|
|
}
|
|
})
|
|
t.Run("an artifact no store holds is said once and not tried again", func(t *testing.T) {
|
|
b := newRepublishBed(t)
|
|
b.reserve(t, "m")
|
|
b.refuse = "oci-artifact-registry's publish of m/prog: not stored: no blob sha256:aa"
|
|
b.holders = map[string][]string{SeatArtifacts: {"oci"}}
|
|
_, _ = b.Republish(ctx, "", "")
|
|
_, _ = b.Republish(ctx, "", "")
|
|
if len(b.sent) != 1 || len(b.said) != 1 || !strings.Contains(b.said[0], "not stored: ") {
|
|
t.Errorf("sent %d, said %v: want one try and one saying of not stored", len(b.sent), b.said)
|
|
}
|
|
})
|
|
t.Run("a refusal in other words is said each time", func(t *testing.T) {
|
|
b := newRepublishBed(t)
|
|
b.reserve(t, "m")
|
|
b.refuse = "the holder is full"
|
|
b.holders = map[string][]string{SeatArtifacts: {"oci"}}
|
|
_, _ = b.Republish(ctx, "", "")
|
|
_, _ = b.Republish(ctx, "", "")
|
|
if len(b.sent) != 2 || len(b.said) != 2 {
|
|
t.Errorf("sent %d, said %v: want both events tried and said", len(b.sent), b.said)
|
|
}
|
|
})
|
|
t.Run("a queue past its cap says queue full", func(t *testing.T) {
|
|
b := newRepublishBed(t)
|
|
b.reserve(t, "m")
|
|
b.queue.bytes = PublishQueueMiB << 20
|
|
b.holders = map[string][]string{SeatArtifacts: {"oci"}}
|
|
_, _ = b.Republish(ctx, "", "")
|
|
if len(b.sent) != 0 || len(b.said) != 1 || !strings.HasSuffix(b.said[0], QueueFull) {
|
|
t.Errorf("sent %d, said %v, want nothing sent and queue full said", len(b.sent), b.said)
|
|
}
|
|
})
|
|
t.Run("a restart sends the queued again, a begun one anew", func(t *testing.T) {
|
|
b := newRepublishBed(t)
|
|
v := b.reserve(t, "m")
|
|
raw, _ := json.Marshal(QueuedPublish{V: 1, Holder: "oci", Module: "m", Version: v.Version, Artifacts: map[string]string{"m:prog": "sha256:aa"}, Queued: b.now, Begun: true})
|
|
if _, err := b.queue.Create(ctx, QueueKey("oci", "m", v.Version), raw); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := b.Resume(ctx); err != nil || len(b.sent) != 1 {
|
|
t.Errorf("resume sent %d (%v), want the begun version sent anew", len(b.sent), err)
|
|
}
|
|
})
|
|
t.Run("after a fresh start the tool queues at the seat's holder, no running heard", func(t *testing.T) {
|
|
// Design 47 G A-416, A-416a: the holder is the one the seat-holders view names from the start, not one learnt from a
|
|
// running heard since; a seat with no holder queues nothing.
|
|
b := newRepublishBed(t)
|
|
b.reserve(t, "m1")
|
|
b.reserve(t, "m2")
|
|
if q, err := b.Republish(ctx, "", ""); err != nil || len(q) != 0 {
|
|
t.Errorf("no holder named: queued %v (%v), want none", q, err)
|
|
}
|
|
b.holders = map[string][]string{SeatArtifacts: {"oci"}}
|
|
q, err := b.Republish(ctx, "", "")
|
|
if err != nil || fmt.Sprint(q) != "[m2 0.1.0 m1 0.1.0]" || len(b.sent) != 2 || b.sent[0].Seat != SeatArtifacts {
|
|
t.Errorf("the tool with neither queued %v (%v), sent %+v: want both versions at oci, with no limit", q, err, b.sent)
|
|
}
|
|
if _, err := b.Republish(ctx, "m1", "0.1.9"); err == nil {
|
|
t.Error("a version no reservation holds is not refused")
|
|
}
|
|
b.holders = map[string][]string{SeatArtifacts: {"oci"}}
|
|
_, _ = b.Republish(ctx, "", "")
|
|
items := Reader{Keys: func() ([]string, error) { return []string{"publish.m.0.1.0", "reserve-done.m.x"}, nil },
|
|
Get: func(k string) (json.RawMessage, bool, error) {
|
|
return json.RawMessage(`{"mode":"publish","module":"m","version":"0.1.0","tries":3,"next-try":"2026-11-17T01:00:00Z","why":"w"}`), true, nil
|
|
}}
|
|
none := Reader{Keys: func() ([]string, error) { return nil, nil }}
|
|
answer, err := AnswerQueue(none, none, items, "", "")
|
|
if err != nil || len(answer.Items) != 1 || answer.Items[0].Tries != 3 || answer.Items[0].Version != "0.1.0" {
|
|
t.Errorf("builder_publish_queue items = %+v (%v), want the one publish item with its tries", answer.Items, err)
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestTheRegistriesRecordSaysWhetherAVersionIsHeld: design 47 H H-A-272, H-A-274, H-A-275 — a missing artifact its registry seat
|
|
// holds at the version (the Go form too) with the built digest is held; at the version with another digest it is held elsewhere;
|
|
// a version the seat lacks is said by name. The numbers a registry holds of the module's artifacts are what reserving skips.
|
|
func TestTheRegistriesRecordSaysWhetherAVersionIsHeld(t *testing.T) {
|
|
ctx := context.Background()
|
|
entry := meshcatalog.CatalogEntry{Artifacts: []meshcatalog.Artifact{{Ref: "m:lib", Kind: "package", Language: "go", Package: &meshcatalog.ArtifactPackage{Ecosystem: "go", Name: "git.example/m"}}}}
|
|
r := &Republisher{Entry: func(context.Context, string) (meshcatalog.CatalogEntry, error) { return entry, nil }}
|
|
v := ReservedVersion{Module: "m", Version: "0.1.37", Fingerprint: "fp", Artifacts: map[string]string{"m:lib": "sha256:a"}}
|
|
for _, c := range []struct {
|
|
name string
|
|
holds []HeldVersion
|
|
all, elsewhere, lacks bool
|
|
}{
|
|
{name: "held in the Go form with the built digest", holds: []HeldVersion{{Version: "v0.1.36", Digest: "sha256:z"}, {Version: "v0.1.37", Digest: "sha256:a"}}, all: true},
|
|
{name: "another digest at the version", holds: []HeldVersion{{Version: "0.1.37", Digest: "sha256:b"}}, elsewhere: true},
|
|
{name: "the version lacked", holds: []HeldVersion{{Version: "0.1.36", Digest: "sha256:a"}}, lacks: true},
|
|
} {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
var seat, name string
|
|
versionsOf := func(_ context.Context, s, n string) ([]HeldVersion, error) { seat, name = s, n; return c.holds, nil }
|
|
j, err := r.Held(ctx, v, versionsOf)
|
|
if err != nil || j.All != c.all || (len(j.Elsewhere) == 1) != c.elsewhere || (j.Lacks != "") != c.lacks || seat != SeatGoPackages || name != "git.example/m" {
|
|
t.Fatalf("judged %+v (%v) asking %s for %s, want all %v, elsewhere %v, lacks %v asking %s for git.example/m", j, err, seat, name, c.all, c.elsewhere, c.lacks, SeatGoPackages)
|
|
}
|
|
if c.lacks && !strings.Contains(j.Lacks, "0.1.37") {
|
|
t.Errorf("what the registry lacks is said as %q", j.Lacks)
|
|
}
|
|
nums, err := r.HeldNumbers(ctx, "m", "fp", []string{"m:lib"}, versionsOf)
|
|
if err != nil || len(nums) != len(c.holds) {
|
|
t.Errorf("the held numbers are %v (%v), want one per version the seat holds", nums, err)
|
|
}
|
|
})
|
|
}
|
|
v.Published = map[string]bool{"m:lib": true}
|
|
if j, err := r.Held(ctx, v, nil); err != nil || !j.All {
|
|
t.Errorf("a version with no missing artifact is judged %+v (%v), want all held without a read", j, err)
|
|
}
|
|
}
|
|
|
|
// queueAt writes a queued version of module m at holder oci directly, as a start finds it.
|
|
func (b *republishBed) queueAt(t *testing.T, v ReservedVersion, class string, at time.Time) {
|
|
t.Helper()
|
|
raw, _ := json.Marshal(QueuedPublish{V: 1, Holder: "oci", Module: v.Module, Version: v.Version, Artifacts: map[string]string{v.Module + ":prog": "sha256:aa"}, Queued: at, Class: class})
|
|
if _, err := b.queue.Create(context.Background(), QueueKey("oci", v.Module, v.Version), raw); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// TestAHoldersQueueSendsLiveFirstInPasses: design 47 H H-A-290 (1)-(3) — a publish whose build ended in this run is sent before
|
|
// any of a build that ended before the start, each class oldest first; a pass lists the holder's keys once and sends them, at most
|
|
// four at a time; a build whose reservation was withdrawn or taken over never publishes, its key dropped and its publish item ended,
|
|
// at enqueue, at the pass and at the start.
|
|
func TestAHoldersQueueSendsLiveFirstInPasses(t *testing.T) {
|
|
ctx := context.Background()
|
|
t.Run("the live class first, at most four sends at once", func(t *testing.T) {
|
|
synctest.Test(t, func(t *testing.T) {
|
|
b := newRepublishBed(t)
|
|
var old []ReservedVersion
|
|
for _, m := range []string{"o1", "o2", "o3", "o4", "o5"} {
|
|
old = append(old, b.reserve(t, m))
|
|
}
|
|
b.Started = b.now
|
|
b.reserve(t, "live")
|
|
for i, v := range old {
|
|
b.queueAt(t, v, PublishClassStart, b.now.Add(time.Duration(i)*time.Second))
|
|
}
|
|
b.now = b.now.Add(time.Hour) // the live one is queued last, after every old one
|
|
b.holders = map[string][]string{SeatArtifacts: {"oci"}}
|
|
release := make(chan struct{})
|
|
var arrived []string
|
|
var inflight, most int
|
|
send := b.Send
|
|
b.Send = func(ctx context.Context, p Publish) error {
|
|
b.mu.Lock()
|
|
arrived = append(arrived, p.Name)
|
|
inflight++
|
|
most = max(most, inflight)
|
|
b.mu.Unlock()
|
|
<-release
|
|
b.mu.Lock()
|
|
inflight--
|
|
b.mu.Unlock()
|
|
return send(ctx, p)
|
|
}
|
|
b.Go = func(f func()) { go f() }
|
|
if q, err := b.Republish(ctx, "live", ""); err != nil || len(q) != 1 {
|
|
t.Fatalf("queued %v (%v), want the live version", q, err)
|
|
}
|
|
synctest.Wait() // every send the bound lets run waits on release
|
|
b.mu.Lock()
|
|
first := slices.Clone(arrived)
|
|
b.mu.Unlock()
|
|
if len(first) != PublishSendsAtOnce || !slices.Contains(first, "live/prog") {
|
|
t.Errorf("the sends running at once are %v: want %d, the live one among them", first, PublishSendsAtOnce)
|
|
}
|
|
close(release)
|
|
synctest.Wait()
|
|
if len(b.sent) != 6 || most != PublishSendsAtOnce {
|
|
t.Errorf("sent %d, at most %d at once: want all six, %d at once", len(b.sent), most, PublishSendsAtOnce)
|
|
}
|
|
})
|
|
})
|
|
t.Run("a pass lists the keys once for all its sends", func(t *testing.T) {
|
|
b := newRepublishBed(t)
|
|
var vs []ReservedVersion
|
|
for i := range 6 {
|
|
vs = append(vs, b.reserve(t, fmt.Sprintf("m%d", i)))
|
|
}
|
|
for i, v := range vs {
|
|
b.queueAt(t, v, PublishClassStart, b.now.Add(time.Duration(i)*time.Second))
|
|
}
|
|
b.Drain(ctx, "oci")
|
|
if n := b.queue.listings.Load(); len(b.sent) != 6 || n != 2 {
|
|
t.Errorf("sent %d with %d listings, want six sends from one pass and one listing that finds it spent", len(b.sent), n)
|
|
}
|
|
})
|
|
t.Run("a start makes a live key of a build before it a start key", func(t *testing.T) {
|
|
b := newRepublishBed(t)
|
|
v := b.reserve(t, "m")
|
|
b.Started = b.now
|
|
b.queueAt(t, v, PublishClassLive, b.now)
|
|
b.Go = func(func()) {} // the start's drain is not run here
|
|
if err := b.Resume(ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
raw, _, _, _ := b.queue.Get(ctx, QueueKey("oci", "m", v.Version))
|
|
var q QueuedPublish
|
|
if json.Unmarshal(raw, &q) != nil || q.Class != PublishClassStart {
|
|
t.Errorf("the key after the start is %s, want the class %s: its build did not end in this run", raw, PublishClassStart)
|
|
}
|
|
})
|
|
for _, at := range []string{"enqueue", "pass", "start"} {
|
|
t.Run("a withdrawn build never publishes, at the "+at, func(t *testing.T) {
|
|
b := newRepublishBed(t)
|
|
v := b.reserve(t, "m")
|
|
b.holders = map[string][]string{SeatArtifacts: {"oci"}}
|
|
if _, ok, err := b.Reserved.Withdraw(ctx, "m", v.Version); err != nil || !ok {
|
|
t.Fatalf("withdrawn %v (%v)", ok, err)
|
|
}
|
|
switch at {
|
|
case "enqueue":
|
|
b.queueAt(t, v, PublishClassLive, b.now)
|
|
b.Go = func(func()) {} // a key queued before the withdrawal is dropped by the enqueue itself
|
|
if q, _ := b.Republish(ctx, "m", v.Version); len(q) != 0 {
|
|
t.Errorf("queued %v", q)
|
|
}
|
|
case "pass":
|
|
b.queueAt(t, v, PublishClassLive, b.now)
|
|
b.Drain(ctx, "oci")
|
|
case "start":
|
|
b.queueAt(t, v, PublishClassLive, b.now)
|
|
b.Go = func(func()) {}
|
|
if err := b.Resume(ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
keys, _ := b.queue.KeysOf(ctx, QueueFilter)
|
|
if len(b.sent) != 0 || len(keys) != 0 || fmt.Sprint(b.ended) != "[m "+v.Version+"]" {
|
|
t.Errorf("sent %v, keys %v, items ended %v: want nothing sent, the key dropped and m %s's item ended", b.sent, keys, b.ended, v.Version)
|
|
}
|
|
})
|
|
}
|
|
t.Run("a live publish queued mid-pass goes after the sends in flight, before the rest of the start list", func(t *testing.T) {
|
|
synctest.Test(t, func(t *testing.T) {
|
|
b := newRepublishBed(t)
|
|
var old []ReservedVersion
|
|
for _, m := range []string{"o1", "o2", "o3", "o4", "o5", "o6"} {
|
|
old = append(old, b.reserve(t, m))
|
|
}
|
|
b.Started = b.now
|
|
b.reserve(t, "live")
|
|
for i, v := range old {
|
|
b.queueAt(t, v, PublishClassStart, b.now.Add(time.Duration(i)*time.Second))
|
|
}
|
|
b.now = b.now.Add(time.Hour)
|
|
b.holders = map[string][]string{SeatArtifacts: {"oci"}}
|
|
first, then := make(chan struct{}), make(chan struct{}) // the four in flight wait on first, every later send on then
|
|
var arrived []string
|
|
send := b.Send
|
|
b.Send = func(ctx context.Context, p Publish) error {
|
|
b.mu.Lock()
|
|
arrived = append(arrived, p.Name)
|
|
gate := map[bool]chan struct{}{true: first, false: then}[len(arrived) <= PublishSendsAtOnce]
|
|
b.mu.Unlock()
|
|
<-gate
|
|
return send(ctx, p)
|
|
}
|
|
b.Go = func(f func()) { go f() }
|
|
b.drainLater(ctx, "oci")
|
|
synctest.Wait() // four start sends in flight, the pass holding o5 and o6
|
|
if q, err := b.Republish(ctx, "live", ""); err != nil || len(q) != 1 {
|
|
t.Fatalf("queued %v (%v)", q, err)
|
|
}
|
|
close(first)
|
|
synctest.Wait() // the sends after the four: with the live one among them, or o5 and o6 alone when the pass goes on
|
|
b.mu.Lock()
|
|
next := slices.Clone(arrived[PublishSendsAtOnce:])
|
|
b.mu.Unlock()
|
|
if !slices.Contains(next, "live/prog") {
|
|
t.Errorf("after the four in flight the sends are %v, want the live one among them, the pass listed again", next)
|
|
}
|
|
close(then)
|
|
synctest.Wait()
|
|
if len(arrived) != 7 {
|
|
t.Errorf("sent %v, want all seven", arrived)
|
|
}
|
|
})
|
|
})
|
|
t.Run("a build a newer patch or release of its series supersedes is retired at the pass and at the start, never by a newer series", func(t *testing.T) {
|
|
b := newRepublishBed(t)
|
|
v := b.reserve(t, "m")
|
|
b.holders = map[string][]string{SeatArtifacts: {"oci"}}
|
|
if _, err := b.Reserved.Reserve(ctx, "m", "0.2", []string{"m:prog"}, Source{Fingerprint: "src2:m"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
b.queueAt(t, v, PublishClassStart, b.now)
|
|
b.Drain(ctx, "oci")
|
|
if len(b.sent) != 1 || len(b.ended) != 0 {
|
|
t.Errorf("with a standing 0.2: sent %v, ended %v, want m %s sent, its series not superseded (H-A-293)", b.sent, b.ended, v.Version)
|
|
}
|
|
rel := &reserveMem{mem: newMem()}
|
|
raw, _ := json.Marshal(ReleasedRecord{Kept: []ReleasedBuild{{Fingerprint: "f", Version: "0.2.3"}, {Fingerprint: "g", Version: "0.1.9"}}})
|
|
_, _ = rel.Create(ctx, ReleasedKey("m"), raw)
|
|
b.Reserved.Releases = rel
|
|
b.sent = nil
|
|
b.queueAt(t, v, PublishClassStart, b.now)
|
|
b.Drain(ctx, "oci")
|
|
if len(b.sent) != 0 || fmt.Sprint(b.ended) != "[m "+v.Version+"]" {
|
|
t.Errorf("at the pass: sent %v, ended %v, want m %s retired by the release 0.1.9", b.sent, b.ended, v.Version)
|
|
}
|
|
b.ended = nil
|
|
b.queueAt(t, v, PublishClassStart, b.now)
|
|
b.Go = func(func()) {}
|
|
if err := b.Resume(ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if keys, _ := b.queue.KeysOf(ctx, QueueFilter); len(keys) != 0 || fmt.Sprint(b.ended) != "[m "+v.Version+"]" {
|
|
t.Errorf("at the start: keys %v, ended %v, want m %s retired", keys, b.ended, v.Version)
|
|
}
|
|
only := &reserveMem{mem: newMem()}
|
|
raw, _ = json.Marshal(ReleasedRecord{Kept: []ReleasedBuild{{Fingerprint: "f", Version: "0.2.0"}}})
|
|
_, _ = only.Create(ctx, ReleasedKey("n"), raw)
|
|
got, err := (&Reserver{Releases: only}).Retired(ctx, []ReservedVersion{{Module: "n", Version: "0.1.4", BuiltAt: b.now}, {Module: "n", Version: "0.1.6"},
|
|
{Module: "n", Version: "0.3.0", BuiltAt: b.now}, {Module: "p", Version: "0.1.2", BuiltAt: b.now}})
|
|
if err != nil || len(got) != 1 || !strings.Contains(got["n 0.1.4"], "reservation 0.1.6") {
|
|
t.Errorf("retired %v (%v), want only n 0.1.4, by the newer patch 0.1.6; n 0.3.0 and p 0.1.2 kept, a release of 0.2 retiring neither", got, err)
|
|
}
|
|
})
|
|
t.Run("a version taken over is not sent, and its item ended", func(t *testing.T) {
|
|
b := newRepublishBed(t)
|
|
v := b.reserve(t, "m")
|
|
b.queueAt(t, v, PublishClassStart, b.now)
|
|
if _, err := b.Reserved.Reserve(ctx, "m", "0.1", []string{"m:prog"}, Source{Fingerprint: "src2:other"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
b.Drain(ctx, "oci")
|
|
if len(b.sent) != 0 || fmt.Sprint(b.ended) != "[m "+v.Version+"]" {
|
|
t.Errorf("sent %v, ended %v: want nothing sent and the item ended", b.sent, b.ended)
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestThePublishQueueToolAnswersAtAnySize: design 47 H H-A-290 (5) — builder_publish_queue over two thousand queued versions answers
|
|
// within a second and small: counts per holder and class with the oldest and newest queue time, a list capped at fifty in the
|
|
// order they are sent, and one module's item with its class; each state read in bulk where the reader can.
|
|
func TestThePublishQueueToolAnswersAtAnySize(t *testing.T) {
|
|
at := time.Date(2026, 11, 20, 17, 0, 0, 0, time.UTC)
|
|
vals := map[string]json.RawMessage{}
|
|
for i := range 2000 {
|
|
holder, class := "oci", PublishClassStart
|
|
if i%2 == 1 {
|
|
holder = "go"
|
|
}
|
|
if i >= 1990 {
|
|
class = PublishClassLive
|
|
}
|
|
q := QueuedPublish{V: 1, Holder: holder, Module: fmt.Sprintf("m%d", i), Version: "0.1.0", Artifacts: map[string]string{"a": "sha256:aa"}, Queued: at.Add(time.Duration(i) * time.Second), Class: class}
|
|
vals[QueueKey(holder, q.Module, q.Version)], _ = json.Marshal(q)
|
|
}
|
|
gets := 0
|
|
queue := Reader{All: func() (StatePage, error) { return StatePage{Values: vals}, nil },
|
|
Keys: func() ([]string, error) { return slices.Collect(maps.Keys(vals)), nil },
|
|
Get: func(k string) (json.RawMessage, bool, error) { gets++; v, ok := vals[k]; return v, ok, nil }}
|
|
none := Reader{Keys: func() ([]string, error) { return nil, nil }}
|
|
start := time.Now()
|
|
a, err := AnswerQueue(queue, none, none, "", "")
|
|
took := time.Since(start)
|
|
raw, _ := json.Marshal(a)
|
|
if err != nil || took > time.Second || a.Total != 2000 || len(a.Queue) != PublishQueueListCap || a.Listed != PublishQueueListCap || len(raw) > 64<<10 || gets != 0 {
|
|
t.Fatalf("answered %d of %d in %s, %d bytes, %d single reads (%v): want all counted, fifty listed, within a second, small, in bulk", len(a.Queue), a.Total, took, len(raw), gets, err)
|
|
}
|
|
if fmt.Sprintln(a.Counts[1].Holder, a.Counts[1].Class, a.Counts[1].Count, a.Counts[1].Oldest.Equal(at.Add(1991*time.Second)), a.Counts[1].Newest.Equal(at.Add(1999*time.Second))) != "go "+PublishClassLive+" 5 true true\n" || len(a.Counts) != 4 {
|
|
t.Errorf("counts %+v, want per holder and class with their oldest and newest", a.Counts)
|
|
}
|
|
if a.Queue[0].Class != PublishClassLive || a.Queue[0].Holder != "go" {
|
|
t.Errorf("the list opens with %+v, want the go holder's live class, sent first", a.Queue[0])
|
|
}
|
|
one, err := AnswerQueue(queue, none, none, "m1995", "")
|
|
if err != nil || len(one.Queue) != 1 || one.Queue[0].Class != PublishClassLive || one.Total != 2000 {
|
|
t.Errorf("one module's answer %+v (%v), want its item with its class", one.Queue, err)
|
|
}
|
|
if a.Capped || len(a.Read) != 0 {
|
|
t.Errorf("a state one page holds is answered capped: %+v", a.Read)
|
|
}
|
|
queue.All = func() (StatePage, error) { return StatePage{Values: vals, More: true, Keys: 5000, Bytes: 3 << 20}, nil }
|
|
if c, err := AnswerQueue(queue, none, none, "", ""); err != nil || !c.Capped || len(c.Read) != 1 || c.Read[0].State != PublishQueueState ||
|
|
c.Read[0].KeysRead != 2000 || c.Read[0].StateKeys != 5000 || c.Read[0].StateBytes != 3<<20 || c.Total != 2000 {
|
|
t.Errorf("a state past its one page answered capped %v, read %+v (%v): want capped, 2000 keys read of 5000, its size said (H-A-293)", c.Capped, c.Read, err)
|
|
}
|
|
queue.All = func() (StatePage, error) { return StatePage{}, errors.ErrUnsupported }
|
|
if b, err := AnswerQueue(queue, none, none, "", ""); err != nil || b.Total != 2000 || gets != 2000 {
|
|
t.Errorf("a reader with no bulk read answered %d (%v) with %d single reads, want every key read one by one", b.Total, err, gets)
|
|
}
|
|
}
|