120 lines
4.8 KiB
Go
120 lines
4.8 KiB
Go
package watch
|
|
|
|
import (
|
|
"fmt"
|
|
"maps"
|
|
"slices"
|
|
"strings"
|
|
"time"
|
|
|
|
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-indexer/takein"
|
|
)
|
|
|
|
// KindTakeInWaits is a source revision or a delivery group the indexer holds back and has not taken in within its bound
|
|
// (novox/hq ADR 0633 §5, issue 1585): a revision for the indexer build it names, a group for its end. It stands until a
|
|
// `take-in.taken` ends the wait, whoever ended it (the named indexer, a revert, a hand take-in or a drop).
|
|
const KindTakeInWaits = "take-in-waits"
|
|
|
|
// The bounds of a take-in wait, from the `take-in.pending` event's own since.
|
|
const (
|
|
TakeInRevisionBound = 60 * time.Minute
|
|
TakeInGroupBound = 30 * time.Minute
|
|
)
|
|
|
|
// takeInRow is the signals table's row of a take-in wait.
|
|
const takeInRow = "take-in"
|
|
|
|
// TakeIn hears one take-in event of the indexer, by its name relative to the indexer (`take-in.<kind>`), the wait's key
|
|
// in its body: a pending one starts the wait for its key, whose bound runs from the event's since, and a taken one ends it. A group's
|
|
// taken event ends the group's wait only: the revision it becomes is its own key and starts its own, longer wait.
|
|
func (w *Watchman) TakeIn(event string, body []byte) {
|
|
kind, err := takein.ParseTakeInEvent(event)
|
|
if err != nil {
|
|
w.say("a take-in event is left: %v", err)
|
|
return
|
|
}
|
|
t, err := takein.DecodeTakeIn(body)
|
|
if err != nil {
|
|
w.say("the body of %s cannot be read, left: %v", event, err)
|
|
return
|
|
}
|
|
if t.Kind != kind {
|
|
w.say("the body of %s says the kind %q, left", event, t.Kind)
|
|
return
|
|
}
|
|
key := t.Key
|
|
w.mu.Lock()
|
|
defer w.mu.Unlock()
|
|
w.takeIn(kind, key, t)
|
|
}
|
|
|
|
// SeedTakeIn starts, at the watchman's start and before its consumer on the take-in stream, the wait of every revision
|
|
// and group the indexer holds now, as indexer_pending answers them (ADR 0633 §5): the consumer is durable, so the
|
|
// pending events it acknowledged before a restart are not heard again, and a wait within its bound would otherwise be
|
|
// lost. Each wait's bound runs from its own since, as a pending event's does; the stream's events that follow replace
|
|
// or end it.
|
|
func (w *Watchman) SeedTakeIn(a takein.PendingAnswer) {
|
|
w.mu.Lock()
|
|
defer w.mu.Unlock()
|
|
for _, wait := range a.Waits {
|
|
w.takeIn(takein.TakeInPending, wait.Key, takein.TakeIn{Kind: takein.TakeInPending, Key: wait.Key, What: wait.What,
|
|
Merges: wait.Merges, Group: wait.Group, Members: wait.Members, WaitsFor: wait.WaitsFor, Since: wait.Since})
|
|
}
|
|
}
|
|
|
|
// takeIn is one take-in event of key, w.mu held.
|
|
func (w *Watchman) takeIn(kind, key string, t takein.TakeIn) {
|
|
finding := FindingKey(ScopeDelivery, key, KindTakeInWaits)
|
|
if kind == takein.TakeInTaken {
|
|
delete(w.takeInHeld, key)
|
|
w.unsignal(takeInRow, key)
|
|
w.unfind(finding)
|
|
return
|
|
}
|
|
bound, what := TakeInRevisionBound, "a source revision waits for the indexer build "+t.WaitsFor
|
|
if t.Unknown != "" {
|
|
what = "a source revision is held because the indexer cannot learn the build it runs (" + t.Unknown + ")"
|
|
}
|
|
if t.What == takein.TakeInGroup {
|
|
bound, what = TakeInGroupBound, "a delivery group is gathered and its end has not come"
|
|
}
|
|
var merges []string
|
|
for _, m := range t.Merges {
|
|
merges = append(merges, m.Repository)
|
|
}
|
|
f := Finding{Scope: ScopeDelivery, ID: key, Kind: KindTakeInWaits, Severity: Warning, Source: "take-in", Since: t.Since,
|
|
Summary: fmt.Sprintf("%s: %s, since %s (%s)", key, what, stamp(t.Since), strings.Join(merges, ", ")),
|
|
Said: fmt.Sprintf("held for %s", bound),
|
|
Headline: "A merged change is held back by the indexer",
|
|
Explanation: "The indexer holds " + what + " and has not taken it in within " + bound.String() + ", so what the merge changes does " +
|
|
"not reach the machines.",
|
|
Needs: "the indexer build it waits for to run, or the take-in by hand (indexer_take_in_pending), or a drop (indexer_drop_pending)"}
|
|
left := bound - w.now().Sub(t.Since)
|
|
w.unfind(finding)
|
|
w.unsignal(takeInRow, key)
|
|
delete(w.takeInHeld, key)
|
|
switch {
|
|
case left > 0:
|
|
w.signal(takeInRow, key, left, signalDue{Do: dueFind, Finding: f})
|
|
case !w.takeInCaught:
|
|
// Past its bound while the stream is still being replayed: the taken event that ended it may be a few messages on,
|
|
// so it is said once the replay has caught up (TakeInCaughtUp), and a taken event before that cancels it.
|
|
w.takeInHeld[key] = f
|
|
default:
|
|
w.find(f)
|
|
}
|
|
}
|
|
|
|
// TakeInCaughtUp tells the watchman its consumer has read the stream up to its end (the last message it delivered said no
|
|
// message pending, or the consumer had none pending at its bind): every wait past its bound that no taken event ended is
|
|
// said now, and the ones heard after are said as they come.
|
|
func (w *Watchman) TakeInCaughtUp() {
|
|
w.mu.Lock()
|
|
defer w.mu.Unlock()
|
|
w.takeInCaught = true
|
|
for _, key := range slices.Sorted(maps.Keys(w.takeInHeld)) {
|
|
w.find(w.takeInHeld[key])
|
|
}
|
|
w.takeInHeld = map[string]Finding{}
|
|
}
|