jschoubben
f89d870308
Once chain_moved records the kind, RecordBuild and every build read go through the chain (reuse key and published added); before that the tables are read as before. The serving controller copies the rows at its start, holding the lease: idempotent per key, rows counted against keys, the largest value measured, a refusal (urgent condition, nothing switched) on a count that differs or a value over the bus's largest, and a re-read when the table took a row meanwhile. ForTest attaches the chain in memory with builds moved; ForTestBefore leaves it unmoved. Build requests, gates and the other kinds are still in their tables.
266 lines
9.0 KiB
Go
266 lines
9.0 KiB
Go
package inventory
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/jackc/pgx/v5"
|
|
|
|
"github.com/novox/mesh-controller/internal/broker"
|
|
"github.com/novox/mesh-controller/internal/chain"
|
|
)
|
|
|
|
// **The move** (novox/hq ADR 0408 §8, issue 981 note 7 Q2): the serving controller writes the rows of a kind into its
|
|
// bucket at its start, holding the lease and after the buckets exist, and records the kind in chain_moved. Idempotent: a
|
|
// key that exists is already moved and is never overwritten, so a bucket value written since is not laid over by the row
|
|
// it came from. It counts the rows against the keys, logs the largest value, and **refuses** (a Refusal, which the
|
|
// controller raises as an urgent condition) on a count that differs or a value over the bus's largest, with nothing
|
|
// switched: a kind is recorded moved only once all of it is in the bucket.
|
|
|
|
// Refusal is a move that stopped without switching a kind, and why. It is permanent until the cause is put right; any
|
|
// other error of a move (the bus away, a write not granted) is tried again.
|
|
type Refusal struct {
|
|
Kind, Why string
|
|
}
|
|
|
|
func (r *Refusal) Error() string {
|
|
return fmt.Sprintf("the move of %s to the bus is refused: %s", r.Kind, r.Why)
|
|
}
|
|
|
|
// MoveReport is what a move of one kind did.
|
|
type MoveReport struct {
|
|
Kind string
|
|
// Rows is how many records the tables held, Written how many keys this move made, and Present how many already
|
|
// held a value (moved by an earlier start).
|
|
Rows, Written, Present int
|
|
// Largest is the biggest value, in bytes.
|
|
Largest int
|
|
// Already is a kind an earlier start moved: nothing was done.
|
|
Already bool
|
|
}
|
|
|
|
// mover is one kind of the chain: its rows, read from its tables, as the keys and values they become.
|
|
type mover struct {
|
|
kind string
|
|
// rows reads the tables: each record's key and its value, whole.
|
|
rows func(ctx context.Context) ([]moveRow, error)
|
|
// create writes one record under its key; chain.ErrExists when the key holds a value.
|
|
create func(ctx context.Context, c *chain.Chain, row moveRow) error
|
|
// keys are the keys the bucket holds.
|
|
keys func(ctx context.Context, c *chain.Chain) ([]string, error)
|
|
// count is how many rows the tables hold now.
|
|
count func(ctx context.Context, tx pgx.Tx) (int, error)
|
|
// lock keeps the tables from taking a row while the switch is recorded.
|
|
lock string
|
|
}
|
|
|
|
type moveRow struct {
|
|
key string
|
|
value any
|
|
size int
|
|
}
|
|
|
|
func (i *Inventory) movers() []mover {
|
|
return []mover{{
|
|
kind: KindBuilds,
|
|
rows: func(ctx context.Context) ([]moveRow, error) {
|
|
builds, err := i.allBuildRows(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out := make([]moveRow, 0, len(builds))
|
|
for _, b := range builds {
|
|
v := toChainBuild(b)
|
|
body, err := json.Marshal(v)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, moveRow{key: chainBuildKey(b.ID), value: v, size: len(body)})
|
|
}
|
|
return out, nil
|
|
},
|
|
create: func(ctx context.Context, c *chain.Chain, row moveRow) error {
|
|
_, err := c.Builds.Create(ctx, row.key, row.value.(chain.Build))
|
|
return err
|
|
},
|
|
keys: func(ctx context.Context, c *chain.Chain) ([]string, error) { return c.Builds.Keys(ctx) },
|
|
count: func(ctx context.Context, tx pgx.Tx) (int, error) {
|
|
var n int
|
|
err := tx.QueryRow(ctx, `select count(*) from build`).Scan(&n)
|
|
return n, err
|
|
},
|
|
lock: `lock table build in share mode`,
|
|
}}
|
|
}
|
|
|
|
// MoveChain moves every kind not moved yet, in order, and says what it did. It needs the chain attached and the lease
|
|
// held (the chain's writes ask). It stops at the first kind that fails.
|
|
func (i *Inventory) MoveChain(ctx context.Context, say func(format string, args ...any)) ([]MoveReport, error) {
|
|
if say == nil {
|
|
say = func(string, ...any) {}
|
|
}
|
|
if i.attached() == nil {
|
|
return nil, ErrNoChain
|
|
}
|
|
var out []MoveReport
|
|
for _, m := range i.movers() {
|
|
r, err := i.moveKind(ctx, m, say)
|
|
if err != nil {
|
|
return out, err
|
|
}
|
|
out = append(out, r)
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// movePasses is how often a move reads the tables again when they took a row while it wrote: the controller before this
|
|
// one may still have been writing as the lease changed hands.
|
|
const movePasses = 5
|
|
|
|
func (i *Inventory) moveKind(ctx context.Context, m mover, say func(string, ...any)) (MoveReport, error) {
|
|
report := MoveReport{Kind: m.kind}
|
|
moved, err := i.ChainMoved(ctx)
|
|
if err != nil {
|
|
return report, err
|
|
}
|
|
if _, done := moved[m.kind]; done {
|
|
report.Already = true
|
|
return report, nil
|
|
}
|
|
for pass := 1; pass <= movePasses; pass++ {
|
|
rows, err := m.rows(ctx)
|
|
if err != nil {
|
|
return report, fmt.Errorf("the %s cannot be read from the tables: %w", m.kind, err)
|
|
}
|
|
report.Rows, report.Largest = len(rows), 0
|
|
// Every value measured before any is written: a value over the bus's largest stops the move with nothing
|
|
// written (ADR 0408 §6), never cut.
|
|
for _, r := range rows {
|
|
report.Largest = max(report.Largest, r.size)
|
|
if r.size > broker.ChainValueBytes {
|
|
return report, &Refusal{m.kind, fmt.Sprintf("the value of %s is %d bytes and the bus holds at most %d; "+
|
|
"nothing is cut, so the record must be made smaller first", r.key, r.size, broker.ChainValueBytes)}
|
|
}
|
|
}
|
|
report.Written, report.Present = 0, 0
|
|
for _, r := range rows {
|
|
switch err := m.create(ctx, i.attached(), r); {
|
|
case err == nil:
|
|
report.Written++
|
|
case errors.Is(err, chain.ErrExists):
|
|
report.Present++
|
|
default:
|
|
return report, fmt.Errorf("%s %s is not written to the bus: %w", m.kind, r.key, err)
|
|
}
|
|
}
|
|
// Rows against keys: every row's key is in the bucket.
|
|
keys, err := m.keys(ctx, i.attached())
|
|
if err != nil {
|
|
return report, fmt.Errorf("the keys of the %s cannot be read back: %w", m.kind, err)
|
|
}
|
|
have := make(map[string]bool, len(keys))
|
|
for _, k := range keys {
|
|
have[k] = true
|
|
}
|
|
for _, r := range rows {
|
|
if !have[r.key] {
|
|
return report, &Refusal{m.kind, fmt.Sprintf("the tables hold %d records and the bucket does not hold %s", len(rows), r.key)}
|
|
}
|
|
}
|
|
settled, err := i.switchKind(ctx, m, report)
|
|
if err != nil {
|
|
return report, err
|
|
}
|
|
if settled {
|
|
say("moved the %s to the bus: %d records, %d written now and %d already there, the largest %d bytes",
|
|
m.kind, report.Rows, report.Written, report.Present, report.Largest)
|
|
return report, nil
|
|
}
|
|
say("the %s took a row while they were moved, so they are read again (pass %d of %d)", m.kind, pass, movePasses)
|
|
}
|
|
return report, &Refusal{m.kind, fmt.Sprintf("the tables kept taking rows through %d passes; another controller is still writing them", movePasses)}
|
|
}
|
|
|
|
// switchKind records the kind as moved, in one transaction that holds the tables against writes and finds their count
|
|
// as the move read it: false when they took a row since.
|
|
func (i *Inventory) switchKind(ctx context.Context, m mover, r MoveReport) (bool, error) {
|
|
tx, err := i.store.Pool().Begin(ctx)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
if _, err := tx.Exec(ctx, m.lock); err != nil {
|
|
return false, err
|
|
}
|
|
n, err := m.count(ctx, tx)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
if n != r.Rows {
|
|
return false, nil
|
|
}
|
|
counts, _ := json.Marshal(map[string]int{m.kind: r.Rows})
|
|
largest, _ := json.Marshal(map[string]int{m.kind: r.Largest})
|
|
if _, err := tx.Exec(ctx,
|
|
`insert into chain_moved (counts, largest) values ($1, $2)
|
|
on conflict (only_one) do update
|
|
set counts = chain_moved.counts || excluded.counts, largest = chain_moved.largest || excluded.largest,
|
|
moved_at = now()`, counts, largest); err != nil {
|
|
return false, err
|
|
}
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return false, err
|
|
}
|
|
i.moved.mu.Lock()
|
|
if i.moved.kind == nil {
|
|
i.moved.kind = map[string]bool{}
|
|
}
|
|
i.moved.kind[m.kind] = true
|
|
i.moved.mu.Unlock()
|
|
return true, nil
|
|
}
|
|
|
|
// allBuildRows is every build of the table, whole.
|
|
func (i *Inventory) allBuildRows(ctx context.Context) ([]Build, error) {
|
|
rows, err := i.store.Pool().Query(ctx,
|
|
`select id, repository, ref, coalesce(module, ''), commit_hash, built_on, failed, made, source_path, manifest,
|
|
built_against, built_contexts, build_sources, source_fingerprint, asked, at
|
|
from build order by at, id`)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var out []Build
|
|
for rows.Next() {
|
|
var b Build
|
|
var made, manifest, against, read, sources []byte
|
|
var asked *time.Time
|
|
if err := rows.Scan(&b.ID, &b.Repository, &b.Ref, &b.Module, &b.Commit, &b.On, &b.Failed, &made, &b.Path,
|
|
&manifest, &against, &read, &sources, &b.SourceFingerprint, &asked, &b.At); err != nil {
|
|
return nil, err
|
|
}
|
|
if asked != nil {
|
|
b.Asked = *asked
|
|
}
|
|
b.Manifest = manifest
|
|
for _, part := range []struct {
|
|
raw []byte
|
|
to any
|
|
who string
|
|
}{{made, &b.Made, "made"}, {against, &b.Against, "built_against"}, {read, &b.Read, "built_contexts"},
|
|
{sources, &b.Sources, "build_sources"}} {
|
|
if len(part.raw) == 0 {
|
|
continue
|
|
}
|
|
if err := json.Unmarshal(part.raw, part.to); err != nil {
|
|
return nil, fmt.Errorf("build %s: %s is not readable: %w", b.ID, part.who, err)
|
|
}
|
|
}
|
|
out = append(out, b)
|
|
}
|
|
return out, rows.Err()
|
|
}
|