build: roll infra_paths changes

scripts/slave/recipes/skia/swarm_trigger.py

 # Copyright 2016 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.
 
 
 # Recipe module for Skia Swarming trigger.
 
 
 import json
 
 
 DEPS = [
   'depot_tools/gclient',
   'depot_tools/git',
+  'depot_tools/infra_paths',
   'depot_tools/tryserver',
   'file',
   'gsutil',
   'recipe_engine/path',
   'recipe_engine/properties',
   'recipe_engine/python',
   'recipe_engine/raw_io',
   'recipe_engine/time',
   'skia',
   'skia_swarming',
@@ skipping 86 matching lines @@
   else:
     dimensions['gpu'] = 'none'
   return dimensions
 
 
 def isolate_recipes(api):
   """Isolate the recipes."""
   # This directory tends to be missing for some reason.
   api.file.makedirs(
       'third_party_infra',
-      api.path['build'].join('third_party', 'infra'),
+      api.infra_paths['build'].join('third_party', 'infra'),
       infra_step=True)
-  skia_recipes_dir = api.path['build'].join(
+  skia_recipes_dir = api.infra_paths['build'].join(
       'scripts', 'slave', 'recipes', 'skia')
   api.skia_swarming.create_isolated_gen_json(
       skia_recipes_dir.join('swarm_recipe.isolate'),
       skia_recipes_dir,
       'linux',
       'isolate_recipes',
       {})
   return api.skia_swarming.batcharchive(['isolate_recipes'])[0][1]
 
 
@@ skipping 21 matching lines @@
     properties['patchset'] = str(api.properties['patchset'])
     properties['rietveld'] = api.properties['rietveld']
 
   extra_args = [
       '--workdir', '../../..',
       'skia/swarm_%s' % task_name,
   ]
   for k, v in properties.iteritems():
     extra_args.append('%s=%s' % (k, v))
 
-  isolate_base_dir = api.path['slave_build']
+  isolate_base_dir = api.infra_paths['slave_build']
   dimensions = swarm_dimensions(builder_spec)
   isolate_blacklist = ['.git', 'out', '*.pyc']
   isolate_vars = {
-    'BUILD': api.path['build'],
-    'WORKDIR': api.path['slave_build'],
+    'BUILD': api.infra_paths['build'],
+    'WORKDIR': api.infra_paths['slave_build'],
   }
 
   isolate_file = '%s_skia.isolate' % task_name
   if 'Coverage' == builder_cfg['configuration']:
     isolate_file = 'coverage_skia.isolate'
   return api.skia_swarming.isolate_and_trigger_task(
       infrabots_dir.join(isolate_file),
       isolate_base_dir,
       '%s_skia' % task_name,
       isolate_vars,
@@ skipping 28 matching lines @@
   return got_revision
 
 
 def compile_steps_swarm(api, builder_spec, got_revision, infrabots_dir,
                         extra_isolate_hashes):
   builder_name = derive_compile_bot_name(api.properties['buildername'],
                                          builder_spec)
   compile_builder_spec = builder_spec
   if builder_name != api.properties['buildername']:
     compile_builder_spec = api.skia.get_builder_spec(
-        api.path['slave_build'].join('skia'), builder_name)
+        api.infra_paths['slave_build'].join('skia'), builder_name)
   # Windows bots require a toolchain.
   extra_hashes = extra_isolate_hashes[:]
   if 'Win' in builder_name:
     test_data = '''{
   "2013": "705384d88f80da637eb367e5acc6f315c0e1db2f",
   "2015": "38380d77eec9164e5818ae45e2915a6f22d60e85"
 }'''
     hash_file = infrabots_dir.join('win_toolchain_hash.json')
     j = api.skia._readfile(hash_file,
                            name='Read win_toolchain_hash.json',
@@ skipping 55 matching lines @@
 
 def perf_steps_collect(api, task, upload_perf_results, got_revision,
                        is_trybot):
   """Wait for perf steps to finish and upload results."""
   # Wait for nanobench to finish, download the results.
   api.file.rmtree('results_dir', task.task_output_dir, infra_step=True)
   api.skia_swarming.collect_swarming_task(task)
 
   # Upload the results.
   if upload_perf_results:
-    perf_data_dir = api.path['slave_build'].join(
+    perf_data_dir = api.infra_paths['slave_build'].join(
         'perfdata', api.properties['buildername'], 'data')
     git_timestamp = api.git.get_timestamp(test_data='1408633190',
                                           infra_step=True)
     api.file.rmtree('perf_dir', perf_data_dir, infra_step=True)
     api.file.makedirs('perf_dir', perf_data_dir, infra_step=True)
     src_results_file = task.task_output_dir.join(
         '0', 'perfdata', api.properties['buildername'], 'data',
         'nanobench_%s.json' % got_revision)
     dst_results_file = perf_data_dir.join(
         'nanobench_%s_%s.json' % (got_revision, git_timestamp))
     api.file.copy('perf_results', src_results_file, dst_results_file,
                   infra_step=True)
 
-    gsutil_path = api.path['depot_tools'].join(
+    gsutil_path = api.infra_paths['depot_tools'].join(
         'third_party', 'gsutil', 'gsutil')
     upload_args = [api.properties['buildername'], api.properties['buildnumber'],
                    perf_data_dir, got_revision, gsutil_path]
     if is_trybot:
       upload_args.append(api.properties['issue'])
     api.python(
              'Upload perf results',
              script=api.skia.resource('upload_bench_results.py'),
              args=upload_args,
              cwd=api.path['checkout'],
@@ skipping 21 matching lines @@
 
 def test_steps_collect(api, task, upload_dm_results, got_revision, is_trybot,
                        builder_cfg):
   """Collect the test results from Swarming."""
   # Wait for tests to finish, download the results.
   api.file.rmtree('results_dir', task.task_output_dir, infra_step=True)
   api.skia_swarming.collect_swarming_task(task)
 
   # Upload the results.
   if upload_dm_results:
-    dm_dir = api.path['slave_build'].join('dm')
+    dm_dir = api.infra_paths['slave_build'].join('dm')
     dm_src = task.task_output_dir.join('0', 'dm')
     api.file.rmtree('dm_dir', dm_dir, infra_step=True)
     api.file.copytree('dm_dir', dm_src, dm_dir, infra_step=True)
 
     # Upload them to Google Storage.
     api.python(
         'Upload DM Results',
         script=api.skia.resource('upload_dm_results.py'),
         args=[
           dm_dir,
           got_revision,
           api.properties['buildername'],
           api.properties['buildnumber'],
           api.properties['issue'] if is_trybot else '',
-          api.path['slave_build'].join('skia', 'common', 'py', 'utils'),
+          api.infra_paths['slave_build'].join('skia', 'common', 'py', 'utils'),
         ],
         cwd=api.path['checkout'],
         env=api.skia.gsutil_env('chromium-skia-gm.boto'),
         infra_step=True)
 
   if builder_cfg['configuration']  == 'Coverage':
     upload_coverage_results(api, task, got_revision, is_trybot)
 
 
 def upload_coverage_results(api, task, got_revision, is_trybot):
@@ skipping 26 matching lines @@
   # into the nanobench_${git_hash}_${timestamp}.json file
   # upload_bench_results.py expects.
   src_nano_file = results_dir.join('nanobench_%s.json' % got_revision)
   dst_nano_file = results_dir.join(
       'nanobench_%s_%s.json' % (got_revision, git_timestamp))
   api.file.copy('nanobench JSON', src_nano_file, dst_nano_file,
                 infra_step=True)
   api.file.remove('old nanobench JSON', src_nano_file)
 
   # Upload nanobench JSON data.
-  gsutil_path = api.path['depot_tools'].join(
+  gsutil_path = api.infra_paths['depot_tools'].join(
       'third_party', 'gsutil', 'gsutil')
   upload_args = [api.properties['buildername'], api.properties['buildnumber'],
                  results_dir, got_revision, gsutil_path]
   if is_trybot:
     upload_args.append(api.properties['issue'])
   api.python(
       'upload nanobench coverage results',
       script=api.skia.resource('upload_bench_results.py'),
       args=upload_args,
       cwd=api.path['checkout'],
@@ skipping 43 matching lines @@
   do_test_steps = builder_spec['do_test_steps']
   do_perf_steps = builder_spec['do_perf_steps']
 
   if not (do_test_steps or do_perf_steps):
     return
 
   extra_hashes = [recipes_hash]
   if compile_hash:
     extra_hashes.append(compile_hash)
 
-  api.skia.download_skps(api.path['slave_build'].join('tmp'),
-                         api.path['slave_build'].join('skps'),
+  api.skia.download_skps(api.infra_paths['slave_build'].join('tmp'),
+                         api.infra_paths['slave_build'].join('skps'),
                          False)
-  api.skia.download_images(api.path['slave_build'].join('tmp'),
-                           api.path['slave_build'].join('images'),
+  api.skia.download_images(api.infra_paths['slave_build'].join('tmp'),
+                           api.infra_paths['slave_build'].join('images'),
                            False)
 
   test_task = None
   perf_task = None
   if do_test_steps:
     test_task = test_steps_trigger(api, builder_spec, got_revision,
                                    infrabots_dir, extra_hashes)
   if do_perf_steps:
     perf_task = perf_steps_trigger(api, builder_spec, got_revision,
                                    infrabots_dir, extra_hashes)
   is_trybot = builder_cfg['is_trybot']
   if test_task:
     test_steps_collect(api, test_task, builder_spec['upload_dm_results'],
                        got_revision, is_trybot, builder_cfg)
   if perf_task:
     perf_steps_collect(api, perf_task, builder_spec['upload_perf_results'],
                        got_revision, is_trybot)
 
 
 def test_for_bot(api, builder, mastername, slavename, testname=None):
   """Generate a test for the given bot."""
   testname = testname or builder
   test = (
     api.test(testname) +
     api.properties(buildername=builder,
                    mastername=mastername,
                    slavename=slavename,
                    buildnumber=5,
                    revision='abc123') +
-    api.path.exists(
-        api.path['slave_build'].join('skia'),
-        api.path['slave_build'].join('tmp', 'uninteresting_hashes.txt')
+    api.infra_paths.exists(
+        api.infra_paths['slave_build'].join('skia'),
+        api.infra_paths['slave_build'].join('tmp', 'uninteresting_hashes.txt')
     )
   )
   if 'Trybot' in builder:
     test += api.properties(issue=500,
                            patchset=1,
                            rietveld='https://codereview.chromium.org')
   if 'Coverage' not in builder:
     test += api.step_data(
         'upload new .isolated file for compile_skia',
         stdout=api.raw_io.output('def456 XYZ.isolated'))
@@ skipping 14 matching lines @@
   for mastername, slaves in TEST_BUILDERS.iteritems():
     for slavename, builders_by_slave in slaves.iteritems():
       for builder in builders_by_slave:
         yield test_for_bot(api, builder, mastername, slavename)
 
   builder = 'Test-Ubuntu-GCC-GCE-CPU-AVX2-x86_64-Debug-Swarming'
   master = 'client.skia'
   slave = 'skiabot-linux-test-000'
   test = test_for_bot(api, builder, master, slave, 'No_downloaded_SKP_VERSION')
   test += api.step_data('Get downloaded SKP_VERSION', retcode=1)
-  test += api.path.exists(
-      api.path['slave_build'].join('skia'),
-      api.path['slave_build'].join('tmp', 'uninteresting_hashes.txt')
+  test += api.infra_paths.exists(
+      api.infra_paths['slave_build'].join('skia'),
+      api.infra_paths['slave_build'].join('tmp', 'uninteresting_hashes.txt')
   )
   yield test