[api] Regenerate remote APIs.

buildbucket/client/cmd/buildbucket/inconsistencies.go

 // Copyright 2016 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package main
 
 import (
         "flag"
         "fmt"
         "sort"
@@ skipping 162 matching lines @@
         if factor >= 1 {
                 fmt.Printf("%s is %.1fx faster\n", r.builder2, factor)
         } else {
                 fmt.Printf("%s is %.1fx slower\n", r.builder2, 1/factor)
         }
         fmt.Printf("%s median time: %s\n", r.builder1, time1)
         fmt.Printf("%s median time: %s\n", r.builder2, time2)
         return nil
 }
 
-func (r *inconsistencyRun) fetchBuilds(builder builderID, startingFrom time.Time) ([]*buildbucket.ApiBuildMessage, error) {
+func (r *inconsistencyRun) fetchBuilds(builder builderID, startingFrom time.Time) ([]*buildbucket.ApiCommonBuildMessage, error) {

[nodir, 2017/06/08 01:25:23]

:(

         req := r.client.Search()
         req.Bucket(builder.Bucket)
         req.Tag("builder:" + builder.Builder)
         req.Status("COMPLETED")
         req.MaxBuilds(100)
 
-        var result []*buildbucket.ApiBuildMessage
+        var result []*buildbucket.ApiCommonBuildMessage
         for {
                 res, err := req.Do()
                 if err != nil {
                         return result, err
                 }
                 if res.Error != nil {
                         return result, fmt.Errorf(res.Error.Message)
                 }
 
                 for _, b := range res.Builds {
                         if parseTimestamp(b.CreatedTs).Before(startingFrom) {
                                 return result, nil
                         }
                         result = append(result, b)
                 }
 
                 if len(res.Builds) == 0 || res.NextCursor == "" {
                         break
                 }
                 req.StartCursor(res.NextCursor)
         }
         return result, nil
 }
 
 type buildSet struct {
-        builds     []*buildbucket.ApiBuildMessage
+        builds     []*buildbucket.ApiCommonBuildMessage
         bestResult string
 }
 
 // groupBuilds groups builds by buildset tag.
-func groupBuilds(builds []*buildbucket.ApiBuildMessage) map[string]*buildSet {
+func groupBuilds(builds []*buildbucket.ApiCommonBuildMessage) map[string]*buildSet {
         results := map[string]*buildSet{}
         for _, b := range builds {
                 tags := parseTags(b.Tags)
                 buildSetName := tags["buildset"]
                 if buildSetName == "" {
                         fmt.Printf("skipped build %d: no buildset tag\n", b.Id)
                         continue
                 }
                 set := results[buildSetName]
                 if set == nil {
                         set = &buildSet{}
                         results[buildSetName] = set
                 }
 
                 set.builds = append(set.builds, b)
                 if set.bestResult == "" || b.Result == "SUCCESS" {
                         set.bestResult = b.Result
                 }
         }
         return results
 }
 
 // medianTime returns median completed_time - created_time of successful builds.
-func medianTime(builds []*buildbucket.ApiBuildMessage) time.Duration {
+func medianTime(builds []*buildbucket.ApiCommonBuildMessage) time.Duration {
         if len(builds) == 0 {
                 return 0
         }
         durations := make(durationSlice, 0, len(builds))
         for _, b := range builds {
                 if b.Result != "SUCCESS" {
                         continue
                 }
                 created := parseTimestamp(b.CreatedTs)
                 completed := parseTimestamp(b.CompletedTs)
@@ skipping 19 matching lines @@
                 return time.Time{}
         }
         return time.Unix(ts/1000000, 0)
 }
 
 type durationSlice []time.Duration
 
 func (a durationSlice) Len() int           { return len(a) }
 func (a durationSlice) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
 func (a durationSlice) Less(i, j int) bool { return a[i] < a[j] }