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 327 matching lines @@
 
       i = 0
       for i in self._Loop():
         if not self._Reconnect(True):
           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 127 matching lines @@
     if exit_code != 0 or not out:
       return None
     return out.startswith('uid=0(root)')
 
   # Protected methods.
 
   def _Reboot(self):
     """Reboots the phone."""
     i = 0
     for i in self._Loop():
+      # TODO(maruel): It looks like it's possible that the device restart so
+      # fast that it throws an exception at the USB level. 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.
       try:
         out = self._adb_cmd.Reboot()
       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)
       if out == '':
         # reboot doesn't reply anything.
@@ skipping 71 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):
     """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)
     i = 0
     for i in self._Loop():
-      try:
-        self._Find(use_serial=use_serial)
+      if 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)
     _LOG.warning(
         '%s._WaitUntilFound() gave up after %d tries', self.port_path, i+1)
 
   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
         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)
+          self.Close()

[ghost stip (do not use), 2015/11/03 18:50:46]

*sigh* context manager, man

[M-A Ruel, 2015/11/04 18:39:10]

It's in a loop, I changed the break at line 623 to a return True to make it
easier to parse the code.

           break
       else:
         _LOG.error(
             '%s._OpenHandle(): Failed after %d tries', self.port_path, i+1)
         self.Close()
     return bool(self._handle)
 
   def _Connect(self, use_serial):
     """Initializes self._adb_cmd from the opened self._handle.
 
@@ skipping 87 matching lines @@
     """
     self.Close()
     self._WaitUntilFound(use_serial=use_serial)
     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)')