Measure each fix from the move to fixing to delivered, and say one over its budget (issue 403)
mesh/merge-gate pass: builds mesh-delivery, mesh-issues → novox; no bus step; every machine composes with the change as it did without (4 of 4 compose)
mesh/repo-check pass: its merge-check.sh passed, each part in its toolchain: merge-check.sh (go), merge-check-typescript.sh (typescript)
mesh/delivery-group group fix/403-fix-time ready: every member ready, and composed together they pass
mesh/delivery superseded: a newer head of the same pull request
mesh/merge-gate pass: builds mesh-delivery, mesh-issues → novox; no bus step; every machine composes with the change as it did without (4 of 4 compose)
mesh/repo-check pass: its merge-check.sh passed, each part in its toolchain: merge-check.sh (go), merge-check-typescript.sh (typescript)
mesh/delivery-group group fix/403-fix-time ready: every member ready, and composed together they pass
mesh/delivery superseded: a newer head of the same pull request
hq ADR 0313: the operator's five minutes start when an agent moves the issue to fixing, not at the merge. mesh-delivery says on each transition, and in checks, when the pull request opened, when it merged and the class of what it moves. mesh-issues keeps the first move to fixing, the fix time with its four phases once the last fix is delivered, serves fix-times, and says issue-tracker.fix.<class>.over-budget on the operator's channel, cleared by the next fix of that class within budget.
This commit is contained in:
@@ -0,0 +1,597 @@
|
||||
package main
|
||||
|
||||
// A fix's time (novox/hq ADR 0313, issue 403). An issue's fix time runs from its first move to fixing to the moment
|
||||
// the last of its fixes is delivered to every machine it should reach. It is held to the fix budget of its class —
|
||||
// five minutes for a leaf module, ten for a core one — and split into four phases read from the fix delivered
|
||||
// last: implementing (to its pull request opened), review (to an approval at its head), checks (to its merge) and
|
||||
// merge to running (to delivered, its delivery time). A fix over its budget is said on the operator's channel once
|
||||
// it is final, naming the issue, its worker and its longest phase; the warning clears when the next issue of that
|
||||
// class is delivered within its budget. `fix-times` answers the last days' median and worst per class.
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
stdio "git.novox.be/novox/mesh-sdk/go"
|
||||
)
|
||||
|
||||
// The classes of a fix (ADR 0282 §1, ADR 0313 §2) and the class of a fix that moves no module.
|
||||
const (
|
||||
ClassCore = "core"
|
||||
ClassLeaf = "leaf"
|
||||
ClassNone = "none"
|
||||
)
|
||||
|
||||
// FixBudgets are the fix budgets by class, counted from the move to fixing (ADR 0313 §2).
|
||||
var FixBudgets = map[string]time.Duration{ClassLeaf: 5 * time.Minute, ClassCore: 10 * time.Minute}
|
||||
|
||||
// fixClasses in the order `fix-times` says them.
|
||||
var fixClasses = []string{ClassLeaf, ClassCore}
|
||||
|
||||
// The phases of a fix time, in order (ADR 0313 §4).
|
||||
const (
|
||||
PhaseImplementing = "implementing"
|
||||
PhaseReview = "review"
|
||||
PhaseChecks = "checks"
|
||||
PhaseRunning = "merge to running"
|
||||
)
|
||||
|
||||
// FixTime is an issue's fix time, kept on it once the last of its fixes is delivered.
|
||||
type FixTime struct {
|
||||
// From is the first move to fixing; End when the fix delivered last was delivered.
|
||||
From time.Time `json:"from"`
|
||||
End time.Time `json:"end"`
|
||||
TookMS int64 `json:"took_ms"`
|
||||
Took string `json:"took"`
|
||||
// Class is core, leaf or none; empty when a fix's class is not known. A fix of class none, or one not known,
|
||||
// has no budget: its time is shown and never warned on.
|
||||
Class string `json:"class,omitempty"`
|
||||
Budget string `json:"budget,omitempty"`
|
||||
BudgetMS int64 `json:"budget_ms,omitempty"`
|
||||
Over bool `json:"over,omitempty"`
|
||||
// Fix is the pull request delivered last, which the phases are read from; Worker who worked on the issue.
|
||||
Fix string `json:"fix"`
|
||||
Worker string `json:"worker,omitempty"`
|
||||
Phases []FixPhase `json:"phases"`
|
||||
Longest string `json:"longest,omitempty"`
|
||||
Said string `json:"said"`
|
||||
// Warned says the over-budget warning was said for it on the operator's channel and not cleared since.
|
||||
Warned bool `json:"warned,omitempty"`
|
||||
}
|
||||
|
||||
// FixPhase is one phase of a fix time: measured, or unknown when the moment that ends it is not known — its time is
|
||||
// then counted in the phase after it, which says so.
|
||||
type FixPhase struct {
|
||||
Name string `json:"name"`
|
||||
State string `json:"state"`
|
||||
TookMS int64 `json:"took_ms"`
|
||||
Took string `json:"took"`
|
||||
Said string `json:"said,omitempty"`
|
||||
}
|
||||
|
||||
// Approval is when a pull request was first approved at its head, as the forge says it; a test stubs the asking.
|
||||
// found is false when no approval at its head is on the forge.
|
||||
type Approval func(repository string, number int) (at time.Time, found bool, err error)
|
||||
|
||||
// classOfFixes is the class of an issue's fixes: that of the slowest-budgeted module they move — core when any
|
||||
// moves a core module, leaf when any moves a leaf one, none when none moves a module — and empty, with why, when
|
||||
// a fix's class is not known and none is core.
|
||||
func classOfFixes(is *Issue, prs []string) (string, string) {
|
||||
var unknown []string
|
||||
leaf := false
|
||||
for _, pr := range prs {
|
||||
f := fixOf(is, pr)
|
||||
switch {
|
||||
case f == nil || f.Class == "":
|
||||
unknown = append(unknown, pr)
|
||||
case f.Class == ClassCore:
|
||||
return ClassCore, ""
|
||||
case f.Class == ClassLeaf:
|
||||
leaf = true
|
||||
}
|
||||
}
|
||||
if len(unknown) > 0 {
|
||||
return "", "the delivery did not say what " + strings.Join(unknown, ", ") + " moves"
|
||||
}
|
||||
if leaf {
|
||||
return ClassLeaf, ""
|
||||
}
|
||||
return ClassNone, ""
|
||||
}
|
||||
|
||||
// fixPhases splits the span from start to the delivered moment at the moments that end each phase, in order. A
|
||||
// phase whose end is not known is unknown, and its time counts in the next phase known; a phase whose end came
|
||||
// before the end of the phase before it counts zero (ADR 0313 §4). The phases add up to the fix time.
|
||||
func fixPhases(start time.Time, ends []struct {
|
||||
name string
|
||||
at *time.Time
|
||||
why string
|
||||
}) ([]FixPhase, string) {
|
||||
var out []FixPhase
|
||||
prev := start
|
||||
var carried []string
|
||||
for _, e := range ends {
|
||||
if e.at == nil {
|
||||
out = append(out, FixPhase{Name: e.name, State: "unknown", Took: "0s", Said: e.why})
|
||||
carried = append(carried, e.name)
|
||||
continue
|
||||
}
|
||||
took := time.Duration(0)
|
||||
if e.at.After(prev) {
|
||||
took = e.at.Sub(prev)
|
||||
prev = *e.at
|
||||
}
|
||||
p := FixPhase{Name: e.name, State: "measured", TookMS: took.Milliseconds(), Took: took.Round(time.Second).String()}
|
||||
if len(carried) > 0 {
|
||||
p.Said = "counts " + strings.Join(carried, " and ") + " too: its end is not known"
|
||||
carried = nil
|
||||
}
|
||||
out = append(out, p)
|
||||
}
|
||||
best := -1
|
||||
for i, p := range out {
|
||||
if p.State == "measured" && (best < 0 || p.TookMS > out[best].TookMS) {
|
||||
best = i
|
||||
}
|
||||
}
|
||||
longest := ""
|
||||
if best >= 0 {
|
||||
longest = out[best].Name + " " + out[best].Took
|
||||
}
|
||||
return out, longest
|
||||
}
|
||||
|
||||
// startOfFixing is when an issue was first moved to fixing: the earliest of what it keeps and what its log says
|
||||
// (an issue moved before the tracker kept the moment is read from its log, a value carried into the log at its
|
||||
// worker's since). Zero when it never was.
|
||||
func (t *Tracker) startOfFixing(is *Issue) time.Time {
|
||||
var start time.Time
|
||||
if is.FixingFrom != nil {
|
||||
start = *is.FixingFrom
|
||||
}
|
||||
if t.Log == nil {
|
||||
return start
|
||||
}
|
||||
entries, err := t.readKey(is.Number, 0)
|
||||
if err != nil {
|
||||
t.Logf("[mesh-issues] the log of %d could not be read for its first move to fixing (its kept moment is used): %v", is.Number, err)
|
||||
return start
|
||||
}
|
||||
status := ""
|
||||
for _, e := range entries {
|
||||
var op Operation
|
||||
if json.Unmarshal(e.Value, &op) != nil {
|
||||
continue
|
||||
}
|
||||
at, became := op.At, ""
|
||||
switch {
|
||||
case op.Issue != nil:
|
||||
became = op.Issue.Status
|
||||
if op.Issue.Worker != nil && !op.Issue.Worker.Since.IsZero() {
|
||||
at = op.Issue.Worker.Since
|
||||
}
|
||||
case op.Set["status"] != nil:
|
||||
_ = json.Unmarshal(op.Set["status"], &became)
|
||||
default:
|
||||
continue
|
||||
}
|
||||
if became == StatusFixing && status != StatusFixing && !at.IsZero() {
|
||||
if start.IsZero() || at.Before(start) {
|
||||
start = at.UTC()
|
||||
}
|
||||
break
|
||||
}
|
||||
status = became
|
||||
}
|
||||
return start
|
||||
}
|
||||
|
||||
// fixTimeOf is an issue's fix time once every fix it names is delivered; nil, with why, when it is not measured.
|
||||
func (t *Tracker) fixTimeOf(is *Issue) (*FixTime, string) {
|
||||
if !allDelivered(is) {
|
||||
return nil, "not every fix is delivered"
|
||||
}
|
||||
start := t.startOfFixing(is)
|
||||
if start.IsZero() {
|
||||
return nil, "it was never moved to fixing"
|
||||
}
|
||||
prs := liveFixes(is)
|
||||
var last *Fix
|
||||
for _, pr := range prs {
|
||||
if f := fixOf(is, pr); f != nil && (last == nil || f.Since.After(last.Since)) {
|
||||
last = f
|
||||
}
|
||||
}
|
||||
if last == nil {
|
||||
return nil, "no fix is heard of"
|
||||
}
|
||||
end := last.Since.UTC()
|
||||
took := time.Duration(0)
|
||||
if end.After(start) {
|
||||
took = end.Sub(start)
|
||||
}
|
||||
ft := &FixTime{From: start, End: end, TookMS: took.Milliseconds(), Took: took.Round(time.Second).String(), Fix: last.PullRequest}
|
||||
if is.Worker != nil {
|
||||
ft.Worker = is.Worker.By
|
||||
} else if is.FixTime != nil {
|
||||
ft.Worker = is.FixTime.Worker
|
||||
}
|
||||
class, why := classOfFixes(is, prs)
|
||||
ft.Class = class
|
||||
if b, ok := FixBudgets[class]; ok {
|
||||
ft.Budget, ft.BudgetMS, ft.Over = b.String(), b.Milliseconds(), took > b
|
||||
}
|
||||
|
||||
// The phases, from the fix delivered last.
|
||||
type end_ = struct {
|
||||
name string
|
||||
at *time.Time
|
||||
why string
|
||||
}
|
||||
var approved *time.Time
|
||||
approvalWhy := "no approval at its head is on the forge: review and checks are counted together"
|
||||
if t.Approval != nil {
|
||||
repo, number, _ := strings.Cut(last.PullRequest, "#")
|
||||
var n int
|
||||
if _, err := fmt.Sscanf(number, "%d", &n); err == nil {
|
||||
at, found, err := t.Approval(repo, n)
|
||||
switch {
|
||||
case err != nil:
|
||||
approvalWhy = "the forge could not be read for its approval (" + cut(err.Error(), 200) + "): review and checks are counted together"
|
||||
case found:
|
||||
a := at.UTC()
|
||||
approved = &a
|
||||
}
|
||||
}
|
||||
} else {
|
||||
approvalWhy = "the forge is not asked here: review and checks are counted together"
|
||||
}
|
||||
openedWhy := "the delivery did not say when its pull request opened: implementing is counted in review"
|
||||
mergedWhy := "the delivery did not say when it merged: checks are counted in merge to running"
|
||||
ft.Phases, ft.Longest = fixPhases(start, []end_{
|
||||
{PhaseImplementing, last.Opened, openedWhy},
|
||||
{PhaseReview, approved, approvalWhy},
|
||||
{PhaseChecks, last.MergedAt, mergedWhy},
|
||||
{PhaseRunning, &end, ""},
|
||||
})
|
||||
|
||||
var said []string
|
||||
said = append(said, fmt.Sprintf("fixed in %s, from the first move to fixing (%s) to %s delivered (%s)", ft.Took,
|
||||
start.Format(time.RFC3339), last.PullRequest, end.Format(time.RFC3339)))
|
||||
switch {
|
||||
case class == ClassNone:
|
||||
said = append(said, "its fixes move no module, so it has no fix budget")
|
||||
case class == "":
|
||||
said = append(said, "no fix budget: "+why)
|
||||
case ft.Over:
|
||||
said = append(said, fmt.Sprintf("over its %s fix budget of %s", class, ft.Budget))
|
||||
default:
|
||||
said = append(said, fmt.Sprintf("within its %s fix budget of %s", class, ft.Budget))
|
||||
}
|
||||
if ft.Longest != "" {
|
||||
said = append(said, "longest: "+ft.Longest)
|
||||
}
|
||||
ft.Said = strings.Join(said, "; ")
|
||||
return ft, ""
|
||||
}
|
||||
|
||||
// sameFixTime says whether two fix times say the same, the warning's mark aside.
|
||||
func sameFixTime(a, b *FixTime) bool {
|
||||
if a == nil || b == nil {
|
||||
return a == b
|
||||
}
|
||||
x, y := *a, *b
|
||||
x.Warned, y.Warned = false, false
|
||||
ra, _ := json.Marshal(x)
|
||||
rb, _ := json.Marshal(y)
|
||||
return string(ra) == string(rb)
|
||||
}
|
||||
|
||||
// timeFix keeps an issue's fix time once every fix it names is delivered, and again when a later fix moves its
|
||||
// end; then the warnings of its class are judged.
|
||||
func (t *Tracker) timeFix(n uint64) error {
|
||||
is, _, err := read(t.Store, n)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
ft, _ := t.fixTimeOf(is)
|
||||
if ft == nil || sameFixTime(ft, is.FixTime) {
|
||||
return nil
|
||||
}
|
||||
if _, err := t.change(n, Act{Op: "fix-time", By: Seat}, func(i *Issue) error {
|
||||
if i.FixTime != nil {
|
||||
ft.Warned = i.FixTime.Warned
|
||||
}
|
||||
i.FixTime = ft
|
||||
return nil
|
||||
}); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := t.judgeFixBudgets(); err != nil {
|
||||
t.Logf("[mesh-issues] a fix over its budget could not be said or cleared on the operator's channel (tried again at the next sweep): %v", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// fixOverKey is the warning a fix over its class's budget raises (ADR 0313 §6).
|
||||
func fixOverKey(class string) string { return "issue-tracker.fix." + class + ".over-budget" }
|
||||
|
||||
// judgeFixBudgets says or clears each class's warning by the newest fix time of the class (ADR 0313 §6): the newest
|
||||
// over its budget and not yet said is said; the newest within its budget clears what was said for the class. Run
|
||||
// after every fix time kept and at every sweep, so a warning that failed is said, or cleared, at the next.
|
||||
func (t *Tracker) judgeFixBudgets() error {
|
||||
if t.Notify == nil {
|
||||
return nil
|
||||
}
|
||||
all, err := t.allIssues()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
var firstErr error
|
||||
for _, class := range fixClasses {
|
||||
var newest *Issue
|
||||
var warned []uint64
|
||||
for _, is := range all {
|
||||
ft := is.FixTime
|
||||
if ft == nil || ft.Class != class {
|
||||
continue
|
||||
}
|
||||
if ft.Warned {
|
||||
warned = append(warned, is.Number)
|
||||
}
|
||||
if newest == nil || ft.End.After(newest.FixTime.End) || (ft.End.Equal(newest.FixTime.End) && is.Number > newest.Number) {
|
||||
newest = is
|
||||
}
|
||||
}
|
||||
if newest == nil {
|
||||
continue
|
||||
}
|
||||
ft := newest.FixTime
|
||||
if ft.Over {
|
||||
if ft.Warned {
|
||||
continue
|
||||
}
|
||||
worker := ft.Worker
|
||||
if worker == "" {
|
||||
worker = "nobody named"
|
||||
}
|
||||
longest := ft.Longest
|
||||
if longest == "" {
|
||||
longest = "not known"
|
||||
}
|
||||
if err := t.Notify(fixOverKey(class), "warning",
|
||||
fmt.Sprintf("issue %d: fixed in %s, over its %s fix budget of %s (longest: %s)", newest.Number, ft.Took, class, ft.Budget, longest),
|
||||
fmt.Sprintf("A fix took longer than its budget (issue %d)", newest.Number),
|
||||
fmt.Sprintf("Issue %d was fixed in %s, from %s's move to fixing to its last fix delivered, over the %s fix "+
|
||||
"budget of %s. Its longest phase was %s. Nothing is needed from you: it says where fixes lose time. "+
|
||||
"It clears when the next %s fix is delivered within its budget.", newest.Number, ft.Took, worker, class,
|
||||
ft.Budget, longest, class), "", false); err != nil {
|
||||
if firstErr == nil {
|
||||
firstErr = err
|
||||
}
|
||||
continue
|
||||
}
|
||||
if _, err := t.change(newest.Number, Act{Op: "warned", By: Seat}, func(i *Issue) error {
|
||||
if i.FixTime != nil {
|
||||
i.FixTime.Warned = true
|
||||
}
|
||||
return nil
|
||||
}); err != nil && firstErr == nil {
|
||||
firstErr = err
|
||||
}
|
||||
continue
|
||||
}
|
||||
if len(warned) == 0 || ft.BudgetMS == 0 {
|
||||
continue
|
||||
}
|
||||
if err := t.Notify(fixOverKey(class), "", "", "", "", fmt.Sprintf("issue %d's fix was delivered within its %s fix budget (%s of %s)",
|
||||
newest.Number, class, ft.Took, ft.Budget), true); err != nil {
|
||||
if firstErr == nil {
|
||||
firstErr = err
|
||||
}
|
||||
continue
|
||||
}
|
||||
sort.Slice(warned, func(i, j int) bool { return warned[i] < warned[j] })
|
||||
for _, n := range warned {
|
||||
if _, err := t.change(n, Act{Op: "warned", By: Seat}, func(i *Issue) error {
|
||||
if i.FixTime != nil {
|
||||
i.FixTime.Warned = false
|
||||
}
|
||||
return nil
|
||||
}); err != nil && firstErr == nil {
|
||||
firstErr = err
|
||||
}
|
||||
}
|
||||
}
|
||||
return firstErr
|
||||
}
|
||||
|
||||
// FixTimesClass is one class's line of `fix-times`.
|
||||
type FixTimesClass struct {
|
||||
Class string `json:"class"`
|
||||
Budget string `json:"budget"`
|
||||
BudgetMS int64 `json:"budget_ms"`
|
||||
Count int `json:"count"`
|
||||
Within int `json:"within"`
|
||||
Over int `json:"over"`
|
||||
Median string `json:"median,omitempty"`
|
||||
MedianMS int64 `json:"median_ms,omitempty"`
|
||||
Worst string `json:"worst,omitempty"`
|
||||
WorstMS int64 `json:"worst_ms,omitempty"`
|
||||
// WorstIssue is the issue whose fix took the worst time.
|
||||
WorstIssue uint64 `json:"worst_issue,omitempty"`
|
||||
}
|
||||
|
||||
// FixTimesRow is an issue as `fix-times` names it.
|
||||
type FixTimesRow struct {
|
||||
Number uint64 `json:"number"`
|
||||
Title string `json:"title"`
|
||||
Class string `json:"class,omitempty"`
|
||||
Took string `json:"took"`
|
||||
TookMS int64 `json:"took_ms"`
|
||||
Budget string `json:"budget,omitempty"`
|
||||
Longest string `json:"longest,omitempty"`
|
||||
Worker string `json:"worker,omitempty"`
|
||||
Delivered string `json:"delivered"`
|
||||
}
|
||||
|
||||
// FixTimes is the answer of `fix-times`.
|
||||
type FixTimes struct {
|
||||
Days int `json:"days"`
|
||||
Since string `json:"since"`
|
||||
Line string `json:"line"`
|
||||
Classes []FixTimesClass `json:"classes"`
|
||||
// Over is every issue over its budget in the window, newest first, with its longest phase.
|
||||
Over []FixTimesRow `json:"over,omitempty"`
|
||||
// Unbudgeted are the issues fixed in the window with no fix budget: their fixes move no module, or what they
|
||||
// move is not known.
|
||||
Unbudgeted []FixTimesRow `json:"unbudgeted,omitempty"`
|
||||
}
|
||||
|
||||
// MostFixTimesDays is the longest window `fix-times` reads.
|
||||
const MostFixTimesDays = 90
|
||||
|
||||
// FixTimes is the `fix-times` verb: each class's fix budget, the last days' median and worst fix time, and every
|
||||
// issue over its budget with its longest phase (ADR 0313 §5, §7). An issue counts in the window its last fix was
|
||||
// delivered in.
|
||||
func (t *Tracker) FixTimes(days int) (*FixTimes, error) {
|
||||
if days <= 0 {
|
||||
days = 7
|
||||
}
|
||||
if days > MostFixTimesDays {
|
||||
return nil, fmt.Errorf("days %d is more than the %d fix-times reads", days, MostFixTimesDays)
|
||||
}
|
||||
all, err := t.allIssues()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
since := t.now().Add(-time.Duration(days) * 24 * time.Hour)
|
||||
a := &FixTimes{Days: days, Since: since.Format(time.RFC3339)}
|
||||
byClass := map[string][]*Issue{}
|
||||
row := func(is *Issue) FixTimesRow {
|
||||
ft := is.FixTime
|
||||
return FixTimesRow{Number: is.Number, Title: is.Title, Class: ft.Class, Took: ft.Took, TookMS: ft.TookMS, Budget: ft.Budget,
|
||||
Longest: ft.Longest, Worker: ft.Worker, Delivered: ft.End.Format(time.RFC3339)}
|
||||
}
|
||||
for _, is := range all {
|
||||
ft := is.FixTime
|
||||
if ft == nil || ft.End.Before(since) {
|
||||
continue
|
||||
}
|
||||
if _, ok := FixBudgets[ft.Class]; !ok {
|
||||
a.Unbudgeted = append(a.Unbudgeted, row(is))
|
||||
continue
|
||||
}
|
||||
byClass[ft.Class] = append(byClass[ft.Class], is)
|
||||
if ft.Over {
|
||||
a.Over = append(a.Over, row(is))
|
||||
}
|
||||
}
|
||||
newestFirst := func(rows []FixTimesRow) {
|
||||
sort.Slice(rows, func(i, j int) bool {
|
||||
if rows[i].Delivered != rows[j].Delivered {
|
||||
return rows[i].Delivered > rows[j].Delivered
|
||||
}
|
||||
return rows[i].Number > rows[j].Number
|
||||
})
|
||||
}
|
||||
newestFirst(a.Over)
|
||||
newestFirst(a.Unbudgeted)
|
||||
var line []string
|
||||
for _, class := range fixClasses {
|
||||
b := FixBudgets[class]
|
||||
c := FixTimesClass{Class: class, Budget: b.String(), BudgetMS: b.Milliseconds()}
|
||||
is := byClass[class]
|
||||
sort.Slice(is, func(i, j int) bool {
|
||||
if is[i].FixTime.TookMS != is[j].FixTime.TookMS {
|
||||
return is[i].FixTime.TookMS < is[j].FixTime.TookMS
|
||||
}
|
||||
return is[i].Number < is[j].Number
|
||||
})
|
||||
c.Count = len(is)
|
||||
for _, i := range is {
|
||||
if i.FixTime.Over {
|
||||
c.Over++
|
||||
} else {
|
||||
c.Within++
|
||||
}
|
||||
}
|
||||
if n := len(is); n > 0 {
|
||||
ms := is[n/2].FixTime.TookMS
|
||||
if n%2 == 0 {
|
||||
ms = (is[n/2-1].FixTime.TookMS + is[n/2].FixTime.TookMS) / 2
|
||||
}
|
||||
med := time.Duration(ms) * time.Millisecond
|
||||
c.MedianMS, c.Median = ms, med.Round(time.Second).String()
|
||||
worst := is[n-1]
|
||||
c.WorstMS, c.Worst, c.WorstIssue = worst.FixTime.TookMS, worst.FixTime.Took, worst.Number
|
||||
line = append(line, fmt.Sprintf("%s: median %s, worst %s (issue %d), %d of %d within %s", class, c.Median,
|
||||
c.Worst, c.WorstIssue, c.Within, c.Count, c.Budget))
|
||||
} else {
|
||||
line = append(line, fmt.Sprintf("%s: no issue fixed", class))
|
||||
}
|
||||
a.Classes = append(a.Classes, c)
|
||||
}
|
||||
a.Line = fmt.Sprintf("fix time over the last %d day(s), from the move to fixing to delivered — %s", days, strings.Join(line, "; "))
|
||||
if len(a.Unbudgeted) > 0 {
|
||||
a.Line += fmt.Sprintf("; %d fixed with no fix budget", len(a.Unbudgeted))
|
||||
}
|
||||
return a, nil
|
||||
}
|
||||
|
||||
// firstApproval is when a pull request was first approved at its head among the forge's reviews: an approval
|
||||
// dismissed, or of an older head, does not count.
|
||||
func firstApproval(raw json.RawMessage) (time.Time, bool, error) {
|
||||
var a struct {
|
||||
Reviews []struct {
|
||||
State string `json:"state"`
|
||||
AtHead bool `json:"at_head"`
|
||||
Submitted string `json:"submitted"`
|
||||
Stale bool `json:"stale"`
|
||||
Dismissed bool `json:"dismissed"`
|
||||
} `json:"reviews"`
|
||||
}
|
||||
var s string
|
||||
if json.Unmarshal(raw, &s) == nil {
|
||||
raw = json.RawMessage(s)
|
||||
}
|
||||
var wrapped struct {
|
||||
Content []struct {
|
||||
Text string `json:"text"`
|
||||
} `json:"content"`
|
||||
}
|
||||
if json.Unmarshal(raw, &wrapped) == nil && len(wrapped.Content) > 0 {
|
||||
raw = json.RawMessage(wrapped.Content[0].Text)
|
||||
}
|
||||
if err := json.Unmarshal(raw, &a); err != nil || a.Reviews == nil {
|
||||
return time.Time{}, false, fmt.Errorf("the forge's gitea_pull_reviews answered no reviews: %.200s", raw)
|
||||
}
|
||||
var first time.Time
|
||||
for _, r := range a.Reviews {
|
||||
if r.State != "APPROVED" || !r.AtHead || r.Stale || r.Dismissed {
|
||||
continue
|
||||
}
|
||||
at, err := time.Parse(time.RFC3339, r.Submitted)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
if first.IsZero() || at.Before(first) {
|
||||
first = at
|
||||
}
|
||||
}
|
||||
return first, !first.IsZero(), nil
|
||||
}
|
||||
|
||||
// busApproval asks the forge's reviews of a pull request over the bus (gitea_pull_reviews).
|
||||
func busApproval(owner func() string) Approval {
|
||||
return func(repository string, number int) (time.Time, bool, error) {
|
||||
raw, err := stdio.Ask("gitea.gitea_pull_reviews", map[string]any{"owner": owner(), "repo": repository, "number": number})
|
||||
if err != nil {
|
||||
return time.Time{}, false, err
|
||||
}
|
||||
return firstApproval(raw)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user