jschoubben
275ddd76e8
Once chain_moved records the kind, a plan is a key of the rollouts bucket under its id and the open batch is the same key in state assembling. A save refuses a copy another save moved since (the plan's own Revision, kept in its value, counts saves) and keeps the merges the record holds, so a copy read before a merge moved cannot lay it back. The merges a batch or walk answers are the record's held field, with the columns the table had; a merge no plan answers stays, flagged, in the record that held it last, or in the record kept for those. A merge moved to a plan is written to the receiving record first and then taken from the giving one; one found in both is read from the one it entered last and repaired at the next cut. Plans and merges are read from a view kept by one watch of the bucket. A bus that does not answer, a lease lost and a key moved are now not-now like the store being away, so a merge whose plan could not be written is held and handed over again, never acknowledged. The start moves release_plan and batched_merge into the bucket, one kind, counted against both tables.
127 lines
4.4 KiB
Go
127 lines
4.4 KiB
Go
package inventory
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"sync"
|
|
|
|
"github.com/jackc/pgx/v5"
|
|
"github.com/jackc/pgx/v5/pgconn"
|
|
|
|
"github.com/novox/mesh-controller/internal/chain"
|
|
)
|
|
|
|
// **The chain moves to the bus kind by kind** (novox/hq ADR 0408 §8, issue 981). The tables of builds, rollouts and
|
|
// assignments are copied once into the chain's buckets by the serving controller at its start (MoveChain), which then
|
|
// records each kind it moved in chain_moved (migration 0104). **Until a kind is recorded there nothing reads its bucket;
|
|
// once it is, nothing reads its tables**: ChainReads answers which, and every method of a kind asks it first.
|
|
|
|
// The kinds of the chain, as chain_moved names them.
|
|
const (
|
|
KindBuilds = "builds"
|
|
KindRollouts = "rollouts"
|
|
)
|
|
|
|
// testChains are the chains in memory a test made for its store, by the store's address: every inventory opened on that
|
|
// store is given the same chain, as every process of a mesh is on the same bus. Empty outside a test.
|
|
var testChains sync.Map
|
|
|
|
// ErrNoChain is a kind moved to the bus read by an inventory that has no chain attached: a process that did not
|
|
// open the bus. Refused loudly, never answered from the tables the move left behind.
|
|
var ErrNoChain = errors.New("this kind of record lives on the bus, and this process has not opened the bus")
|
|
|
|
// movedKinds is which kinds this process has read as moved: once moved, always moved, so it is read from the store
|
|
// until it is true and not after.
|
|
type movedKinds struct {
|
|
mu sync.Mutex
|
|
kind map[string]bool
|
|
open ChainOpener
|
|
// view is the rollouts bucket kept in memory by one watch (issue 1092); pending are the merges added to a plan that
|
|
// is not saved yet.
|
|
view *rolloutView
|
|
pending map[string]pendingMerge
|
|
}
|
|
|
|
// ChainOpener opens the chain on the bus when a process first needs it: a command that reads and never moved anything has
|
|
// no bus connection until a kind it reads turns out to be moved.
|
|
type ChainOpener func(ctx context.Context) (*chain.Chain, error)
|
|
|
|
// UseChainOpener gives the inventory the means to open the chain when it needs it and none is attached.
|
|
func (i *Inventory) UseChainOpener(open ChainOpener) {
|
|
i.moved.mu.Lock()
|
|
i.moved.open = open
|
|
i.moved.mu.Unlock()
|
|
}
|
|
|
|
// UseChain attaches the chain the moved kinds are read and written through. The serving controller attaches the bus's,
|
|
// holding the lease for its writes; a test attaches one in memory.
|
|
func (i *Inventory) UseChain(c *chain.Chain) {
|
|
i.moved.mu.Lock()
|
|
defer i.moved.mu.Unlock()
|
|
i.chain = c
|
|
if i.moved.view != nil {
|
|
i.moved.view.stop()
|
|
i.moved.view = nil
|
|
}
|
|
}
|
|
|
|
// attached is the chain this inventory has, nil when none.
|
|
func (i *Inventory) attached() *chain.Chain {
|
|
i.moved.mu.Lock()
|
|
defer i.moved.mu.Unlock()
|
|
return i.chain
|
|
}
|
|
|
|
// ChainReads says whether a kind of the chain is read from its bucket: chain_moved names it. It answers the chain to read
|
|
// through, and ErrNoChain when the kind is moved and none is attached.
|
|
func (i *Inventory) ChainReads(ctx context.Context, kind string) (*chain.Chain, bool, error) {
|
|
i.moved.mu.Lock()
|
|
known := i.moved.kind[kind]
|
|
i.moved.mu.Unlock()
|
|
if !known {
|
|
var moved bool
|
|
err := i.store.Pool().QueryRow(ctx, `select counts ? $1 from chain_moved`, kind).Scan(&moved)
|
|
var pgErr *pgconn.PgError
|
|
if errors.Is(err, pgx.ErrNoRows) || (errors.As(err, &pgErr) && pgErr.Code == "42P01") {
|
|
// No row, or a store older than the migration that makes the table: nothing moved.
|
|
return nil, false, nil
|
|
}
|
|
if err != nil {
|
|
return nil, false, fmt.Errorf("whether %s moved to the bus cannot be read: %w", kind, err)
|
|
}
|
|
if !moved {
|
|
return nil, false, nil
|
|
}
|
|
i.moved.mu.Lock()
|
|
if i.moved.kind == nil {
|
|
i.moved.kind = map[string]bool{}
|
|
}
|
|
i.moved.kind[kind] = true
|
|
i.moved.mu.Unlock()
|
|
}
|
|
i.moved.mu.Lock()
|
|
defer i.moved.mu.Unlock()
|
|
if i.chain == nil && i.moved.open != nil {
|
|
c, err := i.moved.open(ctx)
|
|
if err != nil {
|
|
return nil, false, fmt.Errorf("%w: %s: %v", ErrNoChain, kind, err)
|
|
}
|
|
i.chain = c
|
|
}
|
|
if i.chain == nil {
|
|
return nil, false, fmt.Errorf("%w: %s", ErrNoChain, kind)
|
|
}
|
|
return i.chain, true, nil
|
|
}
|
|
|
|
// ChainMoved is, per kind moved, how many records the move wrote; empty before any is.
|
|
func (i *Inventory) ChainMoved(ctx context.Context) (map[string]int, error) {
|
|
var counts map[string]int
|
|
err := i.store.Pool().QueryRow(ctx, `select counts from chain_moved`).Scan(&counts)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return map[string]int{}, nil
|
|
}
|
|
return counts, err
|
|
}
|