210 lines
8.2 KiB
Go
210 lines
8.2 KiB
Go
package delivery
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"reflect"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// The take-in events (novox/hq ADR 0633 §1, §5): the indexer publishes them on its own stream, which keeps the last
|
|
// message per subject, `take-in.<kind>.<key>`. A wait starts with `take-in.pending` and ends with `take-in.taken`,
|
|
// whoever ended it (the named indexer, a revert, a hand take-in or a drop). The stream's name is the indexer's manifest's;
|
|
// these names are its events, relative to it.
|
|
const (
|
|
TakeInStream = "take-in"
|
|
TakeInPending = "pending"
|
|
TakeInTaken = "taken"
|
|
)
|
|
|
|
// What waits in a take-in event: a source revision for the indexer build it names, or a delivery group for its end.
|
|
const (
|
|
TakeInRevision = "revision"
|
|
TakeInGroup = "group"
|
|
)
|
|
|
|
// PendingKey is the key of one held merge in the indexer's pending state, and the key a revision's take-in events
|
|
// carry (its oldest merge's): `m.<the merge's stream sequence, 20 digits>`, so the key order is the merge order.
|
|
func PendingKey(seq uint64) string { return fmt.Sprintf("m.%020d", seq) }
|
|
|
|
// GroupTakeInKey is the key a group's take-in events carry while it is gathered: `g.<group>`, with every character a
|
|
// bus subject cannot carry (a space, `*`, `>`) written `_`. The event's body names the group exactly.
|
|
func GroupTakeInKey(group string) string {
|
|
return "g." + strings.Map(func(r rune) rune {
|
|
if r == '*' || r == '>' || r <= ' ' || r == 0x7f {
|
|
return '_'
|
|
}
|
|
return r
|
|
}, group)
|
|
}
|
|
|
|
// TakeInEvent is the name of a take-in event of the given kind and key: `take-in.<pending|taken>.<key>`.
|
|
func TakeInEvent(kind, key string) (string, error) {
|
|
if kind != TakeInPending && kind != TakeInTaken {
|
|
return "", fmt.Errorf("delivery: the take-in kind %q is not pending or taken", kind)
|
|
}
|
|
if err := checkTakeInKey(key); err != nil {
|
|
return "", err
|
|
}
|
|
return TakeInStream + "." + kind + "." + key, nil
|
|
}
|
|
|
|
// ParseTakeInEvent is the inverse of TakeInEvent.
|
|
func ParseTakeInEvent(event string) (kind, key string, err error) {
|
|
parts := strings.SplitN(event, ".", 3)
|
|
if len(parts) != 3 || parts[0] != TakeInStream {
|
|
return "", "", fmt.Errorf("delivery: %q is not a take-in event, take-in.<pending|taken>.<key>", event)
|
|
}
|
|
if _, err := TakeInEvent(parts[1], parts[2]); err != nil {
|
|
return "", "", fmt.Errorf("delivery: %q is not a take-in event: %w", event, err)
|
|
}
|
|
return parts[1], parts[2], nil
|
|
}
|
|
|
|
func checkTakeInKey(key string) error {
|
|
if !strings.HasPrefix(key, "m.") && !strings.HasPrefix(key, "g.") {
|
|
return fmt.Errorf("delivery: the take-in key %q is neither m.<sequence> nor g.<group>", key)
|
|
}
|
|
for _, tok := range strings.Split(key, ".") {
|
|
if tok == "" || strings.ContainsAny(tok, "*> \t\r\n") {
|
|
return fmt.Errorf("delivery: the take-in key %q is not a bus subject's tokens", key)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// TakeIn is the body of a take-in event. Kind is the event's kind and Key its key. What says what waits: a revision
|
|
// (Key its oldest merge's PendingKey, WaitsFor the indexer build it names) or a group being gathered (Key its
|
|
// GroupTakeInKey, Members every approved member with its head, Merges the members held so far). Merges are the merges
|
|
// it holds, oldest first; Since is when the wait began. A `taken` event names the same once the wait ended; By and Why
|
|
// name a hand act (a hand take-in, or a drop, Dropped), and are carried by nothing else.
|
|
type TakeIn struct {
|
|
V int `json:"v"`
|
|
Kind string `json:"kind"`
|
|
Key string `json:"key"`
|
|
What string `json:"what"`
|
|
Merges []GroupMerge `json:"merges"`
|
|
Group string `json:"group,omitempty"`
|
|
Members []Head `json:"members,omitempty"`
|
|
WaitsFor string `json:"waits-for,omitempty"`
|
|
Since time.Time `json:"since"`
|
|
By string `json:"by,omitempty"`
|
|
Why string `json:"why,omitempty"`
|
|
Dropped bool `json:"dropped,omitempty"`
|
|
}
|
|
|
|
func (t TakeIn) check() error {
|
|
if _, err := TakeInEvent(t.Kind, t.Key); err != nil {
|
|
return err
|
|
}
|
|
if len(t.Merges) == 0 {
|
|
return fmt.Errorf("delivery: the take-in event %s names no merge", t.Key)
|
|
}
|
|
for _, m := range t.Merges {
|
|
if err := checkRepository(m.Repository); err != nil {
|
|
return err
|
|
}
|
|
if m.Merge == "" {
|
|
return fmt.Errorf("delivery: the take-in event %s names a merge of %s without its commit", t.Key, m.Repository)
|
|
}
|
|
}
|
|
if t.Since.IsZero() {
|
|
return fmt.Errorf("delivery: the take-in event %s does not say since when it waits", t.Key)
|
|
}
|
|
switch t.What {
|
|
case TakeInRevision:
|
|
if !strings.HasPrefix(t.Key, "m.") {
|
|
return fmt.Errorf("delivery: a revision's take-in key is its oldest merge's m.<sequence>, not %q", t.Key)
|
|
}
|
|
if t.Kind == TakeInPending && t.WaitsFor == "" {
|
|
return fmt.Errorf("delivery: a pending revision %s names the indexer build it waits for", t.Key)
|
|
}
|
|
case TakeInGroup:
|
|
if t.Group == "" {
|
|
return fmt.Errorf("delivery: a group's take-in event %s names its group", t.Key)
|
|
}
|
|
if t.Key != GroupTakeInKey(t.Group) {
|
|
return fmt.Errorf("delivery: the take-in key of the group %q is %s, not %s", t.Group, GroupTakeInKey(t.Group), t.Key)
|
|
}
|
|
if t.WaitsFor != "" {
|
|
return fmt.Errorf("delivery: a group being gathered waits for its end, not for an indexer build")
|
|
}
|
|
default:
|
|
return fmt.Errorf("delivery: a take-in event's what %q is not revision or group", t.What)
|
|
}
|
|
if t.Kind != TakeInTaken && (t.By != "" || t.Why != "" || t.Dropped) {
|
|
return fmt.Errorf("delivery: only a taken event names the hand act that ended a wait")
|
|
}
|
|
if (t.Why != "" || t.Dropped) && t.By == "" {
|
|
return fmt.Errorf("delivery: a hand act's take-in event names who acted (by)")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// EncodeTakeIn is t as JSON at Version; it refuses what its kind and what do not carry.
|
|
func EncodeTakeIn(t TakeIn) ([]byte, error) {
|
|
if err := t.check(); err != nil {
|
|
return nil, err
|
|
}
|
|
t.V = Version
|
|
return json.Marshal(t)
|
|
}
|
|
|
|
// DecodeTakeIn reads a take-in event's body; it refuses an unknown version (ErrUnknownVersion) and what EncodeTakeIn
|
|
// refuses.
|
|
func DecodeTakeIn(data []byte) (TakeIn, error) {
|
|
var t TakeIn
|
|
if err := decode(data, &t); err != nil {
|
|
return TakeIn{}, err
|
|
}
|
|
if err := t.check(); err != nil {
|
|
return TakeIn{}, err
|
|
}
|
|
return t, nil
|
|
}
|
|
|
|
// SameTakeIn says whether two take-in bodies are the same value.
|
|
func SameTakeIn(a, b TakeIn) bool { return reflect.DeepEqual(a, b) }
|
|
|
|
// PendingWait is one wait the indexer's tool indexer_pending answers (novox/hq ADR 0633 §5), as the view reads it to
|
|
// name a module waiting for its revision's indexer. Key and What are a take-in event's: a revision under its oldest
|
|
// merge's key, waiting for the indexer build WaitsFor (empty while it is worked out), or a group being gathered under
|
|
// its group key, with Members every approved member and Merges those held so far. A revision that waits behind a
|
|
// group being gathered names that group's key in Behind. Holds are the modules it holds back: every module of its
|
|
// merges' trees. Said is the last take-in event said of it (`take-in.<kind>.<key>`) and SaidAt when.
|
|
type PendingWait struct {
|
|
Key string `json:"key"`
|
|
What string `json:"what"`
|
|
Merges []GroupMerge `json:"merges"`
|
|
Group string `json:"group,omitempty"`
|
|
Members []Head `json:"members,omitempty"`
|
|
Behind string `json:"behind,omitempty"`
|
|
WaitsFor string `json:"waits-for,omitempty"`
|
|
Since time.Time `json:"since"`
|
|
Holds []string `json:"holds"`
|
|
Said string `json:"said,omitempty"`
|
|
SaidAt time.Time `json:"said-at,omitzero"`
|
|
}
|
|
|
|
// PendingAnswer is indexer_pending's answer: every wait, oldest first, and the pending keys that do not read.
|
|
type PendingAnswer struct {
|
|
Waits []PendingWait `json:"waits"`
|
|
Unread []string `json:"unread,omitempty"`
|
|
}
|
|
|
|
// DecodePendingAnswer reads indexer_pending's answer, refusing a wait that is not a revision or a group, or names no
|
|
// key.
|
|
func DecodePendingAnswer(data []byte) (PendingAnswer, error) {
|
|
var a PendingAnswer
|
|
if err := json.Unmarshal(data, &a); err != nil {
|
|
return a, fmt.Errorf("delivery: not an answer of indexer_pending: %w", err)
|
|
}
|
|
for _, w := range a.Waits {
|
|
if w.Key == "" || (w.What != TakeInRevision && w.What != TakeInGroup) {
|
|
return a, fmt.Errorf("delivery: indexer_pending answers a wait %q of %q, not a revision or a group", w.Key, w.What)
|
|
}
|
|
}
|
|
return a, nil
|
|
}
|