Add time and state to builder revision data

infra/tools/builder_alerts/buildbot.py

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import collections
 import datetime
 import json
 import logging
 import operator
 import os
@@ skipping 160 matching lines @@
     # parent_got_foo_revision instead, but non-tester builders
     # don't have the parent_ versions, so we have to fall back
     # to got_foo_revision in those cases!
     # Don't even think about using 'revision' that's wrong too.
     revision = _property_value(build_json, 'parent_' + buildbot_property)
     if not revision:
       revision = _property_value(build_json, buildbot_property)
     revisions[repo_name] = revision
   return revisions
 
+def latest_update_time_for_builder(state, last_build):

[ojan, 2014/08/14 22:47:19]

Look at alert_builder_tests.test_find_current_step_failures_in_progress as an
example. Just create some build-like object and pass those in as last_build.

Can chat in person if you are stuck.

+  last_update = float(0)
+  if state == 'offline':

[ojan, 2014/08/14 22:47:19]

We should get the same time whether the bot is offline or not.

if times[1] != None:
  last_update = float(last_build['times'][1])
else:
  for step in last_build['steps']:
    ...

+    last_update = float(last_build['times'][1])
+  else:
+    for step in last_build['steps']:
+      step_time = float(step['times'][0])
+      last_update = max(step_time, last_update)
+  return last_update
+
 
 # "line too long" pylint: disable=C0301
-def latest_revisions_for_master(cache, master_url, master_json):  # pragma: no cover
-  latest_revisions = collections.defaultdict(dict)
+def latest_builder_info_for_master(cache, master_url, master_json):  # pragma: no cover

[ojan, 2014/08/14 22:47:19]

If you'd be willing to write tests for this while you're at it, that'd be much
appreciated.

+  latest_builder_info = collections.defaultdict(dict)
   master_name = master_name_from_url(master_url)
   for builder_name, builder_json in master_json['builders'].items():
     # recent_builds can include current builds
     recent_builds = set(builder_json['cachedBuilds'])
     active_builds = set(builder_json['currentBuilds'])
+    state = builder_json['state']
     last_finished_id = sorted(recent_builds - active_builds, reverse=True)[0]
+    #last update from here -- if offline last finish time,
+    # otherwise iterate across steps to find the start time of the running one

[ojan, 2014/08/14 22:47:19]

Leftover comment?

     last_build = fetch_build_json(cache,
         master_url, builder_name, last_finished_id)
-    latest_revisions[master_name][builder_name] = \
+    latest_builder_info[master_name][builder_name] = collections.defaultdict(dict)

[ojan, 2014/08/14 22:47:19]

No need to defaultdict here.

latest_builder_info[master_name][builder_name] = {
  'revisions': revisions_from_build(last_build),
  'state': state,
  'lastUpdateTime': latest_update_time_for_builder(state, last_build),
}

+    latest_builder_info[master_name][builder_name]['revisions'] = \

[ojan, 2014/08/14 22:47:19]

The old code had the wrong style. multi-lines should be done with parens.

         revisions_from_build(last_build)
-  return latest_revisions
+    latest_builder_info[master_name][builder_name]['state'] = state
+    latest_builder_info[master_name][builder_name]['lastUpdateTime'] = \
+        latest_update_time_for_builder(state, last_build)
+  return latest_builder_info
 
 
 def warm_build_cache(cache, master_url, builder_name,
     recent_build_ids, active_builds):  # pragma: no cover
   # Cache active (in-progress) builds:
   match_builder_name = lambda build: build['builderName'] == builder_name
   actives = filter(match_builder_name, active_builds)
   for build in actives:
     key = cache_key_for_build(master_url, builder_name, build['number'])
     cache.set(key, build)
 
   active_build_ids = [b['number'] for b in active_builds]
   # recent_build_ids includes active ones.
   finished_build_ids = [b for b in recent_build_ids
       if b not in active_build_ids]
   last_build_id = max(finished_build_ids)
   cache_key = cache_key_for_build(master_url, builder_name, last_build_id)
 
   # We cache in-progress builds, so if the first finished build has a non-None
   # eta, then it's just the cached version from when it was in progress.
   cached_build = cache.get(cache_key)
   if not cached_build or cached_build.get('eta') is not None:
     # reason = 'in progress' if cached_build else 'missing'
     # logging.debug('prefill reason: %s %s' % (max(finished_build_ids), reason))
     prefill_builds_cache(cache, master_url, builder_name)