Keep rollouts and the merges they answer in the rollouts bucket (issue 1092)

Once chain_moved records the kind, a plan is a key of the rollouts bucket under its id and the open batch is the same key in state assembling. A save refuses a copy another save moved since (the plan's own Revision, kept in its value, counts saves) and keeps the merges the record holds, so a copy read before a merge moved cannot lay it back. The merges a batch or walk answers are the record's held field, with the columns the table had; a merge no plan answers stays, flagged, in the record that held it last, or in the record kept for those. A merge moved to a plan is written to the receiving record first and then taken from the giving one; one found in both is read from the one it entered last and repaired at the next cut. Plans and merges are read from a view kept by one watch of the bucket. A bus that does not answer, a lease lost and a key moved are now not-now like the store being away, so a merge whose plan could not be written is held and handed over again, never acknowledged. The start moves release_plan and batched_merge into the bucket, one kind, counted against both tables.
2026-10-18 03:06:50 +02:00
parent e0fb241263
commit 275ddd76e8
21 changed files with 1939 additions and 40 deletions
@@ -422,3 +422,104 @@ func TestTheMoveCarriesTheBuildRequestsAndMarksTheNeverAskedToAskAgain(t *testin
 		t.Fatalf("the request lost its words: %+v", done)
 	}
 }
+
+// **The move carries every plan with the merges it answers, and the plans read the same from the bucket as from the
+// table** (ADR 0408 §8, ADR 0276, issue 1092): a batch with a merge, a walk that was built and rolled, a merge waiting
+// for a walk of its own, and a merge whose plan the store never kept — each in the record of the plan that held it last.
+func TestTheMoveCarriesThePlansAndTheirMergesAndTheyReadTheSame(t *testing.T) {
+	inv, finish := ForTestBefore(t, 105)
+	finish()
+	ctx := context.Background()
+	batch := aBatch("plan-1", time.Now().Add(-3*time.Hour).UTC())
+	walk := aBatch("plan-2", time.Now().Add(-2*time.Hour).UTC())
+	walk.State, walk.Tier, walk.Tiers = PlanRolling, 1, [][]string{{"a"}, {"b"}}
+	walk.Modules = map[string]*PlanModule{"a": {State: "built"}, "b": {}}
+	walk.Delivery = &PlanDelivery{Awaits: "mesh-delivery", Merges: []PlanMerge{{Repository: "novox/mesh-catalog", Commit: "m-waiting"}}}
+	for _, p := range []*Plan{batch, walk} {
+		if err := inv.SavePlan(ctx, p); err != nil {
+			t.Fatal(err)
+		}
+	}
+	walk.Note = "second save"
+	if err := inv.SavePlan(ctx, walk); err != nil {
+		t.Fatal(err)
+	}
+	for _, m := range []BatchedMerge{aMerge("m-batch", "plan-1"), aMerge("m-walk", "plan-2"), aMerge("m-dangling", "plan-never-kept")} {
+		if added, err := inv.AddMerge(ctx, m); err != nil || !added {
+			t.Fatalf("added %v: %v", added, err)
+		}
+	}
+	waiting := aMerge("m-waiting", "plan-2")
+	if _, err := inv.AddMerge(ctx, waiting); err != nil {
+		t.Fatal(err)
+	}
+	if err := inv.AnswerMerge(ctx, waiting.Repository, waiting.Commit, "", true); err != nil {
+		t.Fatal(err)
+	}
+	wasPlans, err := inv.RecentPlans(ctx, 10)
+	if err != nil || len(wasPlans) != 2 {
+		t.Fatalf("the table holds %d plans: %v", len(wasPlans), err)
+	}
+	wasMerge, _, _ := inv.MergeOf(ctx, "novox/mesh-catalog", "m-walk")
+
+	reports, err := inv.MoveChain(ctx, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var moved MoveReport
+	for _, r := range reports {
+		if r.Kind == KindRollouts {
+			moved = r
+		}
+	}
+	// Two plans, and the record of the merge whose plan the store never kept.
+	if moved.Rows != 3 || moved.TableRows != 6 || moved.Written != 3 {
+		t.Fatalf("the move of the rollouts reported %+v", moved)
+	}
+	nowPlans, err := inv.RecentPlans(ctx, 10)
+	if err != nil || len(nowPlans) != 2 {
+		t.Fatalf("the bucket holds %d plans: %v", len(nowPlans), err)
+	}
+	for k := range wasPlans {
+		was, now := wasPlans[k], nowPlans[k]
+		if was.ID != now.ID || was.State != now.State || was.Tier != now.Tier || was.Revision != now.Revision || was.Note != now.Note ||
+			!was.Created.Equal(now.Created) || !reflect.DeepEqual(was.Tiers, now.Tiers) || len(was.Modules) != len(now.Modules) {
+			t.Errorf("plan %s was %+v and is %+v", was.ID, was, now)
+		}
+	}
+	if open, _ := inv.OpenPlans(ctx); len(open) != 1 || open[0].ID != "plan-2" {
+		t.Fatalf("open plans %+v", open)
+	}
+	if batches, _ := inv.Batches(ctx); len(batches) != 1 || batches[0].ID != "plan-1" {
+		t.Fatalf("batches %+v", batches)
+	}
+	if got, _ := inv.MergesOf(ctx, "plan-1"); len(got) != 1 || got[0].Commit != "m-batch" {
+		t.Fatalf("the batch answers %+v", got)
+	}
+	nowMerge, known, _ := inv.MergeOf(ctx, "novox/mesh-catalog", "m-walk")
+	if !known || nowMerge.Plan != "plan-2" || nowMerge.Branch != wasMerge.Branch || !nowMerge.Merged.Equal(wasMerge.Merged) ||
+		!nowMerge.Heard.Equal(wasMerge.Heard) || string(nowMerge.Event) != string(wasMerge.Event) {
+		t.Fatalf("a merge was %+v and is %+v", wasMerge, nowMerge)
+	}
+	alone, _ := inv.AloneMerges(ctx)
+	if len(alone) != 1 || alone[0].Commit != "m-waiting" || alone[0].Plan != "" {
+		t.Fatalf("waiting: %+v", alone)
+	}
+	if dangling, known, _ := inv.MergeOf(ctx, "novox/mesh-catalog", "m-dangling"); !known || dangling.Plan != "" || dangling.Alone {
+		t.Fatalf("a merge whose plan was never kept reads as %+v %v", dangling, known)
+	}
+	if n := rowsInTheTable(t, inv, "release_plan"); n != "2" {
+		t.Fatalf("the table is %s plans", n)
+	}
+	// From now on a plan is saved to the bucket and the table takes none.
+	later := aBatch("plan-3", time.Now().UTC())
+	if err := inv.SavePlan(ctx, later); err != nil {
+		t.Fatal(err)
+	}
+	if n := rowsInTheTable(t, inv, "release_plan"); n != "2" {
+		t.Fatalf("the table took a plan after the move: %s", n)
+	}
+	if again, err := inv.MoveChain(ctx, nil); err != nil || len(again) != 2 || !again[0].Already || !again[1].Already {
+		t.Fatalf("the second move %+v: %v", again, err)
+	}
+}