Live, a published at a version fourteen reservations share cost three seconds: the fallback by version read every reservation there, and the journal line read them all again, so the backlog drained at fifty a minute. The published now hands the reservations it read (each once, a second pass taking what the first read) to its journal line. The fallback reads the new index key of the reservations at a version whose build has not recorded every digest (kept at reserve and where a digest is recorded, written again at the start), the only ones a published can be kept on; the line counts the rest from the index by version without reading them. Before that pass the handler says in progress to the bus. Builds: design 47 H H-A-280, H-A-271
145 lines
6.3 KiB
Go
145 lines
6.3 KiB
Go
package versions
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"strings"
|
|
"sync/atomic"
|
|
"testing"
|
|
)
|
|
|
|
// countingReserve counts the listings of the reservations and the reads of a reservation key (two tokens), so a test sees that
|
|
// a published reads its reservation and no other.
|
|
type countingReserve struct {
|
|
*reserveMem
|
|
lists, reads atomic.Int64
|
|
}
|
|
|
|
func (c *countingReserve) KeysOf(ctx context.Context, filter string) ([]string, error) {
|
|
c.lists.Add(1)
|
|
return c.reserveMem.KeysOf(ctx, filter)
|
|
}
|
|
|
|
func (c *countingReserve) Get(ctx context.Context, key string) ([]byte, uint64, bool, error) {
|
|
if !strings.HasPrefix(key, "index.") {
|
|
c.reads.Add(1)
|
|
}
|
|
return c.reserveMem.Get(ctx, key)
|
|
}
|
|
|
|
// TestTheIndexFindsAPublishedReservationInOneRead: design 47 H H-A-269 (1), H-A-271 — a registry seat's published finds its
|
|
// reservation through the index by digest, reading that reservation alone and listing none; a published whose digest no
|
|
// reservation holds is judged from its version's keys (kept on a build that recorded no digest yet, A-415), never a scan; the
|
|
// index goes with a release and a drop, and is written again at the start from reservations written before it existed.
|
|
func TestTheIndexFindsAPublishedReservationInOneRead(t *testing.T) {
|
|
ctx := context.Background()
|
|
fill := func(t *testing.T) (*Reserver, *countingReserve) {
|
|
store := &countingReserve{reserveMem: &reserveMem{mem: newMem()}}
|
|
r := &Reserver{Store: store, ReleasedOf: func(context.Context, string) ([]string, error) { return nil, nil }}
|
|
for i := range 40 {
|
|
m := fmt.Sprintf("m%02d", i)
|
|
if _, err := r.Reserve(ctx, m, "0.1", []string{m + ":a"}, Source{Fingerprint: "fp" + m}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if i%2 == 0 { // half are built, each with its own digest
|
|
if _, err := r.Built(ctx, m, "0.1.0", m+":a", "sha256:"+m, nil); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
store.lists.Store(0)
|
|
store.reads.Store(0)
|
|
return r, store
|
|
}
|
|
t.Run("a published by digest reads its one reservation", func(t *testing.T) {
|
|
r, store := fill(t)
|
|
marked, _, err := r.Published(ctx, "m10-a", "v0.1.0", "sha256:m10")
|
|
if err != nil || len(marked) != 1 || marked[0].Reserved.Module != "m10" || marked[0].Artifact != "m10:a" {
|
|
t.Fatalf("the published marked %+v (%v), want m10:a", marked, err)
|
|
}
|
|
if l, n := store.lists.Load(), store.reads.Load(); l != 0 || n != 1 {
|
|
t.Errorf("the published listed %d times and read %d reservations, want none listed and one read", l, n)
|
|
}
|
|
})
|
|
t.Run("a digest no reservation holds is judged from its version's unbuilt keys", func(t *testing.T) {
|
|
r, store := fill(t)
|
|
marked, kept, err := r.Published(ctx, "m11-a", "0.1.0", "sha256:early")
|
|
if err != nil || len(marked) != 0 {
|
|
t.Fatalf("an unbuilt digest marked %v (%v)", marked, err)
|
|
}
|
|
// The 20 unbuilt reservations at 0.1.0 keep it as heard (A-415); the 20 built ones are not read at all (H-A-280).
|
|
if len(kept) != 20 || store.lists.Load() != 0 || store.reads.Load() != 20 {
|
|
t.Errorf("kept on %d (want 20), listed %d (want 0), read %d (want only the 20 unbuilt at 0.1.0)", len(kept), store.lists.Load(), store.reads.Load())
|
|
}
|
|
at, err := r.AtVersion(ctx, "0.9.9")
|
|
if err != nil || len(at) != 0 || store.lists.Load() != 0 {
|
|
t.Errorf("a version no reservation stands at answered %v (%v), listed %d", at, err, store.lists.Load())
|
|
}
|
|
})
|
|
t.Run("a published at a version many share reads each reservation once and hands them on", func(t *testing.T) {
|
|
r, store := fill(t)
|
|
// A stale digest entry naming unbuilt reservations too: the second pass takes them as the first read them.
|
|
stale, _ := json.Marshal(IndexEntry{Keys: []string{ReservedKey("m01", "0.1"), ReservedKey("m03", "0.1")}})
|
|
if _, err := store.Create(ctx, IndexDigestKey("sha256:stale"), stale); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
slow := 0
|
|
out, err := r.PublishedRead(ctx, "x", "0.1.0", "sha256:stale", func() { slow++ })
|
|
if err != nil || len(out.Kept) != 20 || len(out.Read) != 20 || slow != 1 {
|
|
t.Fatalf("kept %d, read %d, told slow %d (%v): want 20 kept, 20 read and handed on, slow told once", len(out.Kept), len(out.Read), slow, err)
|
|
}
|
|
if n := store.reads.Load(); n != 20 {
|
|
t.Errorf("%d reservation reads, want each of the 20 read once", n)
|
|
}
|
|
})
|
|
t.Run("a release and a drop take the reservation out of the index", func(t *testing.T) {
|
|
r, store := fill(t)
|
|
if _, err := r.Released(ctx, "m10", "0.1.0"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := r.Drop(ctx, "m12", "0.1"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, k := range []string{IndexDigestKey("sha256:m10"), IndexDigestKey("sha256:m12")} {
|
|
if _, _, found, _ := store.Get(ctx, k); found {
|
|
t.Errorf("%s stands after its reservation went", k)
|
|
}
|
|
}
|
|
keys, _ := r.indexed(ctx, IndexVersionKey("0.1.0"))
|
|
for _, k := range keys {
|
|
if k == ReservedKey("m10", "0.1") || k == ReservedKey("m12", "0.1") {
|
|
t.Errorf("the version's index still names %s", k)
|
|
}
|
|
}
|
|
})
|
|
t.Run("the index is written again at the start from the reservations", func(t *testing.T) {
|
|
store := &countingReserve{reserveMem: &reserveMem{mem: newMem()}}
|
|
r := &Reserver{Store: store}
|
|
// A reservation written before the index existed, and an index entry naming a reservation that is gone.
|
|
raw, _ := json.Marshal(ReservedVersion{V: 1, Module: "old", Series: "0.2", Version: "0.2.4", Artifacts: map[string]string{"old:a": "sha256:old"}})
|
|
if _, err := store.Create(ctx, ReservedKey("old", "0.2"), raw); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
stale, _ := json.Marshal(IndexEntry{Keys: []string{ReservedKey("gone", "0.1")}})
|
|
if _, err := store.Create(ctx, IndexDigestKey("sha256:gone"), stale); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if n, err := r.Reindex(ctx); err != nil || n != 1 {
|
|
t.Fatalf("the reindex read %d reservations (%v), want 1", n, err)
|
|
}
|
|
if _, _, found, _ := store.Get(ctx, IndexDigestKey("sha256:gone")); found {
|
|
t.Error("the index entry of a reservation that is gone stands after the reindex")
|
|
}
|
|
if keys, _ := store.KeysOf(ctx, AllFilter); len(keys) != 1 {
|
|
t.Errorf("the reservations list %v: the index keys are listed among them", keys)
|
|
}
|
|
store.lists.Store(0)
|
|
store.reads.Store(0)
|
|
marked, _, err := r.Published(ctx, "old-a", "0.2.4", "sha256:old")
|
|
if err != nil || len(marked) != 1 || store.lists.Load() != 0 || store.reads.Load() != 1 {
|
|
t.Errorf("after the reindex the published marked %v (%v), listed %d, read %d", marked, err, store.lists.Load(), store.reads.Load())
|
|
}
|
|
})
|
|
}
|