blob: abd2c776e87642e9931eb6f25f3510ac3ef5a325 [file] [log] [blame]
// Copyright 2015 The LUCI Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//go:generate stringer -type=ComponentType
package ui
import (
"context"
"encoding/json"
"regexp"
"strings"
"time"
"go.chromium.org/luci/common/clock"
"go.chromium.org/luci/milo/common/model"
)
// MiloBuildLegacy denotes a full renderable Milo build page.
// This is slated to be deprecated in April 2019 after the BuildBot turndown.
// This is to be replaced by a new BuildPage struct,
// which encapsulates a Buildbucket Build Proto.
type MiloBuildLegacy struct {
// Summary is a top level summary of the page.
Summary BuildComponent
// Trigger gives information about how and with what information
// the build was triggered.
Trigger *Trigger
// Components is a detailed list of components and subcomponents of the page.
// This is most often used for steps (buildbot/luci) or deps (luci).
Components []*BuildComponent
// PropertyGroup is a list of input and output property of this page.
// This is used for build and emitted properties (buildbot) and quest
// information (luci). This is also grouped by the "type" of property
// so different categories of properties can be separated and sorted.
//
// This is not a map so code that constructs MiloBuildLegacy can control the
// order of property groups, for example show important properties
// first.
PropertyGroup []*PropertyGroup
// Blame is a list of people and commits that is likely to be in relation to
// the thing displayed on this page.
Blame []*Commit
// Mode to render the steps.
StepDisplayPref StepDisplayPref
}
var statusPrecendence = map[model.Status]int{
model.Cancelled: 0,
model.Expired: 1,
model.Exception: 2,
model.InfraFailure: 3,
model.Failure: 4,
model.Warning: 5,
model.Success: 6,
}
// fixComponent fixes possible display inconsistencies with the build, including:
//
// * If the build is complete, all open steps should be closed.
// * Parent steps containing failed steps should also be marked as failed.
// * Components' Collapsed field is set based on StepDisplayPref field.
// * Parent step name prefix is trimmed from the nested substeps.
// * Enforce correct values for StepDisplayPref (set to Collapsed if incorrect).
func fixComponent(comp *BuildComponent, buildFinished time.Time, stripPrefix string, collapseGreen bool) {
// If the build is finished but the step is not finished.
if !buildFinished.IsZero() && comp.ExecutionTime.Finished.IsZero() {
// Then set the finish time to be the same as the build finish time.
comp.ExecutionTime.Finished = buildFinished
comp.ExecutionTime.Duration = buildFinished.Sub(comp.ExecutionTime.Started)
comp.Status = model.InfraFailure
}
// Fix substeps recursively.
for _, substep := range comp.Children {
fixComponent(
substep, buildFinished, comp.Label.String()+".", collapseGreen)
}
// When parent step finishes running, compute its final status as worst
// status, as determined by statusPrecendence map above, among direct children
// and its own status.
if comp.Status.Terminal() {
for _, substep := range comp.Children {
substepStatusPrecedence, ok := statusPrecendence[substep.Status]
if ok && substepStatusPrecedence < statusPrecendence[comp.Status] {
comp.Status = substep.Status
}
}
}
comp.Collapsed = collapseGreen && comp.Status == model.Success
// Strip parent component name from the title.
if comp.Label != nil {
comp.Label.Label = strings.TrimPrefix(comp.Label.Label, stripPrefix)
}
}
var (
farFutureTime = time.Date(2038, time.January, 19, 3, 14, 07, 0, time.UTC)
farPastTime = time.Date(1970, time.January, 1, 0, 0, 0, 0, time.UTC)
)
// fixComponentDuration makes all parent steps have the max duration of all
// of its children.
func fixComponentDuration(c context.Context, comp *BuildComponent) Interval {
// Leaf nodes do not require fixing.
if len(comp.Children) == 0 {
return comp.ExecutionTime
}
// Set start and end times to be out of bounds.
// Each variable can have 3 states:
// 1. Undefined. In which case they're set to farFuture/PastTime
// 2. Current (fin only). In which case it's set to zero time (time.Time{})
// 3. Definite. In which case it's set to a time that isn't either of the above.
start := farFutureTime
fin := farPastTime
for _, subcomp := range comp.Children {
i := fixComponentDuration(c, subcomp)
if i.Started.Before(start) {
start = i.Started
}
switch {
case fin.IsZero():
continue // fin is current, it can't get any farther in the future than that.
case i.Finished.IsZero(), i.Finished.After(fin):
fin = i.Finished // Both of these cased are considered "after".
}
}
comp.ExecutionTime = NewInterval(c, start, fin)
return comp.ExecutionTime
}
// Fix fixes various inconsistencies that users expect to see as part of the
// Build, but didn't make sense as part of the individual components, including:
// * If the build is complete, all open steps should be closed.
// * Parent steps containing failed steps should also be marked as failed.
// * Components' Collapsed field is set based on StepDisplayPref field.
// * Parent step name prefix is trimmed from the nested substeps.
// * Enforce correct values for StepDisplayPref (set to Default if incorrect).
// * Set parent step durations to be the combination of all children.
func (b *MiloBuildLegacy) Fix(c context.Context) {
if b.StepDisplayPref != StepDisplayExpanded && b.StepDisplayPref != StepDisplayNonGreen {
b.StepDisplayPref = StepDisplayDefault
}
for _, comp := range b.Components {
fixComponent(
comp, b.Summary.ExecutionTime.Finished, "",
b.StepDisplayPref == StepDisplayDefault)
// Run duration fixing after component fixing to make sure all of the
// end times are set correctly.
fixComponentDuration(c, comp)
}
}
// BuildSummary returns the BuildSummary representation of the MiloBuildLegacy. This
// is the subset of fields that is interesting to the builder view.
func (b *MiloBuildLegacy) BuildSummary() *BuildSummary {
if b == nil {
return nil
}
result := &BuildSummary{
Link: b.Summary.Label,
Status: b.Summary.Status,
PendingTime: b.Summary.PendingTime,
ExecutionTime: b.Summary.ExecutionTime,
Text: b.Summary.Text,
Blame: b.Blame,
}
if b.Trigger != nil {
result.Revision = &b.Trigger.Commit
}
return result
}
// Trigger is the combination of pointing to a single commit, with information
// about where that commit came from (e.g. the repository), and the project
// that triggered it.
type Trigger struct {
Commit
// Source is the trigger source. In buildbot, this would be the "Reason".
// This has no meaning in SwarmBucket and DM yet.
Source string
// Project is the name of the LUCI project responsible for
// triggering the build.
Project string
}
// Property specifies k/v pair representing some
// sort of property, such as buildbot property, quest property, etc.
type Property struct {
Key string
Value string
}
// PropertyGroup is a cluster of similar properties. In buildbot land this would be the "source".
// This is a way to segregate different types of properties such as Quest properties,
// swarming properties, emitted properties, revision properties, etc.
type PropertyGroup struct {
GroupName string
Property []*Property
}
func (p PropertyGroup) Len() int { return len(p.Property) }
func (p PropertyGroup) Swap(i, j int) {
p.Property[i], p.Property[j] = p.Property[j], p.Property[i]
}
func (p PropertyGroup) Less(i, j int) bool { return p.Property[i].Key < p.Property[j].Key }
// BuildProgress is a way to show progress. Percent should always be specified.
type BuildProgress struct {
// The total number of entries. Shows up as a tooltip. Leave at 0 to
// disable the tooltip.
total uint64
// The number of entries completed. Shows up as <progress> / <total>.
progress uint64
// A number between 0 to 100 denoting the percentage completed.
percent uint32
}
// ComponentType is the type of build component.
type ComponentType int
const (
// Recipe corresponds to a full recipe run. Dependencies are recipes.
Recipe ComponentType = iota
// StepLegacy is a single step of a recipe.
StepLegacy
// Summary denotes that this does not pretain to any particular step.
Summary
)
// MarshalJSON renders enums into String rather than an int when marshalling.
func (c ComponentType) MarshalJSON() ([]byte, error) {
return json.Marshal(c.String())
}
// LogoBanner is a banner of logos that define the OS and devices that a
// component is associated with.
type LogoBanner struct {
OS []Logo
Device []Logo
}
// Interval is a time interval which has a start, an end and a duration.
type Interval struct {
// Started denotes the start time of this interval.
Started time.Time
// Finished denotest the end time of this interval.
Finished time.Time
// Duration is the length of the interval.
Duration time.Duration
}
// NewInterval returns a new interval struct. If end time is empty (eg. Not completed)
// set end time to empty but set duration to the difference between start and now.
// Getting called with an empty start time and non-empty end time is undefined.
func NewInterval(c context.Context, start, end time.Time) Interval {
i := Interval{Started: start, Finished: end}
if start.IsZero() {
return i
}
if end.IsZero() {
i.Duration = clock.Now(c).Sub(start)
} else {
i.Duration = end.Sub(start)
}
return i
}
// BuildComponent represents a single Step, subsetup, attempt, or recipe.
type BuildComponent struct {
// The parent of this component. For buildbot and swarmbucket builds, this
// refers to the builder. For DM, this refers to whatever triggered the Quest.
ParentLabel *Link `json:",omitempty"`
// The main label for the component.
Label *Link
// Status of the build.
Status model.Status
// Banner is a banner of logos that define the OS and devices this
// component is associated with.
Banner *LogoBanner `json:",omitempty"`
// Bot is the machine or execution instance that this component ran on.
Bot *Link `json:",omitempty"`
// Recipe is a link to the recipe this component is based on.
Recipe *Link `json:",omitempty"`
// Source is a link to the external (buildbot, swarming, dm, etc) data
// source that this component relates to.
Source *Link `json:",omitempty"`
// Links to show adjacent to the main label.
MainLink LinkSet `json:",omitempty"`
// Links to show right below the main label. Top-level slice are rows of
// links, second level shows up as
SubLink []LinkSet `json:",omitempty"`
// Designates the progress of the current component. Set null for no progress.
Progress *BuildProgress `json:",omitempty"`
// Pending is time interval that this build was pending.
PendingTime Interval
// Execution is time interval that this build was executing.
ExecutionTime Interval
// The type of component. This manifests itself as a little label on the
// top left corner of the component.
// This is either "RECIPE" or "STEP". An attempt is considered a recipe.
Type ComponentType
// Arbitrary text to display below links. One line per entry,
// newlines are stripped.
Text []string
// Children of the step. Undefined for other types of build components.
Children []*BuildComponent
// Render a step as collapsed or expanded. Undefined for other types of build
// components.
Collapsed bool
}
var rLineBreak = regexp.MustCompile("<br */?>")
// TextBR returns Text, but also splits each line by <br>
func (bc *BuildComponent) TextBR() []string {
var result []string
for _, t := range bc.Text {
result = append(result, rLineBreak.Split(t, -1)...)
}
return result
}
// Navigation is the top bar of the page, used for navigating out of the page.
type Navigation struct {
// Title of the site, is generally consistent throughout the whole site.
SiteTitle *Link
// Title of the page, usually talks about what's currently here
PageTitle *Link
// List of clickable thing to navigate down the hierarchy.
Breadcrumbs []*Link
// List of (smaller) clickable things to display on the right side.
Right []*Link
}
// LinkSet is an ordered collection of Link objects that will be rendered on the
// same line.
type LinkSet []*Link