62 lines
2.9 KiB
Go
62 lines
2.9 KiB
Go
package link
|
|
|
|
import "strconv"
|
|
|
|
// The order of a node's facts (novox/hq ADR 0539 §9, to-be 45 §6, ADR 0227 rule 2).
|
|
//
|
|
// A node-engine says its facts (profile, firewall found, reachable, tunnel, witness, rollbacks, rekey, health) in a report
|
|
// on the bus, and orders them itself: `epoch` and `sequence` are the node-engine's own (Writer `node-engine`), and
|
|
// `report_sequence` numbers each report it makes. The controller keeps the newest account of a machine and refuses an older
|
|
// one, said and counted (rule 2): by epoch, then sequence, then report sequence, each compared only where both claim one.
|
|
// Zero is "no order claimed", never "first". The controller sends a machine no declaration to be ordered by: the order here
|
|
// is only ever the machine's own.
|
|
|
|
// Order is where a node-engine's account stands among its own: the epoch and sequence the node-engine counts. Zero in either
|
|
// claims none.
|
|
type Order struct {
|
|
Epoch int64 `json:"epoch,omitempty"`
|
|
Sequence int64 `json:"sequence,omitempty"`
|
|
}
|
|
|
|
// Words is an order as a person reads it in a log line. Not String: Report embeds Order, and a Stringer
|
|
// promoted onto every report would print each one as its order alone.
|
|
func (o Order) Words() string {
|
|
switch {
|
|
case o.Epoch > 0:
|
|
return "epoch " + strconv.FormatInt(o.Epoch, 10) + ", sequence " + strconv.FormatInt(o.Sequence, 10)
|
|
case o.Sequence > 0:
|
|
return "sequence " + strconv.FormatInt(o.Sequence, 10) + ", no epoch"
|
|
}
|
|
return "no order"
|
|
}
|
|
|
|
// Account is the order of one account of a machine — a report about a declaration: that declaration's
|
|
// order and the node-engine's own number for the report.
|
|
type Account struct {
|
|
Order
|
|
ReportSequence int64
|
|
}
|
|
|
|
// AccountOf is a report's account order.
|
|
func AccountOf(r Report) Account { return Account{Order: r.Order, ReportSequence: r.ReportSequence} }
|
|
|
|
// Ordered says a report comes from a node-engine that orders its reports: it carries a report sequence.
|
|
// Such a report is judged by its order (OlderThan); one without is judged by the digest it names, as
|
|
// before (issue 267).
|
|
func (r Report) Ordered() bool { return r.ReportSequence > 0 }
|
|
|
|
// OlderThan is the controller's rule (to-be 45 §6): whether this account is older than the one kept for
|
|
// the machine — **by epoch, then sequence, then report sequence**, each compared only where both claim
|
|
// one. An account of a declaration of an older epoch is refused; of an older sequence, refused; an older
|
|
// report of the same declaration (a reconcile's, overtaken by the apply's — issue 267), refused. Equal is
|
|
// the same report again, redelivered, and is not refused.
|
|
func (a Account) OlderThan(kept Account) bool {
|
|
if a.Epoch > 0 && kept.Epoch > 0 && a.Epoch != kept.Epoch {
|
|
return a.Epoch < kept.Epoch
|
|
}
|
|
if a.Sequence > 0 && kept.Sequence > 0 && a.Sequence != kept.Sequence {
|
|
return a.Sequence < kept.Sequence
|
|
}
|
|
return a.ReportSequence > 0 && kept.ReportSequence > 0 && a.ReportSequence < kept.ReportSequence
|
|
}
|