websocket: Fix lint, remove hard-coded 30s default timeout

Author: bdarnell

tornado/test/websocket_test.py

@@ -844,31 +844,33 @@ def test_client_ping(self):
 
 class ServerPingTimeoutTest(WebSocketBaseTestCase):
     def get_app(self):
-        handlers = []
+        self.handlers: list[WebSocketHandler] = []
+        test = self
 
         class PingHandler(TestWebSocketHandler):
             def initialize(self, close_future=None, compression_options=None):
+                self.handlers = test.handlers
                 # capture the handler instance so we can interrogate it later
-                handlers.append(self)
+                self.handlers.append(self)
                 return super().initialize(
-                    close_future=close_future,
-                    compression_options=compression_options,
+                    close_future=close_future, compression_options=compression_options
                 )
 
         app = Application([("/", PingHandler)])
-        app._handlers = handlers
         return app
 
     @staticmethod
     def suppress_pong(ws):
         """Suppress the client's "pong" response."""
+
         def wrapper(fcn):
             def _inner(oppcode: int, data: bytes):
                 if oppcode == 0xA:  # NOTE: 0x9=ping, 0xA=pong
                     # prevent pong responses
                     return
                 # leave all other responses unchanged
                 return fcn(oppcode, data)
+
             return _inner
 
         ws.protocol._handle_message = wrapper(ws.protocol._handle_message)
@@ -879,7 +881,7 @@ def test_client_ping_timeout(self):
         ws = yield self.ws_connect("/", ping_interval=0.2, ping_timeout=0.05)
 
         # websocket handler (server side)
-        handler = self._app._handlers[0]
+        handler = self.handlers[0]
 
         for _ in range(5):
             # wait for the ping period
@@ -900,7 +902,7 @@ def test_client_ping_timeout(self):
 
         # connection should be closed from the server side
         assert handler.close_code == 1000
-        assert handler.close_reason == 'ping timed out'
+        assert handler.close_reason == "ping timed out"
 
         # client should have received a close operation
         assert ws.protocol.close_code == 1000

tornado/websocket.py

@@ -28,7 +28,7 @@
 from tornado.concurrent import Future, future_set_result_unless_cancelled
 from tornado.escape import utf8, native_str, to_unicode
 from tornado import gen, httpclient, httputil
-from tornado.ioloop import IOLoop, PeriodicCallback
+from tornado.ioloop import IOLoop
 from tornado.iostream import StreamClosedError, IOStream
 from tornado.log import gen_log, app_log
 from tornado.netutil import Resolver
@@ -860,7 +860,6 @@ def __init__(
         # the effect of compression, frame overhead, and control frames.
         self._wire_bytes_in = 0
         self._wire_bytes_out = 0
-        self.ping_callback = None  # type: Optional[PeriodicCallback]
         self._received_pong = False  # type: bool
         self.close_code = None  # type: Optional[int]
         self.close_reason = None  # type: Optional[str]
@@ -1327,13 +1326,13 @@ def ping_timeout(self) -> float:
                     # Note: using de_dupe_gen_log to prevent this message from
                     # being duplicated for each connection
                     logging.WARNING,
-                    f'The websocket_ping_timeout ({timeout}) cannot be longer'
-                    f' than the websocket_ping_interval ({self.ping_interval}).'
-                    f'\nSetting websocket_ping_timeout={self.ping_interval}'
+                    f"The websocket_ping_timeout ({timeout}) cannot be longer"
+                    f" than the websocket_ping_interval ({self.ping_interval})."
+                    f"\nSetting websocket_ping_timeout={self.ping_interval}",
                 )
                 return self.ping_interval
             return timeout
-        return min(self.ping_interval, 30)
+        return self.ping_interval
 
     def start_pinging(self) -> None:
         """Start sending periodic pings to keep the connection alive"""
@@ -1366,7 +1365,7 @@ async def periodic_ping(self) -> None:
 
             # make sure we received a pong within the timeout
             if timeout > 0 and not self._received_pong:
-                self.close(reason='ping timed out')
+                self.close(reason="ping timed out")
                 return
 
             # wait until the next scheduled ping