sandwich: Makes pull_sandwich_metrics.py a sub-command.

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.
 
 TODO(pasko): implement cache preparation and WPR.
 """
 
 import argparse
+import csv
 import json
 import logging
 import os
 import shutil
 import sys
 import tempfile
 import time
 
 _SRC_DIR = os.path.abspath(os.path.join(
     os.path.dirname(__file__), '..', '..', '..'))
@@ skipping 251 matching lines @@
       self._local_cache_directory_path = None
     if self.cache_operation == 'save':
       self._PullCacheFromDevice()
     if self.trace_output_directory:
       self._SaveRunInfos(ran_urls)
 
 
 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.')
+
+  # Main parser
   parser = argparse.ArgumentParser()
-  parser.add_argument('--job', required=True,
-                      help='JSON file with job description.')
   subparsers = parser.add_subparsers(dest='subcommand', help='subcommand line')
 
   # Record WPR subcommand.
-  record_wpr = subparsers.add_parser('record-wpr',
+  record_wpr = subparsers.add_parser('record-wpr', parents=[common_job_parser],
                                      help='Record WPR from sandwich job.')
   record_wpr.add_argument('--wpr-archive', required=True, type=str,
                           dest='wpr_archive_path',
                           help='Web page replay archive to generate.')
 
   # Patch WPR subcommand.
   patch_wpr = subparsers.add_parser('patch-wpr',
                                      help='Patch WPR response headers.')
   patch_wpr.add_argument('--wpr-archive', required=True, type=str,
                          dest='wpr_archive_path',
-                         help='Web page replay archive to generate.')
+                         help='Web page replay archive to patch.')
 
   # Create cache subcommand.
   create_cache_parser = subparsers.add_parser('create-cache',
+      parents=[common_job_parser],
       help='Create cache from sandwich job.')
   create_cache_parser.add_argument('--cache-archive', required=True, type=str,
                                    dest='cache_archive_path',
                                    help='Cache archive destination path.')
   create_cache_parser.add_argument('--wpr-archive', default=None, type=str,
                                    dest='wpr_archive_path',
                                    help='Web page replay archive to create ' +
                                        'the cache from.')
 
   # Run subcommand.
-  run_parser = subparsers.add_parser('run', help='Run sandwich benchmark.')
+  run_parser = subparsers.add_parser('run', parents=[common_job_parser],
+                                     help='Run sandwich benchmark.')
   run_parser.add_argument('--output', required=True, type=str,
                           dest='trace_output_directory',
                           help='Path of output directory to create.')
   run_parser.add_argument('--cache-archive', type=str,
                           dest='cache_archive_path',
                           help='Cache archive destination path.')
   run_parser.add_argument('--cache-op',
                           choices=['clear', 'push', 'reload'],
                           dest='cache_operation',
                           default='clear',
@@ skipping 13 matching lines @@
       choices=['browser', 'wpr'],
       help='Set which component is emulating the network condition.' +
           ' (Default to browser). Wpr network emulator requires --wpr-archive' +
           ' to be set.')
   run_parser.add_argument('--job-repeat', default=1, type=int,
                           help='How many times to run the job.')
   run_parser.add_argument('--wpr-archive', default=None, type=str,
                           dest='wpr_archive_path',
                           help='Web page replay archive to load job\'s urls ' +
                               'from.')
+
+  # Pull metrics subcommand.
+  create_cache_parser = subparsers.add_parser('pull-metrics',
+      help='Pulls metrics in CSV from a run\'s loading trace.')
+  create_cache_parser.add_argument('--traces-directory', required=True,
+                                   dest='trace_output_directory', type=str,
+                                   help='Path of loading traces directory.')
+  create_cache_parser.add_argument('--out-metrics', default=None, type=str,
+                                   dest='metrics_csv_path',
+                                   help='Path where to save the metrics\'s '+
+                                      'CSV.')
+
   return parser
 
 
 def _RecordWprMain(args):
   sandwich_runner = SandwichRunner(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)):
+    os.makedirs(os.path.dirname(args.wpr_archive_path))
   sandwich_runner.Run()
   return 0
 
 
 def _PatchWprMain(args):
   # Sets the resources cache max-age to 10 years.
   MAX_AGE = 10 * 365 * 24 * 60 * 60
   CACHE_CONTROL = 'public, max-age={}'.format(MAX_AGE)
 
   wpr_archive = wpr_backend.WprArchiveBackend(args.wpr_archive_path)
@@ skipping 18 matching lines @@
     url_entry.SetResponseHeader('cache-control', CACHE_CONTROL)
   wpr_archive.Persist()
   return 0
 
 
 def _CreateCacheMain(args):
   sandwich_runner = SandwichRunner(args.job)
   sandwich_runner.PullConfigFromArgs(args)
   sandwich_runner.cache_operation = 'save'
   sandwich_runner.PrintConfig()
+  if not os.path.isdir(os.path.dirname(args.cache_archive_path)):
+    os.makedirs(os.path.dirname(args.cache_archive_path))
   sandwich_runner.Run()
   return 0
 
 
 def _RunJobMain(args):
   sandwich_runner = SandwichRunner(args.job)
   sandwich_runner.PullConfigFromArgs(args)
   sandwich_runner.PrintConfig()
   sandwich_runner.Run()
   return 0
 
 
+def _PullMetricsMain(args):
+  trace_metrics_list = pull_sandwich_metrics.PullMetricsFromOutputDirectory(
+      args.trace_output_directory)
+  trace_metrics_list.sort(key=lambda e: e['id'])
+  with open(args.metrics_csv_path, 'w') as csv_file:

[Benoit L, 2016/02/25 16:02:13]

Any reason to choose CSV rather than JSON?

[gabadie, 2016/02/25 16:55:06]

The main motivation of using CSV here is to be able to open it directly with a
tabler and make some iteration quickly to fetch some usefull stats from it. This
way we are independent of the ipython notebook, handy for debuging purposes.

+    writer = csv.DictWriter(csv_file,
+                            fieldnames=pull_sandwich_metrics.CSV_FIELD_NAMES)
+    writer.writeheader()
+    for trace_metrics in trace_metrics_list:
+      writer.writerow(trace_metrics)
+  return 0
+
+
 def main(command_line_args):
   logging.basicConfig(level=logging.INFO)
   devil_chromium.Initialize()
 
   # Don't give the argument yet. All we are interested in for now is accessing
   # the default values of OPTIONS.
   OPTIONS.ParseArgs([])
 
   args = _ArgumentParser().parse_args(command_line_args)
 
   if args.subcommand == 'record-wpr':
     return _RecordWprMain(args)
   if args.subcommand == 'patch-wpr':
     return _PatchWprMain(args)
   if args.subcommand == 'create-cache':
     return _CreateCacheMain(args)
   if args.subcommand == 'run':
     return _RunJobMain(args)
+  if args.subcommand == 'pull-metrics':
+    return _PullMetricsMain(args)
   assert False
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))