The builder adopts meshcatalogclient's branch follower on its views reader (A-5, A-15): the modules, their manifests (kept from the entry that holds them, by its digest), their packages and each package's name in its ecosystem are read from the catalog half's entries, never the indexer's modules, manifests, candidates and packages views; an entry of a branch other than the module's first builds its fingerprint and supersedes only its own branch's older one; the start's sweep runs once every followed half's first view is in; the builder's tools bundle reads package names through the same follower. A run's candidate is no input of the builder (A-84): its read of the indexer's candidates view goes, and the entry point for a run's build ask is not built (no line gives the ask's form). The seats' events the builder's own handler takes are named per seat so the follower's events have one taker. Builds: design 47 G §348, §479, §614, A-5, A-15, A-84 Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
105 lines
2.7 KiB
Go
105 lines
2.7 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
|
|
"github.com/nats-io/nats.go/jetstream"
|
|
|
|
"mesh-delivery-builder/internal/build"
|
|
)
|
|
|
|
// bucketOpener is the part of the bus the watches use.
|
|
type bucketOpener interface {
|
|
KeyValue(ctx context.Context, bucket string) (jetstream.KeyValue, error)
|
|
}
|
|
|
|
// kvStore is the builds bucket as the builder's store: create and compare-and-set.
|
|
type kvStore struct{ kv jetstream.KeyValue }
|
|
|
|
func conflict(err error) error {
|
|
if errors.Is(err, jetstream.ErrKeyExists) || errors.Is(err, jetstream.ErrKeyRevisionMismatch) {
|
|
return build.ErrConflict
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (s kvStore) Get(ctx context.Context, key string) ([]byte, uint64, bool, error) {
|
|
e, err := s.kv.Get(ctx, key)
|
|
if errors.Is(err, jetstream.ErrKeyNotFound) {
|
|
return nil, 0, false, nil
|
|
}
|
|
if err != nil {
|
|
return nil, 0, false, err
|
|
}
|
|
return e.Value(), e.Revision(), true, nil
|
|
}
|
|
|
|
func (s kvStore) Create(ctx context.Context, key string, value []byte) (uint64, error) {
|
|
rev, err := s.kv.Create(ctx, key, value)
|
|
return rev, conflict(err)
|
|
}
|
|
|
|
func (s kvStore) Update(ctx context.Context, key string, value []byte, revision uint64) (uint64, error) {
|
|
rev, err := s.kv.Update(ctx, key, value, revision)
|
|
return rev, conflict(err)
|
|
}
|
|
|
|
func (s kvStore) Keys(ctx context.Context) ([]string, error) {
|
|
keys, err := s.kv.Keys(ctx)
|
|
if errors.Is(err, jetstream.ErrNoKeysFound) {
|
|
return nil, nil
|
|
}
|
|
return keys, err
|
|
}
|
|
|
|
func opOf(e jetstream.KeyValueEntry) bool { return e.Operation() == jetstream.KeyValuePut }
|
|
|
|
// settle reads the entries a watcher holds now, up to its mark of the last values, and returns the watcher for the
|
|
// changes that follow.
|
|
func settle(ctx context.Context, kv jetstream.KeyValue, each func(jetstream.KeyValueEntry)) (jetstream.KeyWatcher, error) {
|
|
w, err := kv.WatchAll(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return settled(ctx, w, each)
|
|
}
|
|
|
|
// settled hands each entry the watch delivers before its end-of-initial marker to each, and answers the watch.
|
|
func settled(ctx context.Context, w jetstream.KeyWatcher, each func(jetstream.KeyValueEntry)) (jetstream.KeyWatcher, error) {
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
w.Stop()
|
|
return nil, ctx.Err()
|
|
case e, ok := <-w.Updates():
|
|
if !ok {
|
|
return nil, errors.New("the watch ended")
|
|
}
|
|
if e == nil {
|
|
return w, nil
|
|
}
|
|
each(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
// follow hands each change of a watcher to each until ctx ends; a watch that ends is an error, and the process manager
|
|
// starts the program again.
|
|
func follow(ctx context.Context, w jetstream.KeyWatcher, each func(jetstream.KeyValueEntry)) error {
|
|
defer w.Stop()
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return nil
|
|
case e, ok := <-w.Updates():
|
|
if !ok {
|
|
return errors.New("a watch ended")
|
|
}
|
|
if e != nil {
|
|
each(e)
|
|
}
|
|
}
|
|
}
|
|
}
|