Files
mesh-delivery/modules/mesh-delivery-view/cmd/mesh-delivery-view/main.go
T

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():
}
}()
}