Add signal handlers for graceful disconnects:

- On ``SIGTERM`` and  ``SIGNINT`` (KeyboardInterrupt), disconnect
  gracefully from the provider.

- KeyboardInterrupt used to hang for a while because of the open
  connection. This makes it so we no longer wait the whole
  connection_timeout and it raises the KeyboardInterrupt exception
  immediately. Leave the responsibility of handling the
  KeyboardInterrupt to the user.

Author: fselmo

web3/providers/persistent/async_ipc.py

@@ -140,6 +140,7 @@ async def _provider_specific_connect(self) -> None:
         )
 
     async def _provider_specific_disconnect(self) -> None:
+        # this should remain idempotent
         if self._writer and not self._writer.is_closing():
             self._writer.close()
             await self._writer.wait_closed()

web3/providers/persistent/persistent.py

@@ -4,6 +4,7 @@
 )
 import asyncio
 import logging
+import signal
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -176,6 +177,7 @@ async def connect(self) -> None:
                 self.logger.info(
                     f"Successfully connected to: {self.get_endpoint_uri_or_ipc_path()}"
                 )
+                self._set_signal_handlers()
                 break
             except (WebSocketException, OSError) as e:
                 if _connection_attempts == self._max_connection_retries:
@@ -192,6 +194,7 @@ async def connect(self) -> None:
                 _backoff_time *= _backoff_rate_change
 
     async def disconnect(self) -> None:
+        # this should remain idempotent
         try:
             if self._message_listener_task:
                 self._message_listener_task.cancel()
@@ -260,11 +263,35 @@ async def _provider_specific_connect(self) -> None:
         raise NotImplementedError("Must be implemented by subclasses")
 
     async def _provider_specific_disconnect(self) -> None:
+        # this method should be idempotent
         raise NotImplementedError("Must be implemented by subclasses")
 
     async def _provider_specific_socket_reader(self) -> RPCResponse:
         raise NotImplementedError("Must be implemented by subclasses")
 
+    def _set_signal_handlers(self) -> None:
+        loop = asyncio.get_event_loop()
+
+        def extended_handler(sig: int, frame: Any, existing_handler: Any) -> None:
+            loop.create_task(self.disconnect())
+
+            # invoke the existing handler, if callable
+            if callable(existing_handler):
+                existing_handler(sig, frame)
+
+        existing_sigint_handler = signal.getsignal(signal.SIGINT)
+        existing_sigterm_handler = signal.getsignal(signal.SIGTERM)
+
+        # extend the existing signal handlers to include the disconnect method
+        signal.signal(
+            signal.SIGINT,
+            lambda sig, frame: extended_handler(sig, frame, existing_sigint_handler),
+        )
+        signal.signal(
+            signal.SIGTERM,
+            lambda sig, frame: extended_handler(sig, frame, existing_sigterm_handler),
+        )
+
     def _message_listener_callback(
         self, message_listener_task: "asyncio.Task[None]"
     ) -> None:

web3/providers/persistent/websocket.py

@@ -132,6 +132,7 @@ async def _provider_specific_connect(self) -> None:
         self._ws = await connect(self.endpoint_uri, **self.websocket_kwargs)
 
     async def _provider_specific_disconnect(self) -> None:
+        # this should remain idempotent
         if self._ws is not None and not self._ws.closed:
             await self._ws.close()
             self._ws = None