Made annotated_run look up recipe from builders.pyl masters.

scripts/slave/annotated_run.py

 #!/usr/bin/env python
 # Copyright (c) 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license 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
@@ skipping 298 matching lines @@
 
   ret = run_steps(stream, opts.build_properties, opts.factory_properties)
   return ret.status_code
 
 
 # Return value of run_steps and RecipeEngine.run.
 RecipeExecutionResult = collections.namedtuple(
     'RecipeExecutionResult', 'status_code steps_ran')
 
 
+def get_recipe_properties(factory_properties, build_properties):
+  """Constructs the recipe's properties from buildbot's properties.
+
+  This merges factory_properties and build_properties.  Furthermore, it
+  tries to reconstruct the 'recipe' property from builders.pyl if it isn't
+  already there, and in that case merges in properties form builders.pyl.
+  """
+  properties = factory_properties.copy()
+  properties.update(build_properties)
+
+  # Try to reconstruct the recipe from builders.pyl if not given.
+  if 'recipe' not in properties:
+    mastername = properties['mastername']
+    buildername = properties['buildername']
+
+    master_path = chromium_utils.MasterPath(mastername)
+    builders_file = os.path.join(master_path, 'builders.pyl')
+    if os.path.isfile(builders_file):
+      builders = chromium_utils.ReadBuildersFile(builders_file)
+      assert buildername in builders['builders'], (
+        'buildername %s is not listed in %s' % (buildername, builders_file))
+      builder = builders['builders'][buildername]
+
+      # Update properties with builders.pyl data.
+      properties['recipe'] = builder['recipe']
+      properties.update(builder['properties'])
+    else:
+      raise LookupError('Cannot find recipe for %s on %s' %
+                        (build_properties['buildername'],
+                        build_properties['mastername']))
+  return properties
+
+
 def run_steps(stream, build_properties, factory_properties,
               test_data=recipe_test_api.DisabledTestData()):
   """Returns a tuple of (status_code, steps_ran).
 
   Only one of these values will be set at a time. This is mainly to support the
   testing interface used by unittests/recipes_test.py.
   """
   stream.honor_zero_return_code()
 
   # TODO(iannucci): Stop this when blamelist becomes sane data.
   if ('blamelist_real' in build_properties and
       'blamelist' in build_properties):
     build_properties['blamelist'] = build_properties['blamelist_real']
     del build_properties['blamelist_real']
 
   # 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.
   build_properties.pop('root', None)
 
-  properties = factory_properties.copy()
-  properties.update(build_properties)
+  properties = get_recipe_properties(
+      factory_properties=factory_properties,
+      build_properties=build_properties)
 
   # 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
 
   # It's an integration point with a new recipe engine that can run steps
   # in parallel (that is not implemented yet). Use new engine only if explicitly
   # asked by setting 'engine' property to 'ParallelRecipeEngine'.
   engine = RecipeEngine.create(stream, properties, test_data)
 
   # Create all API modules and an instance of top level GenSteps generator.
   # It doesn't launch any recipe code yet (generator needs to be iterated upon
   # to start executing code).
   api = None
   with stream.step('setup_build') as s:
-    assert 'recipe' in factory_properties
-    recipe = factory_properties['recipe']
+    assert 'recipe' in properties # Should be ensured by get_recipe_properties.
+    recipe = properties['recipe']
 
     properties_to_print = properties.copy()
     if 'use_mirror' in properties:
       del properties_to_print['use_mirror']
 
     run_recipe_help_lines = [
         'To repro this locally, run the following line from a build checkout:',
         '',
         './scripts/tools/run_recipe.py %s --properties-file - <<EOF' % recipe,
         repr(properties_to_print),
@@ skipping 290 matching lines @@
 
 def shell_main(argv):
   if update_scripts():
     return subprocess.call([sys.executable] + argv)
   else:
     return main(argv)
 
 
 if __name__ == '__main__':
   sys.exit(shell_main(sys.argv))