sandwich: Implement SandwichTaskBuilder

tools/android/loading/sandwich.py

 #! /usr/bin/env python
 # 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.
 
 """Instructs Chrome to load series of web pages and reports results.
 
 When running Chrome is sandwiched between preprocessed disk caches and
 WepPageReplay serving all connections.
 
@@ skipping 17 matching lines @@
 from pylib import constants
 import devil_chromium
 
 import chrome_cache
 import common_util
 import emulation
 import options
 import sandwich_metrics
 import sandwich_misc
 from sandwich_runner import SandwichRunner
+import sandwich_task_builder
+import task_manager
 from trace_test.webserver_test import WebServer
 
 
 # Use options layer to access constants.
 OPTIONS = options.OPTIONS
 
 
 def _ArgumentParser():
   """Build a command line argument's parser."""
   # Command parser when dealing with jobs.
   common_job_parser = argparse.ArgumentParser(add_help=False)
   common_job_parser.add_argument('--job', required=True,
                                  help='JSON file with job description.')
 
+  task_parser = task_manager.CommandLineParser()
+
   # Plumbing parser to configure OPTIONS.
   plumbing_parser = OPTIONS.GetParentParser('plumbing options')
 
   # Main parser
   parser = argparse.ArgumentParser(parents=[plumbing_parser])
   subparsers = parser.add_subparsers(dest='subcommand', help='subcommand line')
 
   # Record WPR subcommand.
   record_wpr = subparsers.add_parser('record-wpr', parents=[common_job_parser],
                                      help='Record WPR from sandwich job.')
@@ skipping 97 matching lines @@
       help='Record a test trace using the trace_test.webserver_test.')
   record_trace_parser.add_argument('--source-dir', type=str, required=True,
                                    help='Base path where the files are opened'
                                         'by the web server.')
   record_trace_parser.add_argument('--page', type=str, required=True,
                                    help='Source page in source-dir to navigate '
                                         'to.')
   record_trace_parser.add_argument('-o', '--output', type=str, required=True,
                                    help='Output path of the generated trace.')
 
+  # Run all subcommand.
+  run_all = subparsers.add_parser('run-all',
+                       parents=[common_job_parser, task_parser],
+                       help='Run all steps using the task manager '
+                            'infrastructure.')
+  run_all.add_argument('-g', '--gen-full', action='store_true',
+                       help='Generate the full graph with all possible'
+                            'benchmarks.')
+  run_all.add_argument('--wpr-archive', default=None, type=str,
+                       dest='wpr_archive_path',
+                       help='WebPageReplay archive to use, instead of '
+                            'generating one.')
+  run_all.add_argument('--url-repeat', default=1, type=int,
+                       help='How many times to repeat the urls.')
+
   return parser
 
 
 def _RecordWprMain(args):
   sandwich_runner = SandwichRunner()
   sandwich_runner.LoadJob(args.job)
   sandwich_runner.PullConfigFromArgs(args)
   sandwich_runner.wpr_record = True
   sandwich_runner.PrintConfig()
   if not os.path.isdir(os.path.dirname(args.wpr_archive_path)):
@@ skipping 54 matching lines @@
     sandwich_runner = SandwichRunner()
     # Reuse the WPR's forwarding to access the webpage from Android.
     sandwich_runner.wpr_record = True
     sandwich_runner.wpr_archive_path = os.path.join(out_path, 'wpr')
     sandwich_runner.trace_output_directory = os.path.join(out_path, 'run')
     with WebServer.Context(
         source_dir=args.source_dir, communication_dir=out_path) as server:
       address = server.Address()
       sandwich_runner.urls = ['http://%s/%s' % (address, args.page)]
       sandwich_runner.Run()
-    shutil.copy(os.path.join(out_path, 'run', '0', 'trace.json'), args.output)
+    trace_path = os.path.join(
+        out_path, 'run', '0', sandwich_runner.TRACE_FILENAME)
+    shutil.copy(trace_path, args.output)
   return 0
 
 
+def _RunAllMain(args):
+  builder = sandwich_task_builder.SandwichTaskBuilder(
+      output_directory=args.output,
+      job_path=args.job,
+      url_repeat=args.url_repeat)
+  if args.wpr_archive_path:
+    builder.OverridePathToWprArchive(args.wpr_archive_path)
+  else:
+    builder.PopulateWprRecordingTask()
+  builder.PopulateCommonPipelines()
+
+  runner_transformer_name = 'no-network-emulation'
+  runner_transformer = lambda arg: None
+  builder.PopulateLoadBenchmark(sandwich_misc.EMPTY_CACHE_DISCOVERER,
+                                runner_transformer_name, runner_transformer)
+  builder.PopulateLoadBenchmark(sandwich_misc.FULL_CACHE_DISCOVERER,
+                                runner_transformer_name, runner_transformer)
+
+  if args.gen_full:
+    for subresource_discoverer in sandwich_misc.SUBRESOURCE_DISCOVERERS:
+      if subresource_discoverer == sandwich_misc.FULL_CACHE_DISCOVERER:
+        continue
+      for network_condition in ['Regular4G', 'Regular3G', 'Regular2G']:
+        runner_transformer_name = network_condition.lower()
+        runner_transformer = sandwich_task_builder.NetworkSimulationTransformer(
+            network_condition)
+        builder.PopulateLoadBenchmark(
+            subresource_discoverer, runner_transformer_name, runner_transformer)
+
+  return task_manager.ExecuteWithCommandLine(
+      args, builder.tasks.values(), builder.default_final_tasks)
+
+
 def main(command_line_args):
   logging.basicConfig(level=logging.INFO)
   devil_chromium.Initialize()
 
   args = _ArgumentParser().parse_args(command_line_args)
   OPTIONS.SetParsedArgs(args)
 
   if args.subcommand == 'record-wpr':
     return _RecordWprMain(args)
   if args.subcommand == 'patch-wpr':
     sandwich_misc.PatchWpr(args.wpr_archive_path)
     return 0
   if args.subcommand == 'create-cache':
     return _CreateCacheMain(args)
   if args.subcommand == 'run':
     return _RunJobMain(args)
   if args.subcommand == 'extract-metrics':
     return _ExtractMetricsMain(args)
   if args.subcommand == 'filter-cache':
     return _FilterCacheMain(args)
   if args.subcommand == 'record-test-trace':
     return _RecordWebServerTestTrace(args)
+  if args.subcommand == 'run-all':
+    return _RunAllMain(args)
   assert False
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))