Small fixes as found in staging.

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

 # Copyright 2014 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 75 matching lines @@
     self._write_endpoint = None
     self._interface_number = None
     self._max_read_packet_len = None
 
   @property
   def usb_info(self):
     try:
       sn = self.serial_number
     except libusb1.USBError:
       sn = ''
-    if sn and sn != self._usb_info:
+    if sn and sn != self._usb_info and self._usb_info:
       return '%s %s' % (self._usb_info, sn)
     return self._usb_info
 
   def Open(self):
     """Opens the USB device for this setting, and claims the interface."""
     # Make sure we close any previous handle open to this usb device.
     port_path = self.port_path
     _LOG.info('%s.Open()', self.port_path_str)
 
     with self._HANDLE_CACHE_LOCK:
       previous = self._HANDLE_CACHE.get(port_path)
       if previous:
         _LOG.error(
             '%s.Open(): Found already opened port:\n%s',
             self.port_path_str, previous[1])
         previous[0].Close()
 
-    for endpoint in self._setting.iterEndpoints():
-      address = endpoint.getAddress()
-      if address & libusb1.USB_ENDPOINT_DIR_MASK:
-        self._read_endpoint = address
-        self._max_read_packet_len = endpoint.getMaxPacketSize()
-      else:
-        self._write_endpoint = address
+    try:
+      for endpoint in self._setting.iterEndpoints():
+        address = endpoint.getAddress()
+        if address & libusb1.USB_ENDPOINT_DIR_MASK:
+          self._read_endpoint = address
+          self._max_read_packet_len = endpoint.getMaxPacketSize()
+        else:
+          self._write_endpoint = address
 
-    assert self._read_endpoint is not None
-    assert self._write_endpoint is not None
+      assert self._read_endpoint is not None
+      assert self._write_endpoint is not None
 
-    handle = self._device.open()
-    iface_number = self._setting.getNumber()
-    try:
-      if handle.kernelDriverActive(iface_number):
-        handle.detachKernelDriver(iface_number)
-    except libusb1.USBError as e:
-      if e.value == libusb1.LIBUSB_ERROR_NOT_FOUND:
-        _LOG.warning(
-            '%s.Open(): Kernel driver not found for interface: %s.',
-            self.port_path_str, iface_number)
-      else:
-        raise
-    handle.claimInterface(iface_number)
-    self._handle = handle
-    self._interface_number = iface_number
+      self._handle = self._device.open()
+      self._interface_number = self._setting.getNumber()
+      try:
+        if self._handle.kernelDriverActive(self._interface_number):
+          self._handle.detachKernelDriver(self._interface_number)
+      except libusb1.USBError as e:
+        if e.value == libusb1.LIBUSB_ERROR_NOT_FOUND:
+          _LOG.warning(
+              '%s.Open(): Kernel driver not found for interface: %s.',
+              self.port_path_str, self._interface_number)
+          self.Close()
+        else:
+          raise
+      self._handle.claimInterface(self._interface_number)
 
-    stack = ''.join(traceback.format_stack()[:-2])
-    with self._HANDLE_CACHE_LOCK:
-      self._HANDLE_CACHE[port_path] = (self._handle, stack)

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

that seems wrong, wouldn't you still want to add the ._handle to the cache?

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

It's wrong too, I'll get rid of this once I figured out all the cases where this
can happen, which is always related to %"\&@!!! python exceptions.

+      stack = ''.join(traceback.format_stack()[:-2])
+      with self._HANDLE_CACHE_LOCK:
+        self._HANDLE_CACHE[port_path] = (self, stack)
+    except Exception as e:
+      self.Close()
+      raise
 
   @property
   def is_open(self):
     return bool(self._handle)
 
   @property
   def serial_number(self):
     if not self._serial_number:
       self._serial_number = self._device.getSerialNumber()
     return self._serial_number
@@ skipping 10 matching lines @@
     return '/'.join(str(p) for p in self.port_path)
 
   def Close(self):
     port_path = self.port_path
     _LOG.info('%s.Close()', self.port_path_str)
     with self._HANDLE_CACHE_LOCK:
       self._HANDLE_CACHE.pop(port_path, None)
     if self._handle is None:
       return
     try:
-      self._handle.releaseInterface(self._interface_number)
+      if self._interface_number:
+        self._handle.releaseInterface(self._interface_number)
       self._handle.close()
     except libusb1.USBError as e:
       _LOG.info('%s.Close(): USBError: %s', self.port_path_str, e)
     finally:
       self._handle = None
       self._read_endpoint = None
       self._write_endpoint = None
       self._interface_number = None
       self._max_read_packet_len = None
 
@@ skipping 171 matching lines @@
     return self._connection.sendall(data)
 
   def BulkRead(self, numbytes, timeout=None):  # pylint: disable=unused-argument
     return self._connection.recv(numbytes)
 
   def Timeout(self, timeout_ms):
     return timeout_ms
 
   def Close(self):
     return self._connection.close()