jochen
2eb9a22c24
Two controllers could both act (issue 204), a reconcile's report could overtake the apply after it and the digest decided (issue 267), and a grant could make a second writer of a machine's report. - The lease (internal/lease, ADR 0229): mesh-controller_lease key `holder`, 15 s age, renewed every 5 s by compare-and-set; the epoch is the revision it was taken at. The gate is the clock (stops 3 s before expiry); a refused renewal is a loss and the process exits; a holder that stops gives it back. serve takes it before asserting the bus. Epochs kept in the store (migration 0068 controller_epoch) as a floor: a bucket raised from nothing is compacted past it. Unleased (no epoch, S12 urgent) only when nobody holds it and the bus will not let it be written. A shell command acts under the holder's epoch, or its own lease when none. - Declarations carry `epoch` inside the signed envelope, only to a machine whose latest account carried a report_sequence (mesh-host #35); would-send is composed with the epoch last sent. Allot and the send both pass the gate. - Reports: contract in internal/link/order.go (epoch, sequence, report_sequence, older_than, refused_older). Accounts kept by epoch, then sequence, then report sequence; older refused, counted; unordered reports keep the digest rule. Plans by compare-and-set on a revision, with epoch. Conditions and calls carry the epoch and are not written off the lease. - S12 and S13 (naming the writer by epoch) watched, D5 run; reset of the bucket said. Writers table compiled in and enforced in PermissionsFor; the controller no longer publishes mesh.control.>. A contract per consumed kind, and the empty-on-error lint over the repository. - mesh-host pinned to its main with the epoch in the validator (D1 validates the envelope as sent). Needs mesh-host's genesis lock with the lease grant (mesh-host PR) for TestTheInstallersFirstUserListIsWhatTheControllerWouldCompose.
98 lines
3.3 KiB
Go
98 lines
3.3 KiB
Go
package inventory
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// **The durations the bounds are set from are recorded once each** (novox/hq to-be 45 Phase 0): a
|
|
// send measured at its first report and not again at every reconcile that repeats it; a send of
|
|
// something else measures nothing; a new send is a new measurement.
|
|
func TestAnApplyIsMeasuredOncePerSend(t *testing.T) {
|
|
inv := ForTest(t)
|
|
ctx := t.Context()
|
|
node, err := inv.AddNode(ctx, "anchor")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := inv.RecordSent(ctx, node.ID, "d1", nil); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for range 3 { // the report, then two reconciles saying the same
|
|
if err := inv.RecordApplyDuration(ctx, "anchor", "d1", OutcomeApplied); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if err := inv.RecordApplyDuration(ctx, "anchor", "d0", OutcomeApplied); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ds, err := inv.Durations(ctx, DurationApply, time.Now().Add(-time.Hour))
|
|
if err != nil || len(ds) != 1 || ds[0].Subject != "anchor" || ds[0].Detail != OutcomeApplied || ds[0].Took < 0 {
|
|
t.Fatalf("%v %+v", err, ds)
|
|
}
|
|
time.Sleep(10 * time.Millisecond)
|
|
if err := inv.RecordSent(ctx, node.ID, "d2", nil); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := inv.RecordApplyDuration(ctx, "anchor", "d2", OutcomeFailed); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if ds, _ = inv.Durations(ctx, "", time.Now().Add(-time.Hour)); len(ds) != 2 {
|
|
t.Fatalf("a second send was not measured: %+v", ds)
|
|
}
|
|
}
|
|
|
|
// A machine's silence is the time since its last word, once per word.
|
|
func TestASilenceIsMeasuredFromTheLastWord(t *testing.T) {
|
|
inv := ForTest(t)
|
|
ctx := t.Context()
|
|
before := time.Now().Add(-90 * time.Second)
|
|
for range 2 {
|
|
if err := inv.RecordHeartbeatGap(ctx, "anchor", before); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if err := inv.RecordHeartbeatGap(ctx, "anchor", time.Time{}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ds, err := inv.Durations(ctx, DurationHeartbeatGap, time.Now().Add(-time.Hour))
|
|
if err != nil || len(ds) != 1 || ds[0].Took < 90*time.Second || ds[0].Took > 2*time.Minute {
|
|
t.Fatalf("%v %+v", err, ds)
|
|
}
|
|
}
|
|
|
|
// A plan's tier is measured when the plan leaves it — moving on, or ending — and only then.
|
|
func TestAPlansTierIsMeasuredWhenItIsLeft(t *testing.T) {
|
|
inv := ForTest(t)
|
|
ctx := t.Context()
|
|
p := Plan{ID: "plan-1", Repository: "novox/mesh-tools", Commit: "abc", Created: time.Now().UTC(),
|
|
State: PlanBuilding, Tiers: [][]string{{"mesh-tools"}, {"builder"}},
|
|
Modules: map[string]*PlanModule{"mesh-tools": {}, "builder": {}}}
|
|
if err := inv.SavePlan(ctx, &p); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
p.State = PlanRolling // the same tier, saved again
|
|
if err := inv.SavePlan(ctx, &p); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if ds, _ := inv.Durations(ctx, DurationPlanTier, time.Now().Add(-time.Hour)); len(ds) != 0 {
|
|
t.Fatalf("a tier not left was measured: %+v", ds)
|
|
}
|
|
p.Tier = 1
|
|
if err := inv.SavePlan(ctx, &p); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
p.State = PlanDone
|
|
if err := inv.SavePlan(ctx, &p); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := inv.SavePlan(ctx, &p); err != nil { // saved again once ended: nothing more to measure
|
|
t.Fatal(err)
|
|
}
|
|
ds, err := inv.Durations(ctx, DurationPlanTier, time.Now().Add(-time.Hour))
|
|
if err != nil || len(ds) != 2 || ds[0].Subject != "novox/mesh-tools" || ds[0].Ref != "plan-1/tier-0" ||
|
|
ds[1].Ref != "plan-1/tier-1" {
|
|
t.Fatalf("%v %+v", err, ds)
|
|
}
|
|
}
|