Use -wipe-data on emulator launch to improve android bot reliability.

build/android/emulator.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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
@@ skipping 72 matching lines @@
 
   # 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 = 120
+  _WAITFORBOOT_TIMEOUT = 300
 
   def __init__(self):
     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.popen = None
     self.device = None
 
   def _DeviceName(self):
     """Return our device name."""
     port = _GetAvailablePort()
     return ('emulator-%d' % port, port)
 
   def Launch(self):
     """Launches the emulator and waits for package manager to startup.
 
     If fails, an exception will be raised.
     """
     _KillAllEmulators()  # just to be sure
     (self.device, port) = self._DeviceName()
-    self.popen = subprocess.Popen(args=[
+    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 4 unit test bundles and their data.
         '-partition-size', '256',
+        # ALWAYS 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',
         # Use a familiar name and port.
         '-avd', 'buildbot',
-        '-port', str(port)],
-        stderr=subprocess.STDOUT)
+        '-port', str(port)]
+    logging.info('Emulator launch command: %s', ' '.join(emulator_command))
+    self.popen = subprocess.Popen(args=emulator_command,

[bulach, 2011/12/07 22:55:57]

nit: popen is too generic.. perhaps rather than self.popen, use
self.emulator_process?

[John Grabowski, 2011/12/07 22:57:31]

It returns a popen object.
Class is emulator so I emulator_popen_object is a bit redundant.

+                                  stderr=subprocess.STDOUT)
     self._InstallKillHandler()
     self._ConfirmLaunch()
 
-  def _ConfirmLaunch(self):
+  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.
     """
     a = android_commands.AndroidCommands(self.device, False)
     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)
-    # Now that we checked for obvious problems, wait for a boot complete.
-    # Waiting for the package manager has been problematic.
-    a.Adb().SetTargetSerial(self.device)
-    a.Adb().WaitForBootComplete(self._WAITFORBOOT_TIMEOUT)
+    if wait_for_boot:
+      # Now that we checked for obvious problems, wait for a boot complete.
+      # Waiting for the package manager is sometimes problematic.
+      # TODO(jrg): for reasons I don't understand, sometimes this
+      # gives an "error: device not found" which is only fixed with an
+      # 'adb kill-server' command.  Fix.
+      a.Adb().SetTargetSerial(self.device)
+      a.Adb().WaitForBootComplete(self._WAITFORBOOT_TIMEOUT)
 
   def Shutdown(self):
     """Shuts down the process started by launch."""
     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().launch()
 
 
 if __name__ == '__main__':
   main(sys.argv)