The Tor Browser: comparison media/webrtc/trunk/build/android/emulator.py

--1:000000000000
+:157ee0c27f81
+#!/usr/bin/env python
+#
+# Copyright (c) 2012 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.
+"""Provides an interface to start and stop Android emulator.
+Assumes system environment ANDROID_NDK_ROOT has been set.
+Emulator: The class provides the methods to launch/shutdown the emulator with
+the android virtual device named 'avd_armeabi' .
+"""
+import logging
+import os
+import signal
+import subprocess
+import sys
+import time
+from pylib import android_commands
+from pylib import cmd_helper
+# adb_interface.py is under ../../third_party/android_testrunner/
+sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)), '..',
+'..', 'third_party', 'android_testrunner'))
+import adb_interface
+import errors
+import run_command
+class EmulatorLaunchException(Exception):
+"""Emulator failed to launch."""
+pass
+def _KillAllEmulators():
+"""Kill all running emulators that look like ones we started.
+There are odd 'sticky' cases where there can be no emulator process
+running but a device slot is taken.  A little bot trouble and and
+we're out of room forever.
+"""
+emulators = android_commands.GetEmulators()
+if not emulators:
+return
+for emu_name in emulators:
+cmd_helper.GetCmdOutput(['adb', '-s', emu_name, 'emu', 'kill'])
+logging.info('Emulator killing is async; give a few seconds for all to die.')
+for i in range(5):
+if not android_commands.GetEmulators():
+return
+time.sleep(1)
+def DeleteAllTempAVDs():
+"""Delete all temporary AVDs which are created for tests.
+If the test exits abnormally and some temporary AVDs created when testing may
+be left in the system. Clean these AVDs.
+"""
+avds = android_commands.GetAVDs()
+if not avds:
+return
+for avd_name in avds:
+if 'run_tests_avd' in avd_name:
+cmd = ['android', '-s', 'delete', 'avd', '--name', avd_name]
+cmd_helper.GetCmdOutput(cmd)
+logging.info('Delete AVD %s' % avd_name)
+class PortPool(object):
+"""Pool for emulator port starting position that changes over time."""
+_port_min = 5554
+_port_max = 5585
+_port_current_index = 0
+@classmethod
+def port_range(cls):
+"""Return a range of valid ports for emulator use.
+The port must be an even number between 5554 and 5584.  Sometimes
+a killed emulator "hangs on" to a port long enough to prevent
+relaunch.  This is especially true on slow machines (like a bot).
+Cycling through a port start position helps make us resilient."""
+ports = range(cls._port_min, cls._port_max, 2)
+n = cls._port_current_index
+cls._port_current_index = (n + 1) % len(ports)
+return ports[n:] + ports[:n]
+def _GetAvailablePort():
+"""Returns an available TCP port for the console."""
+used_ports = []
+emulators = android_commands.GetEmulators()
+for emulator in emulators:
+used_ports.append(emulator.split('-')[1])
+for port in PortPool.port_range():
+if str(port) not in used_ports:
+return port
+class Emulator(object):
+"""Provides the methods to lanuch/shutdown the emulator.
+The emulator has the android virtual device named 'avd_armeabi'.
+The emulator could use any even TCP port between 5554 and 5584 for the
+console communication, and this port will be part of the device name like
+'emulator-5554'. Assume it is always True, as the device name is the id of
+emulator managed in this class.
+Attributes:
+emulator: Path of Android's emulator tool.
+popen: Popen object of the running emulator process.
+device: Device name of this emulator.
+"""
+# Signals we listen for to kill the emulator on
+_SIGNALS = (signal.SIGINT, signal.SIGHUP)
+# Time to wait for an emulator launch, in seconds.  This includes
+# the time to launch the emulator and a wait-for-device command.
+_LAUNCH_TIMEOUT = 120
+# Timeout interval of wait-for-device command before bouncing to a a
+# process life check.
+_WAITFORDEVICE_TIMEOUT = 5
+# Time to wait for a "wait for boot complete" (property set on device).
+_WAITFORBOOT_TIMEOUT = 300
+def __init__(self, new_avd_name, fast_and_loose):
+"""Init an Emulator.
+Args:
+nwe_avd_name: If set, will create a new temporary AVD.
+fast_and_loose: Loosen up the rules for reliable running for speed.
+Intended for quick testing or re-testing.
+"""
+try:
+android_sdk_root = os.environ['ANDROID_SDK_ROOT']
+except KeyError:
+logging.critical('The ANDROID_SDK_ROOT must be set to run the test on '
+'emulator.')
+raise
+self.emulator = os.path.join(android_sdk_root, 'tools', 'emulator')
+self.android = os.path.join(android_sdk_root, 'tools', 'android')
+self.popen = None
+self.device = None
+self.default_avd = True
+self.fast_and_loose = fast_and_loose
+self.abi = 'armeabi-v7a'
+self.avd = 'avd_armeabi'
+if 'x86' in os.environ.get('TARGET_PRODUCT', ''):
+self.abi = 'x86'
+self.avd = 'avd_x86'
+if new_avd_name:
+self.default_avd = False
+self.avd = self._CreateAVD(new_avd_name)
+def _DeviceName(self):
+"""Return our device name."""
+port = _GetAvailablePort()
+return ('emulator-%d' % port, port)
+def _CreateAVD(self, avd_name):
+"""Creates an AVD with the given name.
+Return avd_name.
+"""
+avd_command = [
+self.android,
+'--silent',
+'create', 'avd',
+'--name', avd_name,
+'--abi', self.abi,
+'--target', 'android-16',
+'-c', '128M',
+'--force',
+]
+avd_process = subprocess.Popen(args=avd_command,
+stdin=subprocess.PIPE,
+stdout=subprocess.PIPE,
+stderr=subprocess.STDOUT)
+avd_process.stdin.write('no\n')
+avd_process.wait()
+logging.info('Create AVD command: %s', ' '.join(avd_command))
+return avd_name
+def _DeleteAVD(self):
+"""Delete the AVD of this emulator."""
+avd_command = [
+self.android,
+'--silent',
+'delete',
+'avd',
+'--name', self.avd,
+]
+avd_process = subprocess.Popen(args=avd_command,
+stdout=subprocess.PIPE,
+stderr=subprocess.STDOUT)
+logging.info('Delete AVD command: %s', ' '.join(avd_command))
+avd_process.wait()
+def Launch(self, kill_all_emulators):
+"""Launches the emulator asynchronously. Call ConfirmLaunch() to ensure the
+emulator is ready for use.
+If fails, an exception will be raised.
+"""
+if kill_all_emulators:
+_KillAllEmulators()  # just to be sure
+if not self.fast_and_loose:
+self._AggressiveImageCleanup()
+(self.device, port) = self._DeviceName()
+emulator_command = [
+self.emulator,
+# Speed up emulator launch by 40%.  Really.
+'-no-boot-anim',
+# The default /data size is 64M.
+# That's not enough for 8 unit test bundles and their data.
+'-partition-size', '512',
+# Enable GPU by default.
+'-gpu', 'on',
+# Use a familiar name and port.
+'-avd', self.avd,
+'-port', str(port)]
+if not self.fast_and_loose:
+emulator_command.extend([
+# Wipe the data.  We've seen cases where an emulator
+# gets 'stuck' if we don't do this (every thousand runs or
+# so).
+'-wipe-data',
+])
+logging.info('Emulator launch command: %s', ' '.join(emulator_command))
+self.popen = subprocess.Popen(args=emulator_command,
+stderr=subprocess.STDOUT)
+self._InstallKillHandler()
+def _AggressiveImageCleanup(self):
+"""Aggressive cleanup of emulator images.
+Experimentally it looks like our current emulator use on the bot
+leaves image files around in /tmp/android-$USER.  If a "random"
+name gets reused, we choke with a 'File exists' error.
+TODO(jrg): is there a less hacky way to accomplish the same goal?
+"""
+logging.info('Aggressive Image Cleanup')
+emulator_imagedir = '/tmp/android-%s' % os.environ['USER']
+if not os.path.exists(emulator_imagedir):
+return
+for image in os.listdir(emulator_imagedir):
+full_name = os.path.join(emulator_imagedir, image)
+if 'emulator' in full_name:
+logging.info('Deleting emulator image %s', full_name)
+os.unlink(full_name)
+def ConfirmLaunch(self, wait_for_boot=False):
+"""Confirm the emulator launched properly.
+Loop on a wait-for-device with a very small timeout.  On each
+timeout, check the emulator process is still alive.
+After confirming a wait-for-device can be successful, make sure
+it returns the right answer.
+"""
+seconds_waited = 0
+number_of_waits = 2  # Make sure we can wfd twice
+adb_cmd = "adb -s %s %s" % (self.device, 'wait-for-device')
+while seconds_waited < self._LAUNCH_TIMEOUT:
+try:
+run_command.RunCommand(adb_cmd,
+timeout_time=self._WAITFORDEVICE_TIMEOUT,
+retry_count=1)
+number_of_waits -= 1
+if not number_of_waits:
+break
+except errors.WaitForResponseTimedOutError as e:
+seconds_waited += self._WAITFORDEVICE_TIMEOUT
+adb_cmd = "adb -s %s %s" % (self.device, 'kill-server')
+run_command.RunCommand(adb_cmd)
+self.popen.poll()
+if self.popen.returncode != None:
+raise EmulatorLaunchException('EMULATOR DIED')
+if seconds_waited >= self._LAUNCH_TIMEOUT:
+raise EmulatorLaunchException('TIMEOUT with wait-for-device')
+logging.info('Seconds waited on wait-for-device: %d', seconds_waited)
+if wait_for_boot:
+# Now that we checked for obvious problems, wait for a boot complete.
+# Waiting for the package manager is sometimes problematic.
+a = android_commands.AndroidCommands(self.device)
+a.WaitForSystemBootCompleted(self._WAITFORBOOT_TIMEOUT)
+def Shutdown(self):
+"""Shuts down the process started by launch."""
+if not self.default_avd:
+self._DeleteAVD()
+if self.popen:
+self.popen.poll()
+if self.popen.returncode == None:
+self.popen.kill()
+self.popen = None
+def _ShutdownOnSignal(self, signum, frame):
+logging.critical('emulator _ShutdownOnSignal')
+for sig in self._SIGNALS:
+signal.signal(sig, signal.SIG_DFL)
+self.Shutdown()
+raise KeyboardInterrupt  # print a stack
+def _InstallKillHandler(self):
+"""Install a handler to kill the emulator when we exit unexpectedly."""
+for sig in self._SIGNALS:
+signal.signal(sig, self._ShutdownOnSignal)
+def main(argv):
+Emulator(None, True).Launch(True)
+if __name__ == '__main__':
+main(sys.argv)

The Tor Browser / file comparison

comparison: media/webrtc/trunk/build/android/emulator.py

media/webrtc/trunk/build/android/emulator.py