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/sends.go

@@ -2,7 +2,6 @@ package inventory
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"time"
 
@@ -150,32 +149,26 @@ func (i *Inventory) RecordSentWith(ctx context.Context, node, digest string, bui
 		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
-	}
 	tx, err := i.store.Pool().Begin(ctx)
 	if err != nil {
 		return err
 	}
 	defer func() { _ = tx.Rollback(ctx) }()
 	if _, err := tx.Exec(ctx,
-		`update node set sent = $2, sent_at = now(), sent_builds = $3::jsonb, sent_epoch = $4, sent_generation = $5,
-		        sent_provisioning = $6::jsonb
-		  where id = $1`, node, digest, carried, sentEpoch, nullIfZero(generation), nullIfEmpty(s.Provisioning)); err != nil {
+		`update node set sent = $2, sent_at = now(), sent_epoch = $3, sent_generation = $4,
+		        sent_provisioning = $5::jsonb
+		  where id = $1`, node, digest, sentEpoch, nullIfZero(generation), nullIfEmpty(s.Provisioning)); err != nil {
 		return err
 	}
 	recordErr := recordSend(ctx, tx, node, s)
 	if err := tx.Commit(ctx); err != nil {
 		return err
 	}
-	// And what it put on the machine, in the assignments of the modules it carried a build of (issue 1095).
-	saidRunsNot(node, i.recordRuns(ctx, node, builds, time.Now()))
+	// And what it put on the machine, in the assignments (issues 1095, 1109): a write of it that fails fails this record,
+	// for what a machine was sent is read from there.
+	if err := i.recordRuns(ctx, node, builds, time.Now()); err != nil {
+		return fmt.Errorf("%s was sent its declaration, and what each module of it runs there could not be written: %w", node, err)
+	}
 	if recordErr != nil {
 		return &SendNotRecordedError{Err: recordErr}
 	}