Small fixes as found in staging.

appengine/third_party/python-adb/adb/adb_commands_safe.py

 # Copyright 2015 Google Inc. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #     http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 123 matching lines @@
   def ConnectDevice(cls, port_path, **kwargs):
     """Return a AdbCommandsSafe for a USB device referenced by the port path.
 
     Arguments:
     - port_path: str in form '1/2' to refer to a connected but unopened USB
           device.
     - The rest are the same as __init__().
     """
     # pylint: disable=protected-access
     obj = cls(port_path=port_path, handle=None, **kwargs)
-    obj._WaitUntilFound(use_serial=False)
-    if obj._OpenHandle():
-      obj._Connect(use_serial=False)
+    if obj._WaitUntilFound(use_serial=False):
+      if obj._OpenHandle():
+        obj._Connect(use_serial=False)
     return obj
 
   @classmethod
   def Connect(cls, handle, **kwargs):
     """Return a AdbCommandsSafe for a USB device referenced by a handle.
 
     Arguments:
     - handle: an opened or unopened common.UsbHandle.
     - The rest are the same as __init__().
 
@@ skipping 173 matching lines @@
           return False
 
       if not self._Reboot():
         return False
 
       # There's no need to loop initially too fast. Restarting the phone
       # always take several tens of seconds at best.
       time.sleep(5.)
 
       i = 0
-      for i in self._Loop():
-        if not self._Reconnect(True):
+      for i in self._Loop(timeout=60000):
+        if not self._Reconnect(True, timeout=60000):
           continue
         uptime = self.GetUptime()
         if uptime and uptime < previous_uptime:
           return True
         time.sleep(0.1)
       _LOG.error(
-          '%s.Reboot(): Failed to id after %d tries', self.port_path, i+1)
+          '%s.Reboot(): Failed to reboot after %d tries', self.port_path, i+1)
     return False
 
   def Remount(self):
     """Remount / as read-write."""
     if self._adb_cmd:
       for _ in self._Loop():
         try:
           out = self._adb_cmd.Remount()
           # TODO(maruel): Wait for the remount operation to be completed.
           _LOG.info('%s.Remount(): %s', self.port_path, out)
@@ skipping 129 matching lines @@
     return out.startswith('uid=0(root)')
 
   # Protected methods.
 
   def _Reboot(self):
     """Reboots the phone."""
     i = 0
     for i in self._Loop():
       try:
         out = self._adb_cmd.Reboot()
+      except usb_exceptions.ReadFailedError:
+        # It looks like it's possible that adbd restarts the device so fast that
+        # it close the USB connection before adbd has the time to reply (yay for
+        # race conditions). In that case there's no way to know if the command
+        # worked too fast or something went wrong and the command didn't go
+        # through.
+        # Assume it worked, which is nasty.
+        out = ''
       except self._ERRORS as e:
         if not self._Reset('(): %s', e, use_serial=True):
           break
         continue
 
-      _LOG.info('%s._Reboot(): %r', self.port_path, out)
+      _LOG.info('%s._Reboot(): %s: %r', self.port_path, self.serial, out)
       if out == '':
         # reboot doesn't reply anything.
         return True
       assert False, repr(out)
     _LOG.error('%s._Reboot(): Failed after %d tries', self.port_path, i+1)
     return False
 
   def _Root(self):
     """Upgrades adbd from shell user context (uid 2000) to root."""
     i = 0
     for i in self._Loop():
       try:
         out = self._adb_cmd.Root()
+      except usb_exceptions.ReadFailedError:
+        # It looks like it's possible that adbd restarts itself so fast that it
+        # close the USB connection before adbd has the time to reply (yay for
+        # race conditions). In that case there's no way to know if the command
+        # worked too fast or something went wrong and the command didn't go
+        # through.
+        # Assume it worked, which is nasty.
+        out = 'restarting adbd as root\n'
       except self._ERRORS as e:
         if not self._Reset('(): %s', e, use_serial=True):
           break
         continue
 
       _LOG.info('%s._Root(): %r', self.port_path, out)
       # Hardcoded strings in platform_system_core/adb/services.cpp
       if out == 'adbd is already running as root\n':
         return True
       if out == 'adbd cannot run as root in production builds\n':
@@ skipping 11 matching lines @@
     """Reduces adbd from root to shell user context (uid 2000).
 
     Doing so has the effect of having the device switch USB port. As such, the
     device has to be found back by the serial number, not by self.port_path
     """
     assert self._serial
     i = 0
     for i in self._Loop():
       try:
         out = self._adb_cmd.Unroot()
+      except usb_exceptions.ReadFailedError:
+        # Unroot() is special (compared to Reboot and Root) as it's mostly
+        # guaranteed that the output was sent before the USB connection is torn
+        # down. But the exception still swallows the output (!)
+        # Assume it worked, which is nasty.
+        out = 'restarting adbd as non root\n'
       except self._ERRORS as e:
         if not self._Reset('(): %s', e, use_serial=True):
           break
         continue
 
       _LOG.info('%s.Unroot(): %r', self.port_path, out)
       # Hardcoded strings in platform_system_core/adb/services.cpp
       if out in ('adbd not running as root\n', 'restarting adbd as non root\n'):
         return True
       assert False, repr(out)
@@ skipping 19 matching lines @@
         self._port_path = self._handle.port_path_str
       else:
         self._handle = common.UsbHandle.Find(
             adb_commands.DeviceIsAvailable, port_path=self.port_path,
             timeout_ms=self._default_timeout_ms)
       _LOG.info(
           '%s._Find(%s) %s = %s',
           previous_port_path, use_serial, self._serial,
           self.port_path if self._handle else 'None')
     except (common.usb1.USBError, usb_exceptions.DeviceNotFoundError) as e:
-      _LOG.info(
+      _LOG.debug(
           '%s._Find(%s) %s : %s', self.port_path, use_serial, self._serial, e)
+    return bool(self._handle)
 
-  def _WaitUntilFound(self, use_serial):
+  def _WaitUntilFound(self, use_serial, timeout=None):
     """Loops until the device is found on the USB bus.
 
     The handle is left unopened.
 
     This function should normally be called when either adbd or the phone is
     rebooting.
     """
     assert not self._handle
-    _LOG.debug('%s._WaitUntilFound(%s)', self.port_path, use_serial)
+    _LOG.debug(
+        '%s._WaitUntilFound(%s)',
+        self.port_path, self.serial if use_serial else use_serial)
     i = 0
-    for i in self._Loop():
-      try:
-        self._Find(use_serial=use_serial)
-        return
-      except usb_exceptions.DeviceNotFoundError as e:
-        _LOG.info(
-            '%s._WaitUntilFound(): Retrying _Find() due to %s',
-            self.port_path, e)
+    for i in self._Loop(timeout=timeout):
+      if self._Find(use_serial=use_serial):
+        return True
+    # Enumerate the devices present to help.
+    def fn(h):
+      return '%s:%s' % (h.port_path, h.serial_number)
+    devices = '; '.join(
+        fn(h) for h in
+        common.UsbHandle.FindDevicesSafe(DeviceIsAvailable, timeout_ms=1000))
     _LOG.warning(
-        '%s._WaitUntilFound() gave up after %d tries', self.port_path, i+1)
+        '%s._WaitUntilFound(%s) gave up after %d tries; found %s.',
+        self.port_path, self.serial if use_serial else use_serial, i+1, devices)
+
+    return False
 
   def _OpenHandle(self):
     """Opens the unopened self._handle."""
     #_LOG.debug('%s._OpenHandle()', self.port_path)
     if self._handle:
       assert not self._handle.is_open
       i = 0
       for i in self._Loop():
         try:
           # If this succeeds, this initializes self._handle._handle, which is a
           # usb1.USBDeviceHandle.
           self._handle.Open()
-          break
+          return True
         except common.usb1.USBErrorNoDevice as e:
           _LOG.warning(
               '%s._OpenHandle(): USBErrorNoDevice: %s', self.port_path, e)
           # Do not kill adb, it just means the USB host is likely resetting and
           # the device is temporarily unavailable. We can't use
           # handle.serial_number since this communicates with the device.
         except common.usb1.USBErrorBusy as e:
           _LOG.warning('%s._OpenHandle(): USBErrorBusy: %s', self.port_path, e)
           KillADB()
         except common.usb1.USBErrorAccess as e:
           # Do not try to use serial_number, since we can't even access the
           # port.
-          _LOG.warning(
-              '%s._OpenHandle(): Try rebooting the host: %s', self.port_path, e)
+          _LOG.error(
+              '%s._OpenHandle(): No access, maybe change udev rule or add '
+              'yourself to plugdev: %s', self.port_path, e)
+          # Not worth retrying, exit early.
           break
       else:
         _LOG.error(
             '%s._OpenHandle(): Failed after %d tries', self.port_path, i+1)
-        self.Close()
-    return bool(self._handle)
+      self.Close()
+    return False
 
   def _Connect(self, use_serial):
     """Initializes self._adb_cmd from the opened self._handle.
 
     Returns True on success.
     """
     assert not self._adb_cmd
     _LOG.debug('%s._Connect(%s)', self.port_path, use_serial)
     if self._handle:
       assert self._handle.is_open
       for _ in self._Loop():
         # On the first access with an open handle, try to set self._serial to
         # the serial number of the device. This means communicating to the USB
         # device, so it may throw.
         if not self._handle:
           # It may happen on a retry.
-          self._WaitUntilFound(use_serial=use_serial)
-          self._OpenHandle()
+          if self._WaitUntilFound(use_serial=use_serial):
+            self._OpenHandle()
           if not self._handle:
             break
 
         if not self._serial or use_serial:
           try:
             # The serial number is attached to common.UsbHandle, no
             # adb_commands.AdbCommands.
             self._serial = self._handle.serial_number
           except self._ERRORS as e:
             self.Close()
@@ skipping 18 matching lines @@
         finally:
           # Do not leak the USB handle when we can't talk to the device.
           if not self._adb_cmd:
             self.Close()
 
     if not self._adb_cmd and self._handle:
       _LOG.error('Unexpected close')
       self.Close()
     return bool(self._adb_cmd)
 
-  def _Loop(self):
+  def _Loop(self, timeout=None):
     """Yields a loop until it's too late."""
+    timeout = timeout or self._lost_timeout_ms
     start = time.time()
     for i in xrange(self._tries):
-      if ((time.time() - start) * 1000) >= self._lost_timeout_ms:
+      if ((time.time() - start) * 1000) >= timeout:
         return
       yield i
-      if ((time.time() - start) * 1000) >= self._lost_timeout_ms:
+      if ((time.time() - start) * 1000) >= timeout:
         return
       time.sleep(self._sleep)
 
   def _Reset(self, fmt, *args, **kwargs):
     """When a self._ERRORS occurred, try to reset the device.
 
     Returns True on success.
     """
     items = [self.port_path, inspect.stack()[1][3]]
     items.extend(args)
     msg = ('%s.%s' + fmt) % tuple(items)
     _LOG.error(msg)
     if self._on_error:
       self._on_error(msg)
 
     # Reset the adbd and USB connections with a new connection.
     return self._Reconnect(kwargs.get('use_serial', False))
 
-  def _Reconnect(self, use_serial):
+  def _Reconnect(self, use_serial, timeout=None):
     """Disconnects and reconnect.
 
     Arguments:
     - use_serial: If True, search the device by the serial number instead of the
         port number. This is necessary when downgrading adbd from root to user
         context.
 
     Returns True on success.
     """
     self.Close()
-    self._WaitUntilFound(use_serial=use_serial)
+    if not self._WaitUntilFound(use_serial=use_serial, timeout=timeout):
+      return False
     if not self._OpenHandle():
       return False
     return self._Connect(use_serial=use_serial)
 
   def __repr__(self):
     return '<Device %s %s>' % (
         self.port_path, self.serial if self.is_valid else '(broken)')