Delete the dead table paths, the move, the store's assignments mirror and its tick (issue 1110)

Every method of builds, build requests, rollouts, merges and assignments reads and writes the chain alone: the else branches that read the tables, the movers and MoveChain with their tests, chain_moved reads, ChainReads and the flags that switched a kind, the store's assignments mirror (KeepAssignmentPlans needs none of it: it uses only the AssignmentMirrored type, mirrors.go, and AssignmentValues, provisioning.go) and its tick, the move code of the controller's start, and ForTest's chain_moved row. The listed store tests of the move go with their functions; the tests of the readers, requests, assignments and plans that lived beside them stay in chain_store_test.go. Tests that replayed old data migrations over the build, assignment and pin tables are removed with the tables. The static test that no plan is written but through SavePlansMoving now reads the plan's chain path.

cmd/mesh-controller/chain.go

@@ -7,15 +7,12 @@ import (
 	"time"
 
 	"github.com/novox/mesh-controller/internal/chain"
-	"github.com/novox/mesh-controller/internal/conditions"
 	"github.com/novox/mesh-controller/internal/inventory"
 	"github.com/novox/mesh-controller/internal/link"
 )
 
 // The chain on the bus (novox/hq ADR 0408, design 47 milestone 5): builds, rollouts and assignments are keys of the
-// bus's key-value store, written by the controller that holds the lease. The tables of the controller's store are
-// copied into them once, by the serving controller at its start, and a kind is read from its bucket only once the move
-// has recorded it (inventory.ChainReads).
+// bus's key-value store, written by the controller that holds the lease, and the controller's store keeps none of them.
 
 // chainHolds is whether this process may write the chain now: the lease's gate, the one every act passes.
 func chainHolds(ctx context.Context) error {
@@ -33,97 +30,7 @@ func openTheChain(ctx context.Context) (*chain.Chain, error) {
 	return chain.OnTheBus(ctx, js.Conn(), chainHolds)
 }
 
-// kindChainMoveRefused is the condition of a move that stopped without switching a kind.
-const kindChainMoveRefused = "chain-move-refused"
-
-// chainMoveRetry is how long a move that failed for want of the bus waits before it tries again.
-const chainMoveRetry = 30 * time.Second
-
-// movingTheChain copies the tables into the buckets and records it, at the serving controller's start: after the buckets
-// exist and the lease is held, before anything reads a kind that has not moved. **The first try is made here, before the
-// controller serves**, so what it serves is read from one place. A move that fails for want of the bus is tried again
-// every half minute while the controller serves from the tables; one that is refused — a count that differs, a value
-// over the bus's largest — is raised as an urgent condition, and the tables stay what is read: nothing is half-switched.
-func movingTheChain(ctx context.Context, inv *inventory.Inventory) {
-	say := func(format string, args ...any) { fmt.Printf("chain: "+format+"\n", args...) }
-	// The first try is made here, before the controller serves; the tries after it, while it serves.
-	if movedOrStopped(ctx, inv, say) {
-		return
-	}
-	go func() {
-		for {
-			select {
-			case <-ctx.Done():
-				return
-			case <-time.After(chainMoveRetry):
-			}
-			if movedOrStopped(ctx, inv, say) {
-				return
-			}
-		}
-	}()
-}
-
-// movedOrStopped makes one try at the move and says whether there is nothing more to try: moved, refused, or the controller
-// ending. False for a failure of the kind that is tried again (the bus away, a write not granted yet, the lease not held).
-func movedOrStopped(ctx context.Context, inv *inventory.Inventory, say func(string, ...any)) bool {
-	_, err := inv.MoveChain(ctx, say)
-	var refusal *inventory.Refusal
-	switch {
-	case err == nil:
-		go clearChainMove(ctx)
-		go askAgainSoon(ctx, inv)
-		return true
-	case errors.As(err, &refusal):
-		say("%v", err)
-		go raiseChainMove(ctx, refusal)
-		return true
-	case ctx.Err() != nil:
-		return true
-	}
-	say("the move to the bus did not finish, and the tables are read until it does: %v", err)
-	return false
-}
-
-// chainMoveObservation is the urgent condition for a refused move.
-func chainMoveObservation(r *inventory.Refusal) conditions.Observation {
-	return conditions.Observation{Scope: conditions.ScopeBus, ID: "chain." + r.Kind, Token: kindChainMoveRefused,
-		Kind: kindChainMoveRefused, Severity: conditions.Urgent, Resolver: conditions.ResolverOperator,
-		Summary: "the controller's " + r.Kind + " were not moved to the bus: " + r.Why, Source: "chain move"}
-}
-
-// whenKept runs f once the serving controller keeps conditions: the move runs before they are kept.
-func whenKept(ctx context.Context, f func(k *conditions.Keeper)) {
-	for conditionsFrom == nil {
-		select {
-		case <-ctx.Done():
-			return
-		case <-time.After(time.Second):
-		}
-	}
-	f(conditionsFrom)
-}
-
-func raiseChainMove(ctx context.Context, r *inventory.Refusal) {
-	whenKept(ctx, func(k *conditions.Keeper) {
-		if _, err := k.Observe(ctx, chainMoveObservation(r)); err != nil {
-			fmt.Printf("chain: the condition for the refused move could not be raised: %v\n", err)
-		}
-	})
-}
-
-func clearChainMove(ctx context.Context) {
-	whenKept(ctx, func(k *conditions.Keeper) {
-		for _, kind := range []string{inventory.KindBuilds, inventory.KindRollouts, inventory.KindAssignments} {
-			key := chainMoveObservation(&inventory.Refusal{Kind: kind}).Key()
-			if _, err := k.Clear(ctx, key, "the "+kind+" are on the bus"); err != nil {
-				fmt.Printf("chain: the condition for the move of the %s could not be cleared: %v\n", kind, err)
-			}
-		}
-	})
-}
-
-// attachTheChain gives the inventory of the serving controller the chain on its connection, then moves what has not moved.
+// attachTheChain gives the inventory of the serving controller the chain on its connection.
 func attachTheChain(ctx context.Context, inv *inventory.Inventory, server *link.Server) error {
 	bus, ok := server.Bus().(link.OverNATS)
 	if !ok {
@@ -134,7 +41,8 @@ func attachTheChain(ctx context.Context, inv *inventory.Inventory, server *link.
 		return err
 	}
 	inv.UseChain(c)
-	movingTheChain(ctx, inv)
+	// And the requests the move of delivery 1 found never handed over, asked again once (askAgain), once it is serving.
+	go askAgainSoon(ctx, inv)
 	return nil
 }
 

cmd/mesh-controller/plan_moved_every_writer_test.go

@@ -12,9 +12,9 @@ import (
 )
 
 // **Every plan is written through SavePlansMoving, which says it** (issue 974, novox/hq ADR 0406 §2: every move of a plan
-// is said as plan-moved, so no move is found only by comparing). The one hook, inventory.PlanSaved, is called there
-// after the commit; so no statement that writes the plan table may stand anywhere else, and writePlan, the one that
-// does, may be called from nowhere but SavePlansMoving. Checked by reading the sources, no store needed.
+// is said as plan-moved, so no move is found only by comparing). The one hook, inventory.PlanSaved, is called there after the
+// write; so no code but chainSavePlans (which SavePlansMoving calls, and no other function) writes a plan to the rollouts
+// bucket by anything but a change of the merges it holds. Checked by reading the sources, no store needed.
 func TestNoPlanIsWrittenButThroughSavePlansMoving(t *testing.T) {
 	write := regexp.MustCompile(`(?is)(insert\s+into|update|delete\s+from|truncate)\s+(table\s+)?release_plan\b`)
 	var found []string
@@ -31,11 +31,13 @@ func TestNoPlanIsWrittenButThroughSavePlansMoving(t *testing.T) {
 				return err
 			}
 			text := string(raw)
-			if write.MatchString(text) && filepath.ToSlash(path) != "../../internal/inventory/plans.go" {
+			if write.MatchString(text) {
 				found = append(found, path+" writes the plan table")
 			}
-			if strings.Contains(text, "writePlan(") && filepath.ToSlash(path) != "../../internal/inventory/plans.go" {
-				found = append(found, path+" calls writePlan")
+			// A plan record is written by the bucket's raw create and update, which only the plans' own file calls.
+			if filepath.ToSlash(path) != "../../internal/inventory/chain_rollouts.go" && filepath.ToSlash(path) != "../../internal/chain/chain.go" &&
+				strings.Contains(text, "chain.RolloutsOf") {
+				found = append(found, path+" reaches the rollouts bucket")
 			}
 			return nil
 		})
@@ -51,17 +53,26 @@ func TestNoPlanIsWrittenButThroughSavePlansMoving(t *testing.T) {
 		t.Fatal(err)
 	}
 	text := string(raw)
-	if n := len(write.FindAllString(text, -1)); n != 1 {
-		t.Errorf("plans.go has %d statements that write the plan table; want the one in writePlan", n)
-	}
-	calls := regexp.MustCompile(`writePlan\(ctx, tx`).FindAllStringIndex(text, -1)
 	save := strings.Index(text, "func (i *Inventory) SavePlansMoving")
 	next := strings.Index(text[save:], "\nfunc ")
-	if len(calls) != 1 || calls[0][0] < save || calls[0][0] > save+next {
-		t.Errorf("writePlan is called %d times, and not only from SavePlansMoving", len(calls))
+	if next < 0 {
+		next = len(text) - save
 	}
-	if !strings.Contains(text[save:save+next], "PlanSaved(i, *p)") {
-		t.Error("SavePlansMoving does not say each plan it wrote")
+	if !strings.Contains(text[save:save+next], "chainSavePlans(") {
+		t.Error("SavePlansMoving does not write through chainSavePlans")
+	}
+	chainRaw, err := os.ReadFile("../../internal/inventory/chain_rollouts.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	chainText := string(chainRaw)
+	at := strings.Index(chainText, "func (i *Inventory) chainSavePlans")
+	end := strings.Index(chainText[at:], "\nfunc ")
+	if !strings.Contains(chainText[at:at+end], "PlanSaved(i, *p)") {
+		t.Error("chainSavePlans does not say each plan it wrote")
+	}
+	if n := strings.Count(chainText, "createRaw(ctx, c, p.ID"); n != 1 {
+		t.Errorf("a plan is made from %d places of chain_rollouts.go, want the one in chainSavePlans", n)
 	}
 }
 

cmd/mesh-controller/record_mirrors.go

@@ -44,7 +44,6 @@ func mirroringRecords(ctx context.Context, inv *inventory.Inventory, conn *nats.
 		return e
 	}
 	sources := map[string]func(context.Context) (map[string][]byte, error){
-		recordmirror.Assignments.Name:    inv.AssignmentsMirrorToWrite,
 		recordmirror.DeclaredConfig.Name: inv.DeclaredConfigMirror,
 		recordmirror.Predefined.Name:     inv.PredefinedMirror,
 	}
@@ -55,15 +54,11 @@ func mirroringRecords(ctx context.Context, inv *inventory.Inventory, conn *nats.
 	events := &assignmentEvents{}
 	for {
 		if holds() {
-			// The assignments, once they are keys of the bus, are written by the verbs that change them (novox/hq ADR
-			// 0408): this tick keeps the provisioner's plan in their values and says what changed; the mirror of the store
-			// writes them only until the move.
-			onTheBus := keepingAssignments(ctx, inv, announce, epoch, events, failing)
+			// The assignments are keys of the bus, written by the verbs that change them (novox/hq ADR 0408): this tick
+			// keeps the provisioner's plan in their values and says what changed. They are no mirror of the store.
+			keepingAssignments(ctx, inv, announce, epoch, events, failing)
 			for _, m := range recordmirror.Mirrors() {
-				if m.Name == recordmirror.Assignments.Name && onTheBus {
-					continue
-				}
-				why := mirrorOnce(ctx, inv, api, m, writers, sources[m.Name], announce, epoch, holds)
+				why := mirrorOnce(ctx, api, m, writers, sources[m.Name], announce, epoch, holds)
 				if why != failing[m.Name] {
 					if why != "" {
 						fmt.Printf("the %s mirror cannot be kept: %s\n", m.Name, why)
@@ -83,7 +78,7 @@ func mirroringRecords(ctx context.Context, inv *inventory.Inventory, conn *nats.
 }
 
 // mirrorOnce brings one mirror to what the store holds, and answers why it could not; empty when it could.
-func mirrorOnce(ctx context.Context, inv *inventory.Inventory, api jetstream.JetStream, m recordmirror.Mirror, writers map[string]*recordmirror.Writer,
+func mirrorOnce(ctx context.Context, api jetstream.JetStream, m recordmirror.Mirror, writers map[string]*recordmirror.Writer,
 	source func(context.Context) (map[string][]byte, error), announce recordmirror.Announcer, epoch func() uint64,
 	holds func() bool) string {
 	reading, cancel := context.WithTimeout(ctx, 30*time.Second)
@@ -95,9 +90,6 @@ func mirrorOnce(ctx context.Context, inv *inventory.Inventory, api jetstream.Jet
 			return fmt.Sprintf("the bucket %s cannot be read: %v", m.Bucket, err)
 		}
 		w = &recordmirror.Writer{Mirror: m, KV: kv, Announce: announce, Epoch: epoch, Holds: holds}
-		if m.Name == recordmirror.Assignments.Name {
-			w.Holds = assignmentsHolds(inv, holds)
-		}
 		writers[m.Name] = w
 	}
 	want, err := source(reading)
@@ -128,21 +120,10 @@ type assignmentEvents struct {
 // the values it belongs to, and one `assignment-changed` event for each key that is new, changed or ended since the last
 // look — whoever wrote it, a verb in this process or a command in another. False when they are not on the bus yet.
 func keepingAssignments(ctx context.Context, inv *inventory.Inventory, announce recordmirror.Announcer, epoch func() uint64,
-	events *assignmentEvents, failing map[string]string) bool {
+	events *assignmentEvents, failing map[string]string) {
 	reading, cancel := context.WithTimeout(ctx, 30*time.Second)
 	defer cancel()
 	const name = "assignments"
-	if _, on, err := inv.KeptAssignments(reading); err != nil || !on {
-		if err != nil {
-			// Not known to be off the bus: the store's mirror is not written over what the bus may hold.
-			if failing[name] == "" {
-				failing[name] = err.Error()
-				fmt.Printf("the assignments cannot be read from the bus: %v\n", err)
-			}
-			return true
-		}
-		return false
-	}
 	if _, _, err := inv.KeepAssignmentPlans(reading); err != nil {
 		if failing[name] != err.Error() {
 			failing[name] = err.Error()
@@ -152,9 +133,9 @@ func keepingAssignments(ctx context.Context, inv *inventory.Inventory, announce
 		fmt.Printf("the provisioner's plans are kept in the assignments again\n")
 		failing[name] = ""
 	}
-	now, _, err := inv.KeptAssignments(reading)
+	now, err := inv.KeptAssignments(reading)
 	if err != nil {
-		return true
+		return
 	}
 	if events.known != nil {
 		keys := make([]string, 0, len(now)+len(events.known))
@@ -194,12 +175,4 @@ func keepingAssignments(ctx context.Context, inv *inventory.Inventory, announce
 		}
 	}
 	events.known = now
-	return true
-}
-
-// assignmentsHolds is the assignments mirror's leave to write: the lease's, and the assignments neither being switched to
-// the bus nor on it. Asked by the writer before every write and purge, so a pass that read its source before the switch
-// writes nothing after it (ADR 0408 §4).
-func assignmentsHolds(inv *inventory.Inventory, holds func() bool) func() bool {
-	return func() bool { return holds() && inv.AssignmentsMirrorMayWrite() }
 }

cmd/mesh-controller/record_mirrors_switch_test.go

@@ -1,29 +0,0 @@
-package main
-
-import (
-	"errors"
-	"testing"
-
-	"github.com/novox/mesh-controller/internal/inventory"
-	"github.com/novox/mesh-controller/internal/recordmirror"
-)
-
-// **A writer of the store's mirror of the assignments, made before the assignments are switched to the bus, writes and
-// purges nothing after** (ADR 0408 §4, issue 1093): its leave to write is asked before every write, and false once they are
-// switching or moved.
-func TestAMirrorWriterMadeBeforeTheSwitchWritesAndPurgesNothingAfter(t *testing.T) {
-	inv := inventory.NewForTest()
-	w := &recordmirror.Writer{Mirror: recordmirror.Assignments, Holds: assignmentsHolds(inv, func() bool { return true })}
-	if !w.Holds() {
-		t.Fatal("the writer may not write before the switch")
-	}
-	inv.BeginSwitchForTest(inventory.KindAssignments)
-	if w.Holds() {
-		t.Fatal("the writer may write while the assignments are switching")
-	}
-	// Refused before it reads the bucket (it has none here) or lays or ends a key.
-	r, err := w.Sync(t.Context(), map[string][]byte{"anchor.notes": []byte(`{}`)})
-	if !errors.Is(err, recordmirror.ErrNotHeld) || r.Written != 0 || r.Removed != 0 {
-		t.Fatalf("the writer wrote after the switch: %+v %v", r, err)
-	}
-}

cmd/mesh-controller/sent_required_by_integration_test.go

@@ -85,10 +85,7 @@ func TestAModulePulledInIsHandedOnAMachineThatCanTakeItAndMirrored(t *testing.T)
 		t.Fatal(err)
 	}
 	inv.SetProvisioningPlans(inv.SentProvisioningPlans)
-	mirror, err := inv.AssignmentsMirror(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
+	mirror := inv.PlanValuesForTest(t)
 	var value inventory.AssignmentMirrored
 	if err := json.Unmarshal(mirror["laptop.moved-bot"], &value); err != nil {
 		t.Fatalf("no value for the pulled-in module: %s (%v)", mirror["laptop.moved-bot"], err)