The publishes the builder heard lived only in its memory, so a build waiting for a package published before a restart waited the whole bound and failed although the registry held the version. Before it waits, the build asks the Go package registry seat's versions once for each unpinned path and takes the newest in the accepted series through PackagePublished; a failed read is said and the wait goes on by the published events. Builds: design 47 H H-A-194, H-A-192, H-A-165
273 lines
8.8 KiB
Go
273 lines
8.8 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/nats-io/nats.go"
|
|
"github.com/nats-io/nats.go/jetstream"
|
|
|
|
"git.novox.be/novox/mesh-contracts/health-and-repair/go/seats/meshconditions"
|
|
gitseat "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/git"
|
|
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/gopackageregistry"
|
|
"git.novox.be/novox/mesh-sdk/go/process"
|
|
|
|
"mesh-delivery-builder/internal/build"
|
|
"mesh-delivery-builder/internal/versions"
|
|
)
|
|
|
|
// awaitedVersions is the state versions as versions.Store: bound once the bus holds it (the grants part makes it, issue
|
|
// 1790); until then every use is an error, so a trunk build is built unnumbered and said (build.Builder.number).
|
|
type awaitedVersions struct {
|
|
b *process.AwaitedBucket
|
|
// bucket names the state in the error of one not on the bus yet; empty is the versions'.
|
|
bucket string
|
|
}
|
|
|
|
var errVersionsMissing = errors.New("the state " + versions.State + " is not on the bus yet")
|
|
|
|
func (s awaitedVersions) kv() (jetstream.KeyValue, error) {
|
|
if kv := s.b.KV(); kv != nil {
|
|
return kv, nil
|
|
}
|
|
if s.bucket != "" {
|
|
return nil, errors.New("the state " + s.bucket + " is not on the bus yet")
|
|
}
|
|
return nil, errVersionsMissing
|
|
}
|
|
|
|
func (s awaitedVersions) Get(ctx context.Context, key string) ([]byte, uint64, bool, error) {
|
|
kv, err := s.kv()
|
|
if err != nil {
|
|
return nil, 0, false, err
|
|
}
|
|
e, err := 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 versionsConflict(err error) error {
|
|
if errors.Is(err, jetstream.ErrKeyExists) || errors.Is(err, jetstream.ErrKeyRevisionMismatch) {
|
|
return versions.ErrConflict
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (s awaitedVersions) Create(ctx context.Context, key string, value []byte) (uint64, error) {
|
|
kv, err := s.kv()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
rev, err := kv.Create(ctx, key, value)
|
|
return rev, versionsConflict(err)
|
|
}
|
|
|
|
func (s awaitedVersions) Update(ctx context.Context, key string, value []byte, revision uint64) (uint64, error) {
|
|
kv, err := s.kv()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
rev, err := kv.Update(ctx, key, value, revision)
|
|
return rev, versionsConflict(err)
|
|
}
|
|
|
|
func (s awaitedVersions) KeysOf(ctx context.Context, filter string) ([]string, error) {
|
|
kv, err := s.kv()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
l, err := kv.ListKeysFiltered(ctx, filter)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() { _ = l.Stop() }()
|
|
var out []string
|
|
for k := range l.Keys() {
|
|
out = append(out, k)
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// publishedVersionsVia asks the Go package registry seat's verb versions for one package path (design 47 H H-A-194): its
|
|
// versions, newest first.
|
|
func publishedVersionsVia(call toolCaller) func(context.Context, string) ([]string, error) {
|
|
return func(_ context.Context, path string) ([]string, error) {
|
|
raw, err := call("seat:"+gopackageregistry.Seat+"."+gopackageregistry.VerbVersions, gopackageregistry.VersionsInput{Name: path})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var a gopackageregistry.VersionsAnswer
|
|
if err := json.Unmarshal(raw, &a); err != nil {
|
|
return nil, fmt.Errorf("%s's versions answered what is no list of versions: %w", gopackageregistry.Seat, err)
|
|
}
|
|
var out []string
|
|
for _, v := range a.Versions {
|
|
if v.Version != "" {
|
|
out = append(out, v.Version)
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
}
|
|
|
|
// floorVia is the floor's three sources as calls of the builder's own account (design 51 *The floor*): the seat's verb
|
|
// versions, the seat git's tags and the requirements the catalog half's entries name (A-119). A call that fails is that source
|
|
// silent.
|
|
func floorVia(call toolCaller, requirements func(context.Context, string) ([]string, error)) versions.FloorSources {
|
|
return versions.FloorSources{
|
|
Seat: func(_ context.Context, seat, name string) ([]string, error) {
|
|
raw, err := call("seat:"+seat+".versions", map[string]any{"name": name})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var a struct {
|
|
Versions []struct {
|
|
Version string `json:"version"`
|
|
} `json:"versions"`
|
|
}
|
|
if err := json.Unmarshal(raw, &a); err != nil {
|
|
return nil, fmt.Errorf("%s's versions answered what is no list of versions: %w", seat, err)
|
|
}
|
|
var out []string
|
|
for _, v := range a.Versions {
|
|
if v.Version != "" {
|
|
out = append(out, v.Version)
|
|
}
|
|
}
|
|
return out, nil
|
|
},
|
|
Tags: func(_ context.Context, repository, prefix string) ([]string, error) {
|
|
// The seat git's verb tags, whichever module holds the seat (design 47 G §7, A-82), page by page.
|
|
var out []string
|
|
for page := int64(1); ; page++ {
|
|
raw, err := call("seat:"+gitseat.Seat+"."+gitseat.VerbTags, gitseat.TagsInput{Repository: repository, Prefix: prefix, Page: page})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var a gitseat.TagsAnswer
|
|
if err := json.Unmarshal(raw, &a); err != nil {
|
|
return nil, fmt.Errorf("the seat git's tags answered what is no list of tags: %w", err)
|
|
}
|
|
if a.Error != "" {
|
|
return nil, fmt.Errorf("the seat git's tags: %s", a.Error)
|
|
}
|
|
out = append(out, a.Tags...)
|
|
if !a.More {
|
|
return out, nil
|
|
}
|
|
}
|
|
},
|
|
Requirements: requirements,
|
|
}
|
|
}
|
|
|
|
// emitEvent says one of the builder's events, mesh.mod.<module>.event.<event>, with the SDK's envelope headers and id as
|
|
// the bus's dedup id.
|
|
func emitEvent(ctx context.Context, js jetstream.JetStream, cred process.Account, event, id string, body any) error {
|
|
data, err := json.Marshal(body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
msg := nats.NewMsg(cred.EventSubject(event))
|
|
msg.Header.Set("x-event-id", id)
|
|
msg.Header.Set("x-source", cred.Module)
|
|
msg.Header.Set("x-node", cred.Node)
|
|
msg.Header.Set("x-time", time.Now().UTC().Format(time.RFC3339Nano))
|
|
msg.Header.Set("content-type", "application/json")
|
|
msg.Data = data
|
|
pub, cancel := context.WithTimeout(ctx, 10*time.Second)
|
|
defer cancel()
|
|
_, err = js.PublishMsg(pub, msg, jetstream.WithMsgID(id))
|
|
return err
|
|
}
|
|
|
|
// emitSeatEvent says an event of a seat the builder holds, on the seat's subject (mesh.seat.<seat>.event.<event>).
|
|
func emitSeatEvent(ctx context.Context, js jetstream.JetStream, cred process.Account, subject, id string, body any) error {
|
|
data, err := json.Marshal(body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
msg := nats.NewMsg(subject)
|
|
msg.Header.Set("x-event-id", id)
|
|
msg.Header.Set("x-source", cred.Module)
|
|
msg.Header.Set("x-node", cred.Node)
|
|
msg.Header.Set("x-time", time.Now().UTC().Format(time.RFC3339Nano))
|
|
msg.Header.Set("content-type", "application/json")
|
|
msg.Data = data
|
|
pub, cancel := context.WithTimeout(ctx, 10*time.Second)
|
|
defer cancel()
|
|
_, err = js.PublishMsg(pub, msg, jetstream.WithMsgID(id))
|
|
return err
|
|
}
|
|
|
|
// The events on the builder's consumer of EVENTS that wake a floor (design 51 *The floor*, DLV-B3b).
|
|
var (
|
|
// The indexer's take-in.taken, which the builder consumes in place of the retired manifest-accepted (design 47 H H-A-116).
|
|
takenInSubject = "mesh.mod.mesh-delivery-indexer.event.take-in.taken"
|
|
conditionClearedSubject = meshconditions.SubjectConditionCleared
|
|
)
|
|
|
|
// floorWake asks the floor of the names an event wakes again, by looking at every module again: a trunk build is
|
|
// numbered before its claim (build.Builder.number).
|
|
type floorWake struct {
|
|
b *build.Builder
|
|
waits *versions.FloorWaits
|
|
logf func(string, ...any)
|
|
}
|
|
|
|
// heard takes a message of the consumer in when it is one that wakes a floor, acknowledged, and answers whether it was.
|
|
func (f *floorWake) heard(ctx context.Context, m jetstream.Msg) bool {
|
|
switch m.Subject() {
|
|
case takenInSubject:
|
|
f.ack(m)
|
|
f.wake(ctx, versions.WakeTakenIn, "", "")
|
|
case conditionClearedSubject:
|
|
f.ack(m)
|
|
var e meshconditions.ConditionEvent
|
|
if err := json.Unmarshal(m.Data(), &e); err != nil {
|
|
f.logf("%s holds what is no condition, left: %v", m.Subject(), err)
|
|
return true
|
|
}
|
|
if e.Subject == nil {
|
|
return true
|
|
}
|
|
for _, module := range conditionModules(e.Subject.ID) {
|
|
f.wake(ctx, versions.WakeCleared, "", module)
|
|
}
|
|
default:
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (f *floorWake) ack(m jetstream.Msg) {
|
|
if err := m.Ack(); err != nil {
|
|
f.logf("acknowledging %s: %v", m.Subject(), err)
|
|
}
|
|
}
|
|
|
|
// wake looks at every module again when the event wakes a name, and says which.
|
|
func (f *floorWake) wake(ctx context.Context, kind, seat, module string) {
|
|
names := f.waits.Wake(kind, seat, module, "")
|
|
if len(names) == 0 {
|
|
return
|
|
}
|
|
f.logf("the floor of %s is asked again: %s", strings.Join(names, ", "), kind)
|
|
f.b.Reconsider(ctx)
|
|
}
|
|
|
|
// conditionModules are the tokens of a condition's subject id (`<node>/<module>`, `<module>.<check>`): a module named
|
|
// among them is the one whose condition cleared.
|
|
func conditionModules(id string) []string {
|
|
return strings.FieldsFunc(id, func(r rune) bool { return r == '/' || r == '.' || r == ':' })
|
|
}
|