Add concept of bot config and test spec database (BotConfigAndTestDB).

scripts/slave/recipe_modules/perf_try/api.py

 # Copyright 2015 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.
 
 """API for the perf try job recipe module.
 
 This API is meant to enable the perf try job recipe on any chromium-supported
 platform for any test that can be run via buildbot, perf or otherwise.
 """
 
@@ skipping 23 matching lines @@
 
 %(results)s
 """
 
 
 class PerfTryJobApi(recipe_api.RecipeApi):
 
   def __init__(self, *args, **kwargs):
     super(PerfTryJobApi, self).__init__(*args, **kwargs)
 
-  def start_perf_try_job(self, affected_files, bot_update_step, master_dict):
+  def start_perf_try_job(self, affected_files, bot_update_step, bot_db):
     """Entry point pert tryjob or CQ tryjob."""
     perf_config = self._get_perf_config(affected_files)
     if perf_config:
-      self._run_perf_job(perf_config, bot_update_step, master_dict)
+      self._run_perf_job(perf_config, bot_update_step, bot_db)
     elif (not perf_config and
           self.m.properties.get('requester') == 'commit-bot@chromium.org'):
-      self.run_cq_job(bot_update_step, master_dict, affected_files)
+      self.run_cq_job(bot_update_step, bot_db, affected_files)
     else:
       self.m.halt('Could not load config file. Double check your changes to '
                   'config files for syntax errors.')
 
-  def _run_perf_job(self, perf_cfg, bot_update_step, master_dict):
+  def _run_perf_job(self, perf_cfg, bot_update_step, bot_db):
     """Runs performance try job with and without patch."""
     r = self._resolve_revisions_from_config(perf_cfg)
     test_cfg = self.m.bisect_tester.load_config_from_dict(perf_cfg)
 
     # TODO(prasadv): This is tempory hack to prepend 'src' to test command,
     # until dashboard and trybot scripts are changed.
     _prepend_src_to_path_in_command(test_cfg)
     # Run with patch.
     results_with_patch = self._build_and_run_tests(
-        test_cfg, bot_update_step, master_dict, r[0],
+        test_cfg, bot_update_step, bot_db, r[0],
         name='With Patch' if r[0] is None else r[0],
         reset_on_first_run=True,
         upload_on_last_run=True,
         results_label='Patch' if r[0] is None else r[0],
         allow_flakes=False)
 
     if not any(r):
       # Revert changes.
       self.m.chromium_tests.deapply_patch(bot_update_step)
 
     # Run without patch.
     results_without_patch = self._build_and_run_tests(
-        test_cfg, bot_update_step, master_dict, r[1],
+        test_cfg, bot_update_step, bot_db, r[1],
         name='Without Patch' if r[1] is None else r[1],
         reset_on_first_run=False,
         upload_on_last_run=True,
         results_label='TOT' if r[1] is None else r[1],
         allow_flakes=False)
 
     labels = {
         'profiler_link1': ('%s - Profiler Data' % 'With Patch'
                            if r[0] is None else r[0]),
         'profiler_link2': ('%s - Profiler Data' % 'Without Patch'
                            if r[1] is None else r[1])
     }
     self._compare_and_present_results(
         test_cfg, results_without_patch, results_with_patch, labels)
 
-  def run_cq_job(self, update_step, master_dict, files_in_patch):
+  def run_cq_job(self, update_step, bot_db, files_in_patch):
     """Runs benchmarks affected by a CL on CQ."""
     buildername = self.m.properties['buildername']
     affected_benchmarks = self._get_affected_benchmarks(files_in_patch)
     if not affected_benchmarks:
       step_result = self.m.step('Results', [])
       step_result.presentation.step_text = (
           'There are no modifications to Telemetry benchmarks,'
           ' aborting the try job.')
       return
     self._compile('With Patch', self.m.properties['mastername'],
-                  self.m.properties['buildername'], update_step, master_dict)
+                  self.m.properties['buildername'], update_step, bot_db)
 
     if self.m.chromium.c.TARGET_PLATFORM == 'android':
       self.m.chromium_android.adb_install_apk('ChromePublic.apk')
 
     tests = self.m.chromium.list_perf_tests(_get_browser(buildername), 1)
 
     tests = dict((k, v) for k, v in tests.json.output['steps'].iteritems()
                  if _is_benchmark_match(k, affected_benchmarks))
 
     if not tests:
@@ skipping 21 matching lines @@
     """Gets list of modified benchmark files under tools/perf/benchmarks."""
     modified_benchmarks = []
     for affected_file in files_in_patch:
       if (affected_file.startswith(PERF_BENCHMARKS_PATH) or
           affected_file.startswith(PERF_MEASUREMENTS_PATH)):
         benchmark = self.m.path.basename(
             self.m.path.splitext(affected_file)[0])
         modified_benchmarks.append(benchmark)
     return modified_benchmarks
 
-  def _checkout_revision(self, update_step, master_dict, revision=None):
+  def _checkout_revision(self, update_step, bot_db, revision=None):
     """Checkouts specific revisions and updates bot_update step."""
     if revision:
       if self.m.platform.is_win:  # pragma: no cover
         self.m.chromium.taskkill()
       self.m.gclient.c.revisions['src'] = str(revision)
       update_step = self.m.bot_update.ensure_checkout(
           suffix=str(revision), force=True, patch=False,
           update_presentation=False)
       assert update_step.json.output['did_run']
       self.m.chromium.runhooks(name='runhooks on %s' % str(revision))
 
     return update_step
 
-  def _compile(self, name, mastername, buildername, update_step,
-               master_dict, test_spec=None):
+  def _compile(self, name, mastername, buildername, update_step, bot_db):
     """Runs compile and related steps for given builder."""
-    if test_spec is None:
-      test_spec = {}
     compile_targets, _ = self.m.chromium_tests.get_compile_targets_and_tests(
         mastername,
         buildername,
-        master_dict,
-        test_spec,
+        bot_db,
         override_bot_type='builder_tester',
         override_tests=[])
     if self.m.chromium.c.TARGET_PLATFORM == 'android':
       self.m.chromium_android.clean_local_files()
       compile_targets = None
     else:
       # Removes any chrome temporary files or build.dead directories.
       self.m.chromium.cleanup_temp()
 
     if 'With Patch' in name:
@@ skipping 16 matching lines @@
       overall_success = all(v == 0 for v in retcodes)
     if not overall_success:  # pragma: no cover
       raise self.m.step.StepFailure(
           'Patched version failed to run performance test.')
     return {
         'results': all_values,
         'ret_code': overall_success,
         'output': ''.join(overall_output)
     }
 
-  def _build_and_run_tests(self, cfg, update_step, master_dict, revision,
+  def _build_and_run_tests(self, cfg, update_step, bot_db, revision,
                            **kwargs):
     """Compiles binaries and runs tests for a given a revision."""
-    update_step = self._checkout_revision(update_step, master_dict, revision)
+    update_step = self._checkout_revision(update_step, bot_db, revision)
     self._compile(kwargs['name'], self.m.properties['mastername'],
-                  self.m.properties['buildername'], update_step, master_dict)
+                  self.m.properties['buildername'], update_step, bot_db)
 
     if self.m.chromium.c.TARGET_PLATFORM == 'android':
       self.m.chromium_android.adb_install_apk('ChromePublic.apk')
 
     return self._run_test(cfg, **kwargs)
 
   def _load_config_file(self, name, src_path, **kwargs):
     """Attempts to load the specified config file and grab config dict."""
     step_result = self.m.python(
         name,
@@ skipping 218 matching lines @@
 
 def _prepend_src_to_path_in_command(test_cfg):
   command_to_run = []
   for v in test_cfg.get('command').split():
     if v in ['./tools/perf/run_benchmark',
              'tools/perf/run_benchmark',
              'tools\\perf\\run_benchmark']:
       v = 'src/tools/perf/run_benchmark'
     command_to_run.append(v)
   test_cfg.update({'command': ' '.join(command_to_run)})