Read what a node was sent from its assignment keys; a pulled-in module keeps a standing key; a hand send is a time (issue 1109)

SentBuilds answers from the keys of the node's assignments that name a commit, known when the node was sent anything and no key says its commit unknown. A send that names its builds writes the commit, build and rollout on each carried module's key (a module nothing assigns gets a standing key marked pulled-in, never a state) and clears what every other key of the node named; a send by hand writes sent-unknown, a time, on every key and clears their commits. A failed write of these fails the record of the send. node.sent_builds is no longer written. The plan pass ends a pulled-in key only when no send carries it.

internal/inventory/nodes.go

@@ -1264,22 +1264,12 @@ func (i *Inventory) RecordSentUnder(ctx context.Context, node, digest string, bu
 		e := int64(epoch)
 		sentEpoch = &e
 	}
-	var carried *string
-	if builds != nil {
-		raw, err := json.Marshal(builds)
-		if err != nil {
-			return err
-		}
-		text := string(raw)
-		carried = &text
+	if _, err := i.store.Pool().Exec(ctx,
+		`update node set sent = $2, sent_at = now(), sent_epoch = $3 where id = $1`, node, digest, sentEpoch); err != nil {
+		return err
 	}
-	_, err := i.store.Pool().Exec(ctx,
-		`update node set sent = $2, sent_at = now(), sent_builds = $3::jsonb, sent_epoch = $4 where id = $1`,
-		node, digest, carried, sentEpoch)
-	if err == nil {
-		saidRunsNot(node, i.recordRuns(ctx, node, builds, time.Now()))
-	}
-	return err
+	// What it was sent of each module is the assignments' (SentBuilds); a write of it that fails fails this record.
+	return i.recordRuns(ctx, node, builds, time.Now())
 }
 
 // AwaitingSince is since when a machine has had something waiting for its next send (novox/hq issue
@@ -1307,21 +1297,39 @@ func (i *Inventory) AwaitingSince(ctx context.Context, name string) (time.Time,
 }
 
 // SentBuilds is the build of each module a machine was last sent, by its name: module to the commit
-// its build was made from (novox/hq issue 259). Known is false when that was not kept — a machine
-// last sent before it was, sent a declaration by hand, or one the mesh does not know.
+// its build was made from (novox/hq issue 259), read from the keys of the machine's assignments that name a commit — an
+// assigned module and one only pulled in (ADR 0408, issue 1109). Known is false when that was not kept: a machine never sent
+// anything, or last sent a declaration by hand, which makes every key of it say its commit unknown.
 func (i *Inventory) SentBuilds(ctx context.Context, name string) (builds map[string]string, known bool, err error) {
-	var raw []byte
-	err = i.store.Pool().QueryRow(ctx, `select sent_builds from node where name = $1`, name).Scan(&raw)
+	var sentAt *time.Time
+	err = i.store.Pool().QueryRow(ctx, `select sent_at from node where name = $1`, name).Scan(&sentAt)
 	if errors.Is(err, pgx.ErrNoRows) {
 		return nil, false, nil
 	}
-	if err != nil || raw == nil {
+	if err != nil || sentAt == nil {
 		return nil, false, err
 	}
-	builds = map[string]string{}
-	if err := json.Unmarshal(raw, &builds); err != nil {
+	c, err := i.theChain(ctx)
+	if err != nil {
 		return nil, false, err
 	}
+	all, err := c.Assignments.All(ctx)
+	if err != nil {
+		return nil, false, fmt.Errorf("what %s was sent cannot be read from the bus: %w", name, err)
+	}
+	builds = map[string]string{}
+	for _, k := range all {
+		a := k.Value
+		if a.Node != name || !a.Stands() {
+			continue
+		}
+		if !a.SentUnknown.IsZero() {
+			return nil, false, nil
+		}
+		if a.Commit != "" {
+			builds[a.Module] = a.Commit
+		}
+	}
 	return builds, true, nil
 }