Add CIPD pin reporting to swarming.

appengine/swarming/handlers_frontend.py

 # Copyright 2013 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.
 
 """Main entry point for Swarming service.
 
 This file contains the URL handlers for all the Swarming service URLs,
 implemented using the webapp2 framework.
 """
 
@@ skipping 598 matching lines @@
     if not request or not result:
       self.abort(404, '%s not found.' % key.id())
     if not request.has_access:
       self.abort(403, '%s is not accessible.' % key.id())
     return request, result
 
 
 class TaskHandler(BaseTaskHandler):
   """Show the full text of a task request and its result."""
 
+  class PinInfo(object):
+    def __init__(self, pkg, pin):
+      assert pin is None or pkg.path == pin.path
+      self.pkg = pkg
+      self.pin = pin
+
+
+  @staticmethod
+  def pininfos_grouped_by_path(inputs, outputs):
+    """Returns sorted [(path, [PinInfo, ...])].
+
+    PinInfo is a namedtuple with two fields 'pkg' and 'pin'. 'pkg' is the
+    CipdPackage that was specified in the task request. 'pin' is the CipdPackage
+    that was resolved by the bot at runtime, and contains a full package name as
+    well as a package instance id.
+
+    If pinning information is unavailable pin is None.
+
+    Used by user_task.html.
+    """
+    packages = inputs.packages
+    pins = None
+    if outputs:
+      pins = outputs.packages

[M-A Ruel, 2016/08/26 23:19:51]

this code assumes the order is the same but this was not yet enforced. Also I
don't find this particularly useful, I'd prefer just to have
packages_grouped_by_path() here and call it once for inputs, once for outputs.

[iannucci, 2016/08/29 22:08:40]

sgtm, I considered this, but thought you might prefer it this way.

+
+    assert pins is None or len(pins) == len(packages)

[M-A Ruel, 2016/08/26 23:19:51]

This assert should be done at the time the entity is saved as commented in
task_result.py.

[iannucci, 2016/08/29 22:08:40]

yep, done

+    pinned = pins is not None
+
+    retval = collections.defaultdict(list)
+    for i, pkg in enumerate(packages):
+      retval[pkg.path].append(TaskHandler.PinInfo(
+        pkg, pins[i] if pinned else None))
+    for pkgs in retval.itervalues():
+      pkgs.sort()

[M-A Ruel, 2016/08/26 23:19:51]

see comment in task_request.py

+    return sorted(retval.iteritems())
+
   @auth.autologin
   @auth.require(acl.is_user)
   def get(self, task_id):
     request, result = self.get_request_and_result(task_id)
     parent_task_future = None
     if request.parent_task_id:
       parent_key = task_pack.unpack_run_result_key(request.parent_task_id)
       parent_task_future = parent_key.get_async()
     children_tasks_futures = [
       task_pack.unpack_result_summary_key(c).get_async()
@@ skipping 27 matching lines @@
 
     previous_task = None
     if previous_task_future:
       previous_task = previous_task_future.get_result()
 
     parent_task = None
     if parent_task_future:
       parent_task = parent_task_future.get_result()
     children_tasks = [c.get_result() for c in children_tasks_futures]
 
+    cipd = None
+    cipd_pinned = False
+    if request.properties.cipd_input:
+      cipd_pinned = result.cipd_pins is not None

[M-A Ruel, 2016/08/26 23:19:51]

do one for input, one for pinned without mixing both. That's what the polymer
code will have to do anyway, this code will be deleted soon.

+      cipd = {
+        'server': request.properties.cipd_input.server,
+        'client_package': TaskHandler.PinInfo(
+          request.properties.cipd_input.client_package,
+          result.cipd_pins.client_package if cipd_pinned else None),
+        'packages': self.pininfos_grouped_by_path(request.properties.cipd_input,
+                                                  result.cipd_pins),
+      }
+
     params = {
       'bot': bot_future.get_result() if bot_future else None,
       'children_tasks': children_tasks,
+      'cipd': cipd,
+      'cipd_pinned': cipd_pinned,
       'is_admin': acl.is_admin(),
       'is_gae_admin': users.is_current_user_admin(),
       'is_privileged_user': acl.is_privileged_user(),
       'following_task': following_task,
       'full_appid': os.environ['APPLICATION_ID'],
       'host_url': self.request.host_url,
       'is_running': result.state == task_result.State.RUNNING,
       'parent_task': parent_task,
       'previous_task': previous_task,
       'request': request,
       'task': result,
       'xsrf_token': self.generate_xsrf_token(),
     }
+

[M-A Ruel, 2016/08/26 23:19:51]

remove

     self.response.write(template.render('swarming/user_task.html', params))
 
 
 class TaskCancelHandler(BaseTaskHandler):
   """Cancel a task."""
 
   @auth.require(acl.is_user)
   def post(self, task_id):
     request, result = self.get_request_and_result(task_id)
     if not task_scheduler.cancel_task(request, result.key)[0]:
@@ skipping 124 matching lines @@
 
   # If running on a local dev server, allow bots to connect without prior
   # groups configuration. Useful when running smoke test.
   if utils.is_local_dev_server():
     acl.bootstrap_dev_server_acls()
 
   routes.extend(handlers_backend.get_routes())
   routes.extend(handlers_bot.get_routes())
   routes.extend(handlers_endpoints.get_routes())
   return webapp2.WSGIApplication(routes, debug=debug)