Builds: design 47 G §689, §687, A-22, A-26 Claude-Session: https://claude.ai/code/session_01JG73KEq4zoDfM9WtYpcQgZ
332 lines
13 KiB
Go
332 lines
13 KiB
Go
// Command mesh-delivery-view is the operator's view of delivery (novox/hq ADR 0429 §3): it watches the have, the seat's assignments
|
|
// and builds buckets on its own bus credential, derives one row per module and node in memory, and serves them on a
|
|
// local socket (for mesh-delivery-cli) and on a local web page. It starts, stops or retries nothing; the one thing it writes is the operator's answer to an ask that needs no proof of who
|
|
// answered, under `<ask key>.view` in its bucket answers (ADR 0528 clause 6).
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"git.novox.be/novox/mesh-delivery/contracts/go/clients/meshcatalogclient"
|
|
"io"
|
|
"log"
|
|
"mesh-delivery-view/internal/view"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"strings"
|
|
"syscall"
|
|
"time"
|
|
|
|
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/builds"
|
|
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-view/viewstate"
|
|
"git.novox.be/novox/mesh-delivery/sdk/trunk"
|
|
"git.novox.be/novox/mesh-sdk/go/process"
|
|
"git.novox.be/novox/mesh-sdk/go/views"
|
|
"github.com/nats-io/nats.go"
|
|
"github.com/nats-io/nats.go/jetstream"
|
|
)
|
|
|
|
const (
|
|
defaultSocket = "/var/lib/mesh-delivery-view-cli/cli.sock"
|
|
defaultWeb = "127.0.0.1:8471"
|
|
)
|
|
|
|
func main() {
|
|
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
|
|
defer stop()
|
|
if err := run(ctx, os.Getenv, os.Stderr); err != nil {
|
|
fmt.Fprintln(os.Stderr, "mesh-delivery-view:", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
// run is the program: it returns when ctx ends or a listener cannot be made.
|
|
func run(ctx context.Context, getenv func(string) string, logOut io.Writer) error {
|
|
logger := log.New(logOut, "mesh-delivery-view: ", log.LstdFlags)
|
|
cred, err := process.ReadBrokerAccount(getenv)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
socket := strings.TrimSpace(getenv("MESH_DELIVERY_SOCKET"))
|
|
if socket == "" {
|
|
socket = defaultSocket
|
|
}
|
|
web := strings.TrimSpace(getenv("MESH_DELIVERY_WEB"))
|
|
if web == "" {
|
|
web = defaultWeb
|
|
}
|
|
|
|
model := view.New()
|
|
l, err := view.ListenSocket(socket)
|
|
if err != nil {
|
|
return fmt.Errorf("cannot listen on %s: %w", socket, err)
|
|
}
|
|
srv := &http.Server{Addr: web, Handler: view.Web(model), ReadHeaderTimeout: 10 * time.Second}
|
|
webUp := make(chan error, 1)
|
|
go func() { webUp <- srv.ListenAndServe() }()
|
|
go view.ServeSocket(ctx, l, model)
|
|
|
|
conn, js, err := cred.Dial()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer conn.Close()
|
|
model.SetWriter(kvWriter{ctx: ctx, js: js})
|
|
model.SetMotionEvent(func(e view.MotionEvent) error {
|
|
err := emitEvent(ctx, js, cred, e.Type, e.Body, e.ID)
|
|
if err != nil {
|
|
logger.Printf("the %s of %s on %s could not be said (said again at its next change): %v", e.Type, e.Body.Module, e.Body.Node, err)
|
|
}
|
|
return err
|
|
})
|
|
model.SetDeliveredEvent(func(e view.DeliveredEvent) error {
|
|
id := fmt.Sprintf("delivered.%d", e.Revision)
|
|
if e.Repository != "" { // a repository's reached head (ADR 0556 clause 3)
|
|
key, _ := trunk.RepositoryKey(e.Repository)
|
|
id = fmt.Sprintf("reached.%s.%d.%d", key, e.Revision, len(e.NotYet))
|
|
if len(e.NotYet) > 0 {
|
|
sum := sha256.Sum256([]byte(strings.Join(e.NotYet, ",")))
|
|
id += "." + hex.EncodeToString(sum[:6])
|
|
}
|
|
}
|
|
err := emitEvent(ctx, js, cred, DeliveredEventType, e, id)
|
|
if err != nil {
|
|
logger.Printf("the delivery of source revision %d could not be said (said again at the next change the view takes in): %v", e.Revision, err)
|
|
}
|
|
return err
|
|
})
|
|
model.SetReachWriter(func(w view.ReachWrite) error {
|
|
rev, err := putReach(ctx, js, w)
|
|
if err != nil {
|
|
logger.Printf("the reach of %s could not be written (written again at the next change the view takes in): %v", w.Key, err)
|
|
return err
|
|
}
|
|
// What the view wrote it says (ADR 0596 §2): a reader hears the reach change and asks view_reach, never the bucket.
|
|
err = emitEvent(ctx, js, cred, ReachedEventType, ReachedEvent{Key: w.Key, Reach: w.Value}, fmt.Sprintf("reached.%s.%d", w.Key, rev))
|
|
if err != nil {
|
|
logger.Printf("the reach of %s is written and could not be said (said again at the next change the view takes in): %v", w.Key, err)
|
|
}
|
|
return err
|
|
})
|
|
model.SetBacklog(view.BacklogOver(js, 5*time.Second))
|
|
// The indexer's and the assigner's states are their owners': read by the first view of the owner's read tool and then
|
|
// its views family, never their buckets (ADR 0615 §1, DLV-M4). An owner that is down never holds the start: a watch of
|
|
// its picture waits for the first view on its own goroutine, and until then the unanswered first view is the view's
|
|
// finding (ADR 0615 §6).
|
|
calls, err := process.Connect(cred, nats.Name(cred.Node+"."+cred.Module+".calls"), nats.RetryOnFailedConnect(true))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer calls.Close()
|
|
reader := &views.ProcessReader{Module: viewstate.ViewModule, Call: calls.Call, Logf: logger.Printf}
|
|
writer, err := findingWriter(ctx, cred, conn, js, calls.State("findings"), logger.Printf)
|
|
if err != nil {
|
|
return fmt.Errorf("the view's finding writer: %w", err)
|
|
}
|
|
defer writer.Close()
|
|
reader.Findings = func() views.WireWriter { return writer }
|
|
for _, o := range ownersFollowed {
|
|
if _, err := reader.Follow(o.owner, o.state, o.tool); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
open := buckets{js: js, reader: reader}
|
|
for _, bucket := range []string{view.HaveBucket, view.AssignmentsBucket, view.PresenceBucket, view.StuckBucket, view.CandidatesBucket, view.AsksBucket, view.AnswersBucket, builds.BuilderBuildsBucket, view.AssignerWantsBucket, view.SourceBucket, view.AssignerAsksBucket, viewstate.ViewAnswersBucket, view.TakenBucket} {
|
|
go follow(ctx, open, bucket, false, model, logger)
|
|
}
|
|
// The source's history gives each head's source revision (ADR 0556); the modules' history is each revision of the
|
|
// catalog half the view takes, in its order (below).
|
|
go follow(ctx, open, view.SourceBucket, true, model, logger)
|
|
statusBucket := process.AwaitBucket(ctx, js, conn, firstViewsBucket, "view_first_views reads nothing and view_first_view_again is not heard", logger.Printf)
|
|
// The modules are the catalog half's, adopted whole by the seat's client: its first view, its status, its hand asks and
|
|
// its event catalog-revision (on the module's durable consumer) are the reader's.
|
|
catalog, _, err := meshcatalogclient.WireCatalogProcess(reader, calls.Call, "main", catalogChanged(model, logger))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
reader.Start(ctx, js, cred, statusBucket)
|
|
catalogHeld(ctx, catalog, model)
|
|
select {
|
|
case <-ctx.Done():
|
|
case err := <-webUp:
|
|
if !errors.Is(err, http.ErrServerClosed) {
|
|
return fmt.Errorf("the web view stopped: %w", err)
|
|
}
|
|
}
|
|
shutdown, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
|
defer cancel()
|
|
srv.Shutdown(shutdown)
|
|
return nil
|
|
}
|
|
|
|
// kvWriter is the view's one write: a key of its own bucket answers (manifest state entry answers), which the teller reads.
|
|
// The bucket is the controller's to create; a bucket not there yet is an error the operator is told.
|
|
type kvWriter struct {
|
|
ctx context.Context
|
|
js jetstream.JetStream
|
|
}
|
|
|
|
func (w kvWriter) Put(key string, value []byte) error {
|
|
kv, err := w.js.KeyValue(w.ctx, viewstate.ViewAnswersBucket)
|
|
if err != nil {
|
|
return fmt.Errorf("the bucket %s: %w", viewstate.ViewAnswersBucket, err)
|
|
}
|
|
_, err = kv.Put(w.ctx, key, value)
|
|
return err
|
|
}
|
|
|
|
// putReach writes a reach value under its key in the view's own state reach (ADR 0556 clause 2), its only writer.
|
|
func putReach(ctx context.Context, js jetstream.JetStream, w view.ReachWrite) (uint64, error) {
|
|
kv, err := js.KeyValue(ctx, viewstate.ReachBucket)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("the bucket %s: %w", viewstate.ReachBucket, err)
|
|
}
|
|
return kv.Put(ctx, w.Key, w.Value)
|
|
}
|
|
|
|
// ReachedEventType is the event the view says after it writes a repository's reach: mesh.mod.mesh-delivery-view.event.reached
|
|
// (ADR 0596 §2). Its body is ReachedEvent.
|
|
const ReachedEventType = "reached"
|
|
|
|
// ReachedEvent is the body of the event reached: the key of the reach (the repository's) and the reach as the view wrote it.
|
|
type ReachedEvent struct {
|
|
Key string `json:"key"`
|
|
Reach json.RawMessage `json:"reach"`
|
|
}
|
|
|
|
// The view's own state of its first views (views.StatusState).
|
|
var firstViewsBucket = viewstate.ViewModule + "_" + views.StatusState
|
|
|
|
// ownersFollowed are the indexer's and the assigner's states the view's process follows by their first views, each by its
|
|
// owner's read tool (as the view's invokes names it) and views family (its events on the shared events stream); the
|
|
// view's tools ask the other six through the owners' read tools on each call.
|
|
var ownersFollowed = []struct{ owner, state, tool string }{
|
|
{view.AssignerModule, view.AssignmentsState, view.AssignerModule + ".assigner_read_assignments"},
|
|
{view.AssignerModule, "wants", view.AssignerModule + ".assigner_read_wants"},
|
|
{view.AssignerModule, "asks", view.AssignerModule + ".assigner_read_asks"},
|
|
{view.IndexerModule, "candidates", view.IndexerModule + ".indexer_read_candidates"},
|
|
{view.IndexerModule, "taken", view.IndexerModule + ".indexer_read_taken"},
|
|
}
|
|
|
|
// buckets opens what the view watches: an owner's state as its picture (firstview), any other bucket on the bus.
|
|
type buckets struct {
|
|
js jetstream.JetStream
|
|
reader *views.ProcessReader
|
|
}
|
|
|
|
func (b buckets) KeyValue(ctx context.Context, bucket string) (jetstream.KeyValue, error) {
|
|
if p := b.reader.Picture(bucket); p != nil {
|
|
return p, nil
|
|
}
|
|
return b.js.KeyValue(ctx, bucket)
|
|
}
|
|
|
|
// follow watches a bucket with its last values first and then each change, for as long as ctx lives: a bucket that is
|
|
// not there yet, or a watch that ends, is tried again.
|
|
func follow(ctx context.Context, js process.BucketOpener, bucket string, history bool, model *view.Model, logger *log.Logger) {
|
|
for ctx.Err() == nil {
|
|
if err := watchOnce(ctx, js, bucket, history, model); err != nil && ctx.Err() == nil {
|
|
logger.Printf("cannot watch %s, trying again: %v", bucket, err)
|
|
}
|
|
select {
|
|
case <-ctx.Done():
|
|
case <-time.After(5 * time.Second):
|
|
}
|
|
}
|
|
}
|
|
|
|
func watchOnce(ctx context.Context, js process.BucketOpener, bucket string, history bool, model *view.Model) error {
|
|
kv, err := js.KeyValue(ctx, bucket)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var opts []jetstream.WatchOpt
|
|
initial := bucket
|
|
if history {
|
|
opts, initial = append(opts, jetstream.IncludeHistory()), view.ReachHistory(bucket)
|
|
}
|
|
w, err := kv.WatchAll(ctx, opts...)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer w.Stop()
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return nil
|
|
case e, ok := <-w.Updates():
|
|
if !ok {
|
|
return errors.New("the watch ended")
|
|
}
|
|
if e == nil { // the last values have all been delivered
|
|
model.Initial(initial)
|
|
continue
|
|
}
|
|
model.Apply(view.Entry{Bucket: bucket, Key: e.Key(), Value: e.Value(), At: e.Created(),
|
|
Deleted: e.Operation() != jetstream.KeyValuePut, Revision: e.Revision(), History: history})
|
|
}
|
|
}
|
|
}
|
|
|
|
// DeliveredEventType is the event the view says when a source revision is delivered: mesh.mod.mesh-delivery-view.event.delivered
|
|
// (issue 1906 D9, ADR 0539 §17). Its body is view.DeliveredEvent.
|
|
const DeliveredEventType = "delivered"
|
|
|
|
// emitEvent publishes an event of the view's own namespace, mesh.mod.<module>.event.<type>, with the SDK's envelope headers
|
|
// (as mesh-sdk's process.Conn.Emit does) and the id as the bus's own dedup id, so the same revision said twice in the stream's
|
|
// duplicate window is kept once.
|
|
func emitEvent(ctx context.Context, js jetstream.JetStream, cred process.Account, eventType string, body any, id string) error {
|
|
data, err := json.Marshal(body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
msg := nats.NewMsg(cred.EventSubject(eventType))
|
|
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
|
|
}
|
|
|
|
// catalogChanged hands one module of a revision the view took to the model, in the form of its value; the modules'
|
|
// history is these changes in the order of the revisions.
|
|
func catalogChanged(model *view.Model, logger *log.Logger) func(string, json.RawMessage, bool, time.Time) {
|
|
return func(module string, entry json.RawMessage, gone bool, at time.Time) {
|
|
e := view.Entry{Bucket: view.ModulesBucket, Key: module, At: at, Deleted: gone}
|
|
if !gone {
|
|
v, err := view.ModuleValue(entry)
|
|
if err != nil {
|
|
logger.Printf("the catalog entry of %s is not taken: %v", module, err)
|
|
return
|
|
}
|
|
e.Value = v
|
|
}
|
|
model.Apply(e)
|
|
e.History = true
|
|
model.Apply(e)
|
|
}
|
|
}
|
|
|
|
// catalogHeld makes the model's pictures of the modules initial once the catalog half's first view is held: the process
|
|
// starts at once and waits for the seat's holder, saying so.
|
|
func catalogHeld(ctx context.Context, cat *meshcatalogclient.Catalog, model *view.Model) {
|
|
go func() {
|
|
select {
|
|
case <-cat.Follower.Ready():
|
|
model.Initial(view.ModulesBucket)
|
|
model.Initial(view.ReachHistory(view.ModulesBucket))
|
|
case <-ctx.Done():
|
|
}
|
|
}()
|
|
}
|