Add the possibility to ignore sigint from other threads (#7623)

### Problem
In the context of #7596, pants tasks will be executed outside of the main thread. This means that tasks like python-repl cannot override signal handling (code), because this can only be done from the main thread.

### Solution
Create an atomic variable, SignalHandler._ignore_sigint, that gates SIGINT handling. Create a global context manager inside ExceptionSink that toggles this for a certain time if needed.

### Result
Any thread can pause the handling of SIGINT in a controlled way.
python-repl no longer installs signal handlers, but rather it toggles the handling of the signal.

### Caveat
We may want to gate all signals individually, but the semantics of SIGINT are usually different enough from SIGTERM and SIGKILL that I think it's okay to only gate the first one.

Author: blorente

src/python/pants/base/exception_sink.py

@@ -10,6 +10,7 @@
 import os
 import signal
 import sys
+import threading
 import traceback
 from builtins import object, str
 from contextlib import contextmanager
@@ -43,11 +44,38 @@ def signal_handler_mapping(self):
     # instead just iterating over the registered signals to set handlers, so a dict is probably
     # better.
     return {
-      signal.SIGINT: self.handle_sigint,
+      signal.SIGINT: self._handle_sigint_if_enabled,
       signal.SIGQUIT: self.handle_sigquit,
       signal.SIGTERM: self.handle_sigterm,
     }
 
+  def __init__(self):
+    self._ignore_sigint_lock = threading.Lock()
+    self._threads_ignoring_sigint = 0
+
+  def _check_sigint_gate_is_correct(self):
+    assert self._threads_ignoring_sigint >= 0, \
+      "This should never happen, someone must have modified the counter outside of SignalHandler."
+
+  def _handle_sigint_if_enabled(self, signum, _frame):
+    with self._ignore_sigint_lock:
+      self._check_sigint_gate_is_correct()
+      threads_ignoring_sigint = self._threads_ignoring_sigint
+    if threads_ignoring_sigint == 0:
+      self.handle_sigint(signum, _frame)
+
+  @contextmanager
+  def _ignoring_sigint(self):
+    with self._ignore_sigint_lock:
+      self._check_sigint_gate_is_correct()
+      self._threads_ignoring_sigint += 1
+    try:
+      yield
+    finally:
+      with self._ignore_sigint_lock:
+        self._threads_ignoring_sigint -= 1
+        self._check_sigint_gate_is_correct()
+
   def handle_sigint(self, signum, _frame):
     raise KeyboardInterrupt('User interrupted execution with control-c!')
 
@@ -283,6 +311,8 @@ def reset_signal_handler(cls, signal_handler):
     OS state:
     - Overwrites signal handlers for SIGINT, SIGQUIT, and SIGTERM.
 
+    NB: This method calls signal.signal(), which will crash if not called from the main thread!
+
     :returns: The :class:`SignalHandler` that was previously registered, or None if this is
               the first time this method was called.
     """
@@ -303,13 +333,32 @@ def reset_signal_handler(cls, signal_handler):
   @classmethod
   @contextmanager
   def trapped_signals(cls, new_signal_handler):
-    """A contextmanager which temporarily overrides signal handling."""
+    """
+    A contextmanager which temporarily overrides signal handling.
+
+    NB: This method calls signal.signal(), which will crash if not called from the main thread!
+    """
     try:
       previous_signal_handler = cls.reset_signal_handler(new_signal_handler)
       yield
     finally:
       cls.reset_signal_handler(previous_signal_handler)
 
+  @classmethod
+  @contextmanager
+  def ignoring_sigint(cls):
+    """
+    A contextmanager which disables handling sigint in the current signal handler.
+    This allows threads that are not the main thread to ignore sigint.
+
+    NB: Only use this if you can't use ExceptionSink.trapped_signals().
+
+    Class state:
+    - Toggles `self._ignore_sigint` in `cls._signal_handler`.
+    """
+    with cls._signal_handler._ignoring_sigint():
+      yield
+
   @classmethod
   def _iso_timestamp_for_now(cls):
     return datetime.datetime.now().isoformat()