Track step nesting in StreamEngine (Reland).

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 279 matching lines @@
   """
   Knows how to execute steps emitted by a recipe, holds global state such as
   step history and build properties. Each recipe module API has a reference to
   this object.
 
   Recipe modules that are aware of the engine:
     * properties - uses engine.properties.
     * step - uses engine.create_step(...), and previous_step_result.
   """
 
-  ActiveStep = collections.namedtuple('ActiveStep',
-                                      'step step_result open_step nest_level')
+  ActiveStep = collections.namedtuple('ActiveStep', (
+      'step', 'step_result', 'open_step', 'nest_level'))
 
   def __init__(self, step_runner, properties, universe_view):
     """See run_steps() for parameter meanings."""
     self._step_runner = step_runner
     self._properties = properties
     self._universe_view = universe_view
 
     # A stack of ActiveStep objects, holding the most recently executed step at
     # each nest level (objects deeper in the stack have lower nest levels).
     # When we pop from this stack, we close the corresponding step stream.
@@ skipping 25 matching lines @@
 
     This always returns the innermost nested step that is still open --
     presumably the one that just failed if we are in an exception handler."""
     if not self._step_stack:
       raise ValueError(
           "No steps have been run yet, and you are asking for a previous step"
           " result. Check to make sure your code isn't doing incorrect logic"
           " with try-finally blocks.")
     return self._step_stack[-1].step_result
 
-  def _close_to_level(self, level):
-    """Close all open steps that are at least as deep as level."""
-    while self._step_stack and level <= self._step_stack[-1].nest_level:
+  def _close_through_level(self, level):
+    """Close all open steps whose nest level is >= the supplied level.
+
+    Args:
+      level (int): the nest level to close through.
+    """
+    while self._step_stack and self._step_stack[-1].nest_level >= level:
       cur = self._step_stack.pop()
       if cur.step_result:
         cur.step_result.presentation.finalize(cur.open_step.stream)
       cur.open_step.finalize()
 
   def run_step(self, step):
     """
     Runs a step.
 
     Args:
       step: The step to run.
 
     Returns:
       A StepData object containing the result of running the step.
     """
     with util.raises((recipe_api.StepFailure, OSError),
                      self._step_runner.stream_engine):
       ok_ret = step.pop('ok_ret')
       infra_step = step.pop('infra_step')
 
       step_result = None
 
-      nest_level = step.pop('step_nest_level', 0)
-      self._close_to_level(nest_level)
+      nest_level = step.get('step_nest_level', 0)
+      self._close_through_level(nest_level)
 
       open_step = self._step_runner.open_step(step)
       self._step_stack.append(self.ActiveStep(
           step=step,
           step_result=None,
           open_step=open_step,
           nest_level=nest_level))
-      if nest_level:
-        open_step.stream.set_nest_level(nest_level)
 
       step_result = open_step.run()
       self._step_stack[-1] = (
           self._step_stack[-1]._replace(step_result=step_result))
 
       if step_result.retcode in ok_ret:
         step_result.presentation.status = 'SUCCESS'
         return step_result
       else:
         if not infra_step:
@@ skipping 29 matching lines @@
 
     with self._step_runner.run_context():
       try:
         try:
           recipe_result = recipe_script.run(api, api._engine.properties)
           result = {
             "recipe_result": recipe_result,
             "status_code": 0
           }
         finally:
-          self._close_to_level(0)
+          self._close_through_level(0)
       except recipe_api.StepFailure as f:
         result = {
           # Include "recipe_result" so it doesn't get marked as infra failure.
           "recipe_result": None,
           "reason": f.reason,
           "status_code": f.retcode or 1
         }
       except types.StepDataAttributeError as ex:
         result = {
           "reason": "Invalid Step Data Access: %r" % ex,
@@ skipping 59 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