Make recipes.py run give better messages.

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 46 matching lines @@
     the current history of what steps have run, what they returned, and any
     json data they emitted. Additionally, the OrderedDict has the following
     convenience functions defined:
       * last_step   - Returns the last step that ran or None
       * nth_step(n) - Returns the N'th step that ran or None
 
 'failed' is a boolean representing if the build is in a 'failed' state.
 """
 
 import collections
+import json
 import os
 import sys
 import traceback
 
 from . import env
 
 from . import loader
 from . import recipe_api
 from . import recipe_test_api
 from . import step_runner as step_runner_module
@@ skipping 99 matching lines @@
     'USER',
     'USERNAME',
 ])
 
 
 # Return value of run_steps and RecipeEngine.run.  Just a container for the
 # literal return value of the recipe.
 RecipeResult = collections.namedtuple('RecipeResult', 'result')
 
 
-def run_steps(properties, stream_engine, step_runner, universe):
+def run_steps(properties, stream_engine, step_runner, universe_view):
   """Runs a recipe (given by the 'recipe' property).
 
   Args:
     properties: a dictionary of properties to pass to the recipe.  The
       'recipe' property defines which recipe to actually run.
     stream_engine: the StreamEngine to use to create individual step streams.
     step_runner: The StepRunner to use to 'actually run' the steps.
-    universe: The RecipeUniverse to use to load the recipes & modules.
+    universe_view: The RecipeUniverse to use to load the recipes & modules.
 
   Returns: RecipeResult
   """
   # NOTE(iannucci): 'root' was a terribly bad idea and has been replaced by
   # 'patch_project'. 'root' had Rietveld knowing about the implementation of
   # the builders. 'patch_project' lets the builder (recipe) decide its own
   # destiny.
   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:
-    engine = RecipeEngine(step_runner, properties, universe)
+    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()
     if 'use_mirror' in properties:
       del properties_to_print['use_mirror']
 
+    root_package = universe_view.universe.package_deps.root_package
     run_recipe_help_lines = [
-        'To repro this locally, run the following line from a build checkout:',
+        'To repro this locally, run the following line from the root of a %r'
+          ' checkout:' % (root_package.name),
         '',
-        './scripts/tools/run_recipe.py %s --properties-file - <<EOF' % recipe,
-        repr(properties_to_print),
+        '%s run --properties-file - %s <<EOF' % (
+            os.path.join( '.', root_package.relative_recipes_dir, 'recipes.py'),
+            recipe),
+        '%s' % json.dumps(properties_to_print),
         'EOF',
         '',
         'To run on Windows, you can put the JSON in a file and redirect the',
         'contents of the file into run_recipe.py, with the < operator.',
     ]
 
     with s.new_log_stream('run_recipe') as l:
       for line in run_recipe_help_lines:
         l.write_line(line)
 
     _isolate_environment()
 
     # Find and load the recipe to run.
     try:
-      recipe_script = universe.load_recipe(recipe)
+      recipe_script = universe_view.load_recipe(recipe)
       s.write_line('Running recipe with %s' % (properties,))
 
       api = loader.create_recipe_api(recipe_script.LOADED_DEPS,
                                      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)
@@ skipping 240 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