sandwich: Implements network condition on WPR server and browser.

tools/android/loading/run_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 15 matching lines @@
 _SRC_DIR = os.path.abspath(os.path.join(
     os.path.dirname(__file__), '..', '..', '..'))
 
 sys.path.append(os.path.join(_SRC_DIR, 'third_party', 'catapult', 'devil'))
 from devil.android import device_utils
 
 sys.path.append(os.path.join(_SRC_DIR, 'build', 'android'))
 from pylib import constants
 import devil_chromium
 
+import chrome_setup
 import device_setup
 import devtools_monitor
 import options
 import page_track
 import pull_sandwich_metrics
 import trace_recorder
 import tracing
 
 
 _JOB_SEARCH_PATH = 'sandwich_jobs'
@@ skipping 11 matching lines @@
 # Name of the chrome package.
 _CHROME_PACKAGE = constants.PACKAGE_INFO['chrome'].package
 
 # An estimate of time to wait for the device to become idle after expensive
 # operations, such as opening the launcher activity.
 _TIME_TO_DEVICE_IDLE_SECONDS = 2
 
 # Cache directory's path on the device.
 _REMOTE_CACHE_DIRECTORY = '/data/data/' + _CHROME_PACKAGE + '/cache/Cache'
 
+# Websocket timeout of 1 minute to avoid websocket timeout on slow

[Benoit L, 2016/02/18 13:01:25]

As above, need a better name (and comment).

[gabadie, 2016/02/18 13:21:58]

Done.

+# network condition.
+_WEBSOCKET_TIMEOUT = 60
+
 
 def _ReadUrlsFromJobDescription(job_name):
   """Retrieves the list of URLs associated with the job name."""
   try:
     # Extra sugar: attempt to load from a relative path.
     json_file_name = os.path.join(os.path.dirname(__file__), _JOB_SEARCH_PATH,
         job_name)
     with open(json_file_name) as f:
       json_data = json.load(f)
   except IOError:
@@ skipping 173 matching lines @@
     directory_path = os.path.join(output_directories_path, dirname)
     if not os.path.isdir(directory_path):
       continue
     try:
       int(dirname)
     except ValueError:
       continue
     shutil.rmtree(directory_path)
 
 
-def main():
-  logging.basicConfig(level=logging.INFO)
-  devil_chromium.Initialize()
-  options.OPTIONS.ParseArgs([])
-
+def _ArgumentParser():
+  """Build a command line argument's parser.
+  """
   parser = argparse.ArgumentParser()
   parser.add_argument('--job', required=True,
                       help='JSON file with job description.')
   parser.add_argument('--output', required=True,
                       help='Name of output directory to create.')
   parser.add_argument('--repeat', default=1, type=int,
                       help='How many times to run the job')
   parser.add_argument('--cache-op',
                       choices=['clear', 'save', 'push', 'reload'],
                       default='clear',
                       help='Configures cache operation to do before launching '
                           +'Chrome. (Default is clear).')
   parser.add_argument('--wpr-archive', default=None, type=str,
                       help='Web page replay archive to load job\'s urls from.')
   parser.add_argument('--wpr-record', default=False, action='store_true',
                       help='Record web page replay archive.')
   parser.add_argument('--disable-wpr-script-injection', default=False,
                       action='store_true',
                       help='Disable WPR default script injection such as ' +
                           'overriding javascript\'s Math.random() and Date() ' +
                           'with deterministic implementations.')
-  args = parser.parse_args()
+  parser.add_argument('--network-condition', default=None,
+      choices=sorted(chrome_setup.NETWORK_CONDITIONS.keys()),
+      help='Set a network profile.')
+  parser.add_argument('--network-emulator', default='browser',
+      choices=['browser', 'wpr'],
+      help='Set which component is emulating the network condition.' +
+          ' (Default to browser)')
+  return parser
+
+
+def main():
+  logging.basicConfig(level=logging.INFO)
+  devil_chromium.Initialize()
+  options.OPTIONS.ParseArgs([])

[Benoit L, 2016/02/18 13:01:25]

Don't you want to pass the command line here?

[gabadie, 2016/02/18 13:21:58]

No. This is just a work around that has been added in the parent CL:
https://codereview.chromium.org/1707793002/

And I prefer to have 100% control over my command line parameter and its --help
rather than  having the lower level layers polluting my command line MAN message
with flags this script might not be ready for yet.

I personally think global variable usage like this guy must be banned...

[mattcary, 2016/02/19 15:40:17]

The problem though is that many of the other library tools assume specific
command line configuration. So you don't actually want 100% control over your
command line, as then you'd have to leak the rest of the library to configure it
correctly.

For example, you're disabling devtools port configuration here, and you probably
didn't intend that.

+
+  args = _ArgumentParser().parse_args()
 
   if not os.path.isdir(args.output):
     try:
       os.makedirs(args.output)
     except OSError:
       logging.error('Cannot create directory for results: %s' % args.output)
       raise
   else:
     _CleanPreviousTraces(args.output)
 
   run_infos = {
     'cache-op': args.cache_op,
     'job': args.job,
     'urls': []
   }
   job_urls = _ReadUrlsFromJobDescription(args.job)
   device = device_utils.DeviceUtils.HealthyDevices()[0]
   local_cache_archive_path = os.path.join(args.output, 'cache.zip')
   local_cache_directory_path = None
+  wpr_network_condition_name = None
+  browser_network_condition_name = None
+  if args.network_emulator == 'wpr':
+    wpr_network_condition_name = args.network_condition
+  elif args.network_emulator == 'browser':
+    browser_network_condition_name = args.network_condition
+  else:
+    assert False
 
   if args.cache_op == 'push':
     assert os.path.isfile(local_cache_archive_path)
     local_cache_directory_path = tempfile.mkdtemp(suffix='.cache')
     _UnzipDirectoryContent(local_cache_archive_path, local_cache_directory_path)
 
-  with device_setup.WprHost(device, args.wpr_archive, args.wpr_record,
-      args.disable_wpr_script_injection) as additional_flags:
+  with device_setup.WprHost(device, args.wpr_archive,
+      record=args.wpr_record,
+      network_condition_name=wpr_network_condition_name,
+      disable_script_injection=args.disable_wpr_script_injection
+      ) as additional_flags:
     def _RunNavigation(url, clear_cache, trace_id):
       with device_setup.DeviceConnection(
           device=device,
           additional_flags=additional_flags) as connection:
+        additional_metadata = {}
+        if browser_network_condition_name:
+          additional_metadata = chrome_setup.SetUpEmulationAndReturnMetadata(
+              connection=connection,
+              emulated_device_name=None,
+              emulated_network_name=browser_network_condition_name)
         loading_trace = trace_recorder.MonitorUrl(
             connection, url,
             clear_cache=clear_cache,
-            categories=pull_sandwich_metrics.CATEGORIES)
+            categories=pull_sandwich_metrics.CATEGORIES,
+            timeout=_WEBSOCKET_TIMEOUT)
+        loading_trace.metadata.update(additional_metadata)
         if trace_id != None:
           loading_trace_path = os.path.join(
               args.output, str(trace_id), 'trace.json')
           os.makedirs(os.path.dirname(loading_trace_path))
           loading_trace.SaveToJsonFile(loading_trace_path)
 
     for _ in xrange(args.repeat):
       for url in job_urls:
         clear_cache = False
         if args.cache_op == 'clear':
@@ skipping 22 matching lines @@
     cache_directory_path = _PullBrowserCache(device)
     _ZipDirectoryContent(cache_directory_path, local_cache_archive_path)
     shutil.rmtree(cache_directory_path)
 
   with open(os.path.join(args.output, 'run_infos.json'), 'w') as file_output:
     json.dump(run_infos, file_output, indent=2)
 
 
 if __name__ == '__main__':
   sys.exit(main())