swarming: Enable USB resets in python-adb on the staging instance.

appengine/third_party/python-adb/adb/contrib/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 73 matching lines @@
   #   anymore. It is sometimes thrown as USBErrorIO.
   _ERRORS = (
       usb_exceptions.CommonUsbError,
       common.usb1.USBError,
       common.usb1.USBErrorIO)
 
   _SHELL_SUFFIX = ' ;echo -e "\n$?"'
 
   def __init__(
       self, handle, banner, rsa_keys, on_error, port_path=None,
-      default_timeout_ms=10000, auth_timeout_ms=10000, lost_timeout_ms=10000):
+      default_timeout_ms=10000, auth_timeout_ms=10000, lost_timeout_ms=10000,
+      enable_resets=False):
     """Constructs an AdbCommandsSafe.
 
     Arguments:
     - port_path: str addressing the device on the USB bus, e.g. '1/2'.
     - handle: common.UsbHandle or None.
     - banner: How the app present itself to the device. This affects
           authentication so it is better to use an hardcoded constant.
     - rsa_keys: list of AuthSigner.
     - on_error: callback to call in case of error.
     - default_timeout_ms: Timeout for adbd to reply to a command.
@@ skipping 17 matching lines @@
         auth_timeout_ms, lost_timeout_ms)
     # Immutable.
     self._auth_timeout_ms = auth_timeout_ms
     self._default_timeout_ms = default_timeout_ms
     self._banner = banner or socket.gethostname()
     self._lost_timeout_ms = lost_timeout_ms
     self._on_error = on_error
     self._rsa_keys = rsa_keys
     self._sleep = 0.1
     self._tries = int(round((self._lost_timeout_ms / 1000. + 5) / self._sleep))
+    self._should_reset = enable_resets
 
     # State.
     self._adb_cmd = None
     self._serial = None
     self._failure = None
     self._handle = handle
     self._port_path = '/'.join(str(p) for p in port_path) if port_path else None
 
   @classmethod
   def ConnectDevice(cls, port_path, **kwargs):
@@ skipping 679 matching lines @@
               self._handle, banner=self._banner, rsa_keys=self._rsa_keys,
               auth_timeout_ms=self._auth_timeout_ms)
           self._failure = None if self._adb_cmd else 'unknown'
           break
         except usb_exceptions.DeviceAuthError as e:
           self._failure = 'unauthorized'
           _LOG.warning('AUTH FAILURE: %s: %s', self.port_path, e)
         except usb_exceptions.LibusbWrappingError as e:
           self._failure = 'usb_failure'
           _LOG.warning('I/O FAILURE: %s: %s', self.port_path, e)
-          # TODO(crbug.com/642440): Reset the handle here if fleet health
-          # regresses and host kernel panics don't subside.
+          if self._should_reset:
+            self._handle.Reset()
         except adb_protocol.InvalidResponseError as e:
           self._failure = 'protocol_fault'
           _LOG.warning('SYNC FAILURE: %s: %s', self.port_path, e)
         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')
@@ skipping 40 matching lines @@
     self.Close()
     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)')