Removing PY2 lock handler. (#1013)

Author: dieppedalle

openhtf/util/logs.py

@@ -252,16 +252,6 @@ def filter(self, record):
     return match.group('test_uid') == self.test_uid
 
 
-class KillableThreadSafeStreamHandler(logging.StreamHandler):
-
-  def handle(self, record):
-    # logging.Handler objects have an internal lock attribute that is a
-    # threading.RLock instance; it can cause deadlocks in Python 2.7 when a
-    # KillableThread is killed while its release method is running.
-    with threads.safe_lock_release_context(self.lock):
-      return super(KillableThreadSafeStreamHandler, self).handle(record)
-
-
 class RecordHandler(logging.Handler):
   """A handler to save logs to an HTF TestRecord."""
 
@@ -273,13 +263,6 @@ def __init__(self, test_uid, test_record, notify_update):
     self.addFilter(MAC_FILTER)
     self.addFilter(TestUidFilter(test_uid))
 
-  def handle(self, record):
-    # logging.Handler objects have an internal lock attribute that is a
-    # threading.RLock instance; it can cause deadlocks in Python 2.7 when a
-    # KillableThread is killed while its release method is running.
-    with threads.safe_lock_release_context(self.lock):
-      return super(RecordHandler, self).handle(record)
-
   def emit(self, record):
     """Save a logging.LogRecord to our test record.
 
@@ -350,7 +333,7 @@ def configure_logging():
     logging_level = logging.DEBUG
 
   # Configure a handler to print to the CLI.
-  cli_handler = KillableThreadSafeStreamHandler(stream=sys.stdout)
+  cli_handler = logging.StreamHandler(stream=sys.stdout)
   cli_handler.setFormatter(CliFormatter())
   cli_handler.setLevel(logging_level)
   cli_handler.addFilter(MAC_FILTER)

openhtf/util/threads.py

@@ -34,68 +34,6 @@ class InvalidUsageError(Exception):
   """Raised when an API is used in an invalid or unsupported manner."""
 
 
-def safe_lock_release_context(rlock):
-  # Python3 has a C-implementation of RLock, which doesn't have the thread
-  # termination issues.
-  return _placeholder_release()
-
-
-@contextlib.contextmanager
-def _placeholder_release():
-  yield
-
-
-# pylint: disable=protected-access
-@contextlib.contextmanager
-def _safe_lock_release_py2(rlock):
-  """Ensure that a threading.RLock is fully released for Python 2.
-
-  The RLock release code is:
-    https://github.com/python/cpython/blob/2.7/Lib/threading.py#L187
-
-  The RLock object's release method does not release all of its state if an
-  exception is raised in the middle of its operation.  There are three pieces of
-  internal state that must be cleaned up:
-  - owning thread ident, an integer.
-  - entry count, an integer that counts how many times the current owner has
-      locked the RLock.
-  - internal lock, a threading.Lock instance that handles blocking.
-
-  Args:
-    rlock: threading.RLock, lock to fully release.
-
-  Yields:
-    None.
-  """
-  assert isinstance(rlock, threading._RLock)
-  ident = _thread.get_ident()
-  expected_count = 0
-  if rlock._RLock__owner == ident:
-    expected_count = rlock._RLock__count
-  try:
-    yield
-  except ThreadTerminationError:
-    # Check if the current thread still owns the lock by checking if we can
-    # acquire the underlying lock.
-    if rlock._RLock__block.acquire(0):
-      # Lock is clean, so unlock and we are done.
-      rlock._RLock__block.release()
-    elif rlock._RLock__owner == ident and expected_count > 0:
-      # The lock is still held up the stack, so make sure the count is accurate.
-      if rlock._RLock__count != expected_count:
-        rlock._RLock__count = expected_count
-    elif rlock._RLock__owner == ident or rlock._RLock__owner is None:
-      # The internal lock is still acquired, but either this thread or no thread
-      # owns it, which means it needs to be hard reset.
-      rlock._RLock__owner = None
-      rlock._RLock__count = 0
-      rlock._RLock__block.release()
-    raise
-
-
-# pylint: enable=protected-access
-
-
 def loop(_=None, force=False):
   """Causes a function to loop indefinitely."""
   if not force: