include Package proto into Result proto

recipe_engine/run.py

 # 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.
 
 """Entry point for fully-annotated builds.
 
 This script is part of the effort to move all builds to annotator-based
 systems. Any builder configured to use the AnnotatorFactory.BaseFactory()
 found in scripts/master/factory/annotator_factory.py executes a single
 AddAnnotatedScript step. That step (found in annotator_commands.py) calls
@@ skipping 138 matching lines @@
           engine,
           recipe_test_api.DisabledTestData())
 
       s.add_step_text('running recipe: "%s"' % recipe)
     except (loader.LoaderError, ImportError, AssertionError) as e:
       for line in str(e).splitlines():
         s.add_step_text(line)
       s.set_step_status('EXCEPTION')
       if engine_flags and engine_flags.use_result_proto:
         return result_pb2.Result(
+            recipe_package=universe_view.config_file.read(),
             failure=result_pb2.Failure(
                 human_reason=str(e),
                 exception=result_pb2.Exception(
                   traceback=traceback.format_exc().splitlines()
                 )))
       return RecipeResult({
           'status_code': 2,
           'reason': str(e),
       })
 
@@ skipping 132 matching lines @@
     self._get_client('paths')._initialize_with_recipe_api(api)
 
     # TODO(martiniss): Remove this once we've transitioned to the new results
     # format
     if self._engine_flags and self._engine_flags.use_result_proto:
       logging.info("Using new result proto logic")
       return self._new_run(recipe_script, api, properties)
     return self._old_run(recipe_script, api, properties)
 
   def _new_run(self, recipe_script, api, properties):
-    result = None
+    result = result_pb2.Result(
+        recipe_package=self.universe.config_file.read(),
+    )
 
     with self._step_runner.run_context():
       try:
         try:
           recipe_result = recipe_script.run(api, properties)
-          result = result_pb2.Result(json_result=json.dumps(recipe_result))
+          result.json_result = json.dumps(recipe_result)
         finally:
           self._close_through_level(0)
       except recipe_api.StepFailure as f:

[iannucci, 2017/04/05 19:33:53]

So actually; InfraFailures will get caught by this, currently.

-        result = result_pb2.Result(
-          failure=result_pb2.Failure(
-              human_reason=f.reason,
-              failure=result_pb2.StepFailure(
-                  step=f.name
-              )))
+        result.failure.human_reason = f.reason
+        result.failure.failure.step = f.name
 
       except types.StepDataAttributeError as ex:
-        result = result_pb2.Result(
-            failure=result_pb2.Failure(
-                human_reason=ex.message,
-                step_data=result_pb2.StepData(
-                    step=f.name
-                )))
+        result.failure.human_reason = ex.message
+        result.failure.step_data.step = f.name
 
         # Let the step runner run_context decide what to do.
         raise
 
       except subprocess42.TimeoutExpired as ex:
-        result = result_pb2.Result(
-          failure=result_pb2.Failure(
-              human_reason="Step time out: %r" % ex,
-              timeout= result_pb2.Timeout(
-                  timeout_s=ex.timeout
-              )))
+        result.failure.human_reason = "Step time out: %r" % ex
+        result.failure.timeout.timeout_s = ex.timeout
 
       except Exception as ex:
-        result = result_pb2.Result(
-          failure=result_pb2.Failure(
-              human_reason="Uncaught Exception: %r" % ex,
-              exception=result_pb2.Exception(
-                  traceback=traceback.format_exc().splitlines()
-              )))
+        result.failure.human_reason = "Uncaught Exception: %r" % ex
+        result.failure.exception.traceback[:] = (
+            traceback.format_exc().splitlines())
 
         # Let the step runner run_context decide what to do.
         raise
 
     return result
 
   def _old_run(self, recipe_script, api, properties):
     with self._step_runner.run_context():
       try:
         try:
@@ skipping 63 matching lines @@
         results.append(
           loader._invoke_with_properties(
             run_recipe, properties, recipe_script.PROPERTIES,
             properties.keys()))
       except TypeError as e:
         raise TypeError(
             "Got %r while trying to call recipe %s with properties %r" % (
               e, recipe, properties))
 
     return results