[Cronet] Get Cronet performance test running again

components/cronet/android/test/javaperftests/run.py

 #!/usr/bin/env python
 # 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.
 
 """This script runs an automated Cronet performance benchmark.
 
 This script:
 1. Sets up "USB reverse tethering" which allow network traffic to flow from
    an Android device connected to the host machine via a USB cable.
@@ skipping 46 matching lines @@
 from telemetry import story
 from telemetry.internal import forwarders
 from telemetry.internal.forwarders import android_forwarder
 from telemetry.value import scalar
 from telemetry.web_perf import timeline_based_measurement
 
 BUILD_TYPE = 'Release'
 BUILD_DIR = os.path.join(REPOSITORY_ROOT, 'out', BUILD_TYPE)
 QUIC_SERVER = os.path.join(BUILD_DIR, 'quic_server')
 QUIC_CLIENT = os.path.join(BUILD_DIR, 'quic_client')
+CERT_PATH = os.path.join('net', 'data', 'ssl', 'certificates')
+QUIC_CERT_DIR = os.path.join(REPOSITORY_ROOT, CERT_PATH)
+QUIC_CERT_HOST = 'test.example.com'
+QUIC_CERT_FILENAME = 'quic_%s.crt' % QUIC_CERT_HOST
+QUIC_CERT = os.path.join(QUIC_CERT_DIR, QUIC_CERT_FILENAME)
+QUIC_KEY = os.path.join(QUIC_CERT_DIR, 'quic_%s.key.pkcs8' % QUIC_CERT_HOST)
 APP_APK = os.path.join(BUILD_DIR, 'apks', 'CronetPerfTest.apk')
 APP_PACKAGE = 'org.chromium.net'
 APP_ACTIVITY = '.CronetPerfTestActivity'
 APP_ACTION = 'android.intent.action.MAIN'
 BENCHMARK_CONFIG = {
   # Control various metric recording for further investigation.
   'CAPTURE_NETLOG': False,
   'CAPTURE_TRACE': False,
   'CAPTURE_SAMPLED_TRACE': False,
   # While running Cronet Async API benchmarks, indicate if callbacks should be
@@ skipping 12 matching lines @@
   'LARGE_ITERATIONS': 4,
   # An on-device file containing benchmark timings.  Written by benchmark app.
   'RESULTS_FILE': '/data/data/' + APP_PACKAGE + '/results.txt',
   # An on-device file whose presence indicates benchmark app has terminated.
   'DONE_FILE': '/data/data/' + APP_PACKAGE + '/done.txt',
   # Ports of HTTP and QUIC servers on host.
   'HTTP_PORT': 9000,
   'QUIC_PORT': 9001,
   # Maximum read/write buffer size to use.
   'MAX_BUFFER_SIZE': 16384,
+  'HOST': QUIC_CERT_HOST,
+  'QUIC_CERT_FILE': QUIC_CERT_FILENAME,
 }
 # Add benchmark config to global state for easy access.
 globals().update(BENCHMARK_CONFIG)
 
 
 def GetDevice():
   devices = device_utils.DeviceUtils.HealthyDevices()
   assert len(devices) == 1
   return devices[0]
 
@@ skipping 12 matching lines @@
 
 class CronetPerfTestAndroidStory(android.AndroidStory):
   # Android AppStory implementation wrapping CronetPerfTest app.
   # Launches Cronet perf test app and waits for execution to complete
   # by waiting for presence of DONE_FILE.
 
   def __init__(self, device):
     self._device = device
     device.RunShellCommand('rm %s' % DONE_FILE)
     config = BENCHMARK_CONFIG
-    config['HOST'] = GetServersHost(device)
+    config['HOST_IP'] = GetServersHost(device)
     start_intent = intent.Intent(
         package=APP_PACKAGE,
         activity=APP_ACTIVITY,
         action=APP_ACTION,
         # |config| maps from configuration value names to the configured values.
         # |config| is encoded as URL parameter names and values and passed to
         # the Cronet perf test app via the Intent data field.
         data='http://dummy/?'+urllib.urlencode(config),
         extras=None,
         category=None)
@@ skipping 59 matching lines @@
 class QuicServer:
 
   def __init__(self, quic_server_doc_root):
     self._process = None
     self._quic_server_doc_root = quic_server_doc_root
 
   def StartupQuicServer(self, device):
     self._process = pexpect.spawn(QUIC_SERVER,
                                   ['--quic_in_memory_cache_dir=%s' %
                                       self._quic_server_doc_root,
+                                   '--certificate_file=%s' % QUIC_CERT,
+                                   '--key_file=%s' % QUIC_KEY,
                                    '--port=%d' % QUIC_PORT])
     assert self._process != None
     # Wait for quic_server to start serving.
     waited_s = 0
-    while subprocess.call([QUIC_CLIENT,
-                           '--host=%s' % GetServersHost(device),
-                           '--port=%d' % QUIC_PORT,
-                           'http://%s:%d/%s' % (GetServersHost(device),
-                                                QUIC_PORT, SMALL_RESOURCE)],
+    while subprocess.call(['lsof', '-i', 'udp:%d' % QUIC_PORT, '-p',
+                           '%d' % self._process.pid],
                           stdout=open(os.devnull, 'w')) != 0:
       sleep(0.1)
       waited_s += 0.1
       assert waited_s < 5, "quic_server failed to start after %fs" % waited_s
+    # Push certificate to device.
+    cert = open(QUIC_CERT, 'r').read()
+    device_cert_path = os.path.join(device.GetExternalStoragePath(), CERT_PATH)
+    device.RunShellCommand('mkdir -p %s' % device_cert_path)
+    device.WriteFile(os.path.join(device_cert_path, QUIC_CERT_FILENAME), cert)
 
   def ShutdownQuicServer(self):
     if self._process:
       self._process.terminate()
 
 
 def GenerateHttpTestResources():
   http_server_doc_root = tempfile.mkdtemp()
   # Create a small test file to serve.
   small_file_name = os.path.join(http_server_doc_root, SMALL_RESOURCE)
@@ skipping 17 matching lines @@
   quic_server_doc_root = tempfile.mkdtemp()
   # Use wget to build up fake QUIC in-memory cache dir for serving.
   # quic_server expects the dir/file layout that wget produces.
   for resource in [SMALL_RESOURCE, LARGE_RESOURCE]:
     assert subprocess.Popen(['wget', '-p', '-q', '--save-headers',
                              GetHttpServerURL(device, resource)],
                             cwd=quic_server_doc_root).wait() == 0
   # wget places results in host:port directory.  Adjust for QUIC port.
   os.rename(os.path.join(quic_server_doc_root,
                          "%s:%d" % (GetServersHost(device), HTTP_PORT)),
-            os.path.join(quic_server_doc_root,
-                         "%s:%d" % (GetServersHost(device), QUIC_PORT)))
+            os.path.join(quic_server_doc_root, QUIC_CERT_HOST))
   return quic_server_doc_root
 
 
 def GenerateLighttpdConfig(config_file, http_server_doc_root, http_server):
   # Must create customized config file to allow overriding the server.bind
   # setting.
   config_file.write('server.document-root = "%s"\n' % http_server_doc_root)
   config_file.write('server.port = %d\n' % HTTP_PORT)
   # These lines are added so lighttpd_server.py's internal test succeeds.
   config_file.write('server.tag = "%s"\n' % http_server.server_tag)
@@ skipping 28 matching lines @@
   quic_server.StartupQuicServer(device)
   # Launch Telemetry's benchmark_runner on CronetPerfTestBenchmark.
   # By specifying this file's directory as the benchmark directory, it will
   # allow benchmark_runner to in turn open this file up and find the
   # CronetPerfTestBenchmark class to run the benchmark.
   top_level_dir = os.path.dirname(os.path.realpath(__file__))
   # The perf config file is required to continue using dependencies on the
   # Chromium checkout in Telemetry.
   perf_config_file = os.path.join(REPOSITORY_ROOT, 'tools', 'perf', 'core',
       'binary_dependencies.json')
+  with open(perf_config_file, "w") as config_file:
+    config_file.write('{"config_type": "BaseConfig"}')
   runner_config = benchmark_runner.ProjectConfig(
       top_level_dir=top_level_dir,
       benchmark_dirs=[top_level_dir],
-      client_config=perf_config_file)
+      client_config=perf_config_file,
+      default_chrome_root=REPOSITORY_ROOT)
   sys.argv.insert(1, 'run')
   sys.argv.insert(2, 'run.CronetPerfTestBenchmark')
   sys.argv.insert(3, '--android-rndis')
   benchmark_runner.main(runner_config)
   # Shutdown.
   quic_server.ShutdownQuicServer()
   shutil.rmtree(quic_server_doc_root)
   http_server.ShutdownHttpServer()
   shutil.rmtree(http_server_doc_root)
 
 
 if __name__ == '__main__':
   main()