Formally define step config, pass to stream.

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 192 matching lines @@
   properties.pop('root', None)
 
   # TODO(iannucci): A much better way to do this would be to dynamically
   #   detect if the mirrors are actually available during the execution of the
   #   recipe.
   if ('use_mirror' not in properties and (
     'TESTING_MASTERNAME' in os.environ or
     'TESTING_SLAVENAME' in os.environ)):
     properties['use_mirror'] = False
 
-  with stream_engine.new_step_stream('setup_build') as s:
+  with stream_engine.make_step_stream('setup_build') as s:
     engine = RecipeEngine(step_runner, properties, universe_view)
 
     # Create all API modules and top level RunSteps function.  It doesn't launch
     # any recipe code yet; RunSteps needs to be called.
     api = None
 
     assert 'recipe' in properties
     recipe = properties['recipe']
 
     properties_to_print = properties.copy()
@@ skipping 66 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'))
+      'config', 'step_result', 'open_step'))
 
   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 31 matching lines @@
           " 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_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:
+    while self._step_stack and self._step_stack[-1].config.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):
+  def run_step(self, step_dict):
     """
     Runs a step.
 
     Args:
-      step: The step to run.
+      step_dict (dict): A step dictionary to run.
 
     Returns:
       A StepData object containing the result of running the step.
     """
+    step_config = recipe_api._make_step_config(**step_dict)
     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.get('nest_level', 0)
-      self._close_through_level(nest_level)
+      self._close_through_level(step_config.nest_level)
 
-      open_step = self._step_runner.open_step(step)
+      open_step = self._step_runner.open_step(step_config)
       self._step_stack.append(self.ActiveStep(
-          step=step,
+          config=step_config,
           step_result=None,
-          open_step=open_step,
-          nest_level=nest_level))
+          open_step=open_step))
 
       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:
+      if step_result.retcode in step_config.ok_ret:
         step_result.presentation.status = 'SUCCESS'
         return step_result
       else:
-        if not infra_step:
+        if not step_config.infra_step:
           state = 'FAILURE'
           exc = recipe_api.StepFailure
         else:
           state = 'EXCEPTION'
           exc = recipe_api.InfraFailure
 
         step_result.presentation.status = state
 
         self._step_stack[-1].open_step.stream.write_line(
             'step returned non-zero exit code: %d' % step_result.retcode)
 
-        raise exc(step['name'], step_result)
+        raise exc(step_config.name, step_result)
 
   def run(self, recipe_script, api):
     """Run a recipe represented by a recipe_script object.
 
     This function blocks until recipe finishes.
     It mainly executes the recipe, and has some exception handling logic, and
     adds the step history to the result.
 
     Args:
       recipe_script: The recipe to run, as represented by a RecipeScript object.
@@ skipping 41 matching lines @@
           "reason": "Uncaught Exception: %r" % ex,
           "traceback": traceback.format_exc().splitlines(),
           "status_code": -1
         }
 
         raise
 
     result['name'] = '$result'
     return RecipeResult(result)
 
-  def create_step(self, step):  # pylint: disable=R0201
-    """Called by step module to instantiate a new step.
-
-    Args:
-      step: ConfigGroup object with information about the step, see
-        recipe_modules/step/config.py.
-
-    Returns:
-      Opaque engine specific object that is understood by 'run_steps' method.
-    """
-    return step.as_jsonish()
-
   def depend_on(self, recipe, properties, distributor=None):
     return self.depend_on_multi(
         ((recipe, properties),), distributor=distributor)[0]
 
   def depend_on_multi(self, dependencies, distributor=None):
     results = []
     for recipe, properties in dependencies:
       recipe_script = self._universe_view.load_recipe(recipe)
 
       return_schema = getattr(recipe_script, 'RETURN_SCHEMA', None)
@@ skipping 14 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