Merge pull request #1153 from Gatsik/patch-1

Fix custom Websocket for IPv6 connection

Author: Gatsik

src/client/_clientwindow.py

@@ -1811,7 +1811,7 @@ def handle_welcome(self, message: WelcomeCommand) -> None:
 
         self.authorized.emit(self.me)
 
-        if self.game_session is None or self.game_session.game_uid is None:
+        if self.game_session is None:
             self.game_session = GameSession(
                 player_id=self.id,
                 player_login=self.login,

src/client/workaround_websocket.py

@@ -1,7 +1,5 @@
 import logging
 import socket
-from queue import Queue
-from queue import ShutDown
 from typing import cast
 
 from PyQt6.QtCore import QByteArray
@@ -21,61 +19,48 @@
 logger = logging.getLogger(__name__)
 
 
-class SocketReader(QThread):
+class SocketReader(QObject):
     message_received = pyqtSignal(QByteArray)
-    error = pyqtSignal()
+    error = pyqtSignal(object)
 
-    def __init__(self, connection: ClientConnection) -> None:
+    def __init__(self, connection: ClientConnection | None = None) -> None:
         super().__init__()
-        self.connection = connection
+        self.connection: ClientConnection | None = connection
 
-    def run(self) -> None:
+    def set_connection(self, conn: ClientConnection, /) -> None:
+        self.connection = conn
+
+    def read(self) -> None:
+        if self.connection is None:
+            logger.warning("Trying to read without any connection")
+            return
         try:
             for message in self.connection:
                 self.message_received.emit(QByteArray(cast(bytes, message)))
         except (ConnectionAbortedError, ConnectionClosedError) as e:
-            logger.error(e)
-            self.error.emit()
-            return
-
-
-class SocketWriter(QThread):
-    error = pyqtSignal()
-
-    def __init__(self, connection: ClientConnection, send_queue: Queue[bytes]) -> None:
-        super().__init__()
-        self.send_queue = send_queue
-        self.connection = connection
-
-    def run(self) -> None:
-        while True:
-            try:
-                item = self.send_queue.get()
-            except ShutDown:
-                return
-            try:
-                self.connection.send(item)
-            except (ConnectionAbortedError, ConnectionClosedError) as e:
-                logger.error(e)
-                self.error.emit()
-                return
-            self.send_queue.task_done()
+            self.error.emit(e)
 
 
 class Websocket(QObject):
     binaryMessageReceived = pyqtSignal(QByteArray)
     errorOccurred = pyqtSignal(QAbstractSocket.SocketError)
     stateChanged = pyqtSignal(QAbstractSocket.SocketState)
+    _start_read = pyqtSignal()
 
     def __init__(self, addresses: list[QHostAddress]) -> None:
         super().__init__()
         self.addresses = addresses
         self.socket: socket.socket | None = None
-        self.send_queue: Queue[bytes] | None = None
         self._sock_state = QAbstractSocket.SocketState.UnconnectedState
 
-        self.reader_thread: SocketReader | None = None
-        self.writer_thread: SocketWriter | None = None
+        self.reader_thread = QThread()
+
+        self.reader = SocketReader()
+        self.reader.moveToThread(self.reader_thread)
+        self.reader.message_received.connect(self.binaryMessageReceived.emit)
+        self.reader.error.connect(self.handle_error)
+        self._start_read.connect(self.reader.read)
+
         self.connection: ClientConnection | None = None
 
         self._states = (
@@ -106,13 +91,14 @@ def sock_state(self, value: State) -> None:
         self._sock_state = self._states[value]
         self.stateChanged.emit(self._sock_state)
 
-    def sync_state(self) -> None:
-        assert self.connection is not None
-        self.sock_state = self.connection.state
-
     def sendBinaryMessage(self, message: bytes) -> None:
-        assert self.send_queue is not None
-        self.send_queue.put(message)
+        if self.connection is not None:
+            try:
+                self.connection.send(message)
+            except (ConnectionAbortedError, ConnectionClosedError) as e:
+                self.handle_error(e)
+        else:
+            logger.warning("Trying to write without any connection")
 
     def state(self) -> QAbstractSocket.SocketState:
         return self._sock_state
@@ -121,30 +107,19 @@ def errorString(self) -> str:
         return "[Not implemented]"
 
     def close(self) -> None:
-        self._sock_state = QAbstractSocket.SocketState.UnconnectedState
-        self.stateChanged.emit(self._sock_state)
-
-        if self.send_queue is not None:
-            self.send_queue.shutdown()
-            self.send_queue = None
-        if self.reader_thread is not None:
-            self.reader_thread.quit()
-            self.reader_thread = None
-        if self.writer_thread is not None:
-            self.writer_thread.quit()
-            self.writer_thread = None
         if self.connection is not None:
             self.connection.close()
-            self.connection = None
+        self.connection = None
         self.socket = None
+        self.sock_state = State.CLOSED
 
-    def reader_writer_error(self) -> None:
-        self.sync_state()
+    def handle_error(self, error: Exception) -> None:
+        logger.error(error)
         self.errorOccurred.emit(QAbstractSocket.SocketError.NetworkError)
+        self.close()
 
     def open(self, url: QUrl) -> None:
-        self._sock_state = QAbstractSocket.SocketState.ConnectingState
-        self.stateChanged.emit(self._sock_state)
+        self.sock_state = State.CONNECTING
 
         self.connect()
         assert self.socket is not None
@@ -158,18 +133,9 @@ def open(self, url: QUrl) -> None:
         self.connection.debug = False
         self.connection.protocol.debug = False
 
-        self.start_read_write()
-        self.sync_state()
+        self.reader.set_connection(self.connection)
+        if not self.reader_thread.isRunning():
+            self.reader_thread.start()
+        self._start_read.emit()
 
-    def start_read_write(self) -> None:
-        assert self.connection is not None
-
-        self.reader_thread = SocketReader(self.connection)
-        self.reader_thread.message_received.connect(self.binaryMessageReceived.emit)
-        self.reader_thread.error.connect(self.reader_writer_error)
-        self.reader_thread.start()
-
-        self.send_queue = Queue()
-        self.writer_thread = SocketWriter(self.connection, self.send_queue)
-        self.writer_thread.error.connect(self.reader_writer_error)
-        self.writer_thread.start()
+        self.sock_state = self.connection.state

src/fa/maps.py

@@ -364,6 +364,10 @@ def preview(
         ):
             logger.debug("Using fresh preview image for: " + mapname)
             return util.THEME.icon(img['cache'], False, pixmap)
+
+        if "_coop_" in mapname:
+            return util.THEME.icon("games/unknown_map.png")
+
     except Exception:
         logger.debug("Map Preview Exception ('%s')", mapname, exc_info=sys.exc_info())
     return None

src/fa/replay.py

@@ -199,7 +199,6 @@ def replay(source, detach=False):
     if replay_id:
         arguments.append("/replayid")
         arguments.append(str(replay_id))
-        WatchedReplaysTracker.add(replay_id)
 
     # Update the game appropriately
     if not check(mod, mapname, version, featured_mod_versions, sim_mods, game_dir):
@@ -209,6 +208,8 @@ def replay(source, detach=False):
 
     if runner.run(None, arguments, detach):
         logger.info("Viewing Replay.")
+        if replay_id:
+            WatchedReplaysTracker.add(replay_id)
         return True
     else:
         logger.error("Replaying failed. Guru meditation: %s", arguments)

src/fa/replaylivestreamer.py

@@ -11,6 +11,7 @@
 from PyQt6.QtCore import QUrl
 from PyQt6.QtCore import pyqtSignal
 from PyQt6.QtNetwork import QAbstractSocket
+from PyQt6.QtNetwork import QNetworkReply
 from PyQt6.QtWebSockets import QWebSocket
 from PyQt6.QtWidgets import QMessageBox
 
@@ -37,7 +38,7 @@ class StreamWriter(QObject):
     _close = pyqtSignal()
     _abort = pyqtSignal()
 
-    def __init__(self, gurl: GameUrl) -> None:
+    def __init__(self, gurl: GameUrl | None = None) -> None:
         super().__init__()
         self.game_url = gurl
 
@@ -46,8 +47,6 @@ def __init__(self, gurl: GameUrl) -> None:
         self.socket.connected.connect(self.on_socket_connected)
         self.socket.disconnected.connect(self.on_socket_disconnected)
 
-        self.pipe_connected: int | None = None
-
         self.queue: Queue[bytes] = Queue()
         self._thread = Thread(target=self.stream, daemon=True)
 
@@ -72,6 +71,22 @@ def __init__(self, gurl: GameUrl) -> None:
 
         self._close_intended = False
 
+    def is_finished(self) -> bool:
+        return self._finished
+
+    def reset(self) -> None:
+        self.game_url = None
+
+        self._ready = False
+        self._finished = True
+        self._close_intended = False
+
+        self.queue = Queue()
+        self._thread = Thread(target=self.stream, daemon=True)
+
+    def set_game_url(self, gurl: GameUrl, /) -> None:
+        self.game_url = gurl
+
     def start(self) -> None:
         self._finished = False
         self._logger.debug("Starting named pipe thread...")
@@ -84,12 +99,12 @@ def stream(self) -> None:
             win32pipe.PIPE_TYPE_BYTE | win32pipe.PIPE_WAIT,
             1, 65536, 65536, 0, win32security.SECURITY_ATTRIBUTES(),
         )
-        self.pipe_connected = cast(int, win32pipe.ConnectNamedPipe(pipe, None))
+        pipe_connected = cast(int, win32pipe.ConnectNamedPipe(pipe, None))
 
-        if self.pipe_connected != 0:
+        if pipe_connected != 0:
             self._logger.warning(
                 "Coul not connect named pipe. ConnectNamedPipe returned %s",
-                self.pipe_connected,
+                pipe_connected,
             )
             win32file.CloseHandle(pipe)
             self._close.emit()
@@ -119,6 +134,7 @@ def on_socket_connected(self) -> None:
         # in the past presumably to identify from who we want to receive replay data.
         # nowadays replay server merges data from all players, but the format remained
         # the same, because the game uses this format
+        assert self.game_url is not None
         msg = f"G/{self.game_url.uid}/{self.game_url.player}.scfareplay\x00".encode()
         self.socket.sendBinaryMessage(msg)
 
@@ -150,8 +166,6 @@ def close(self) -> None:
 
     def shutdown(self) -> None:
         self.queue.shutdown()
-        self.pipe_connected = None
-
         self._finished = True
 
         self.closed.emit()
@@ -167,32 +181,34 @@ def __init__(self) -> None:
         self.api = UserApiAccessor()
 
         self.game_url: GameUrl | None = None
-        self.writer: StreamWriter | None = None
+
+        self.writer = StreamWriter()
+        self.writer.ready.connect(self.on_writer_ready)
+        self.writer.not_ready.connect(self.on_writer_not_ready)
+        self.writer.closed.connect(self.on_writer_closed)
 
     def start_live_replay(self, gurl: GameUrl) -> None:
         # TODO: handle linux too
         if sys.platform == "win32" and Settings.get("game/pipe_live_replay", True, type=bool):
+            if not self.writer.is_finished():
+                self._logger.warning("Another instance of StreamWriter is not finished yet.")
+                QMessageBox.warning(None, "Live Replay", "Another live replay is already running.")
+                return
+
             self.game_url = gurl
-            self.api.get("/replay/access", self.on_replay_access_url)
+            self.writer.set_game_url(gurl)
+            self.api.get("/replay/access", self.on_replay_access_url, self.on_api_error)
         else:
             replay(gurl)
 
     def on_replay_access_url(self, data: dict[str, Any]) -> None:
-        if self.writer is not None:
-            self._logger.warning("Another instance of StreamWriter is not finished yet.")
-            QMessageBox.warning(None, "Live Replay", "Another live replay is already running.")
-            return
-
-        assert self.game_url is not None
-        self.writer = StreamWriter(self.game_url)
-        self.writer.ready.connect(self.on_writer_ready)
-        self.writer.not_ready.connect(self.on_writer_not_ready)
-        self.writer.closed.connect(self.on_writer_closed)
         self.writer.connect_to_replay_server(QUrl(data["accessUrl"]))
 
+    def on_api_error(self, _: QNetworkReply) -> None:
+        QMessageBox.warning(None, "Live Replay", "Could not get access to replay server")
+
     def on_writer_ready(self) -> None:
         assert self.game_url is not None
-        assert self.writer is not None
         if replay(self.game_url):
             self.writer.start()
         else:
@@ -204,4 +220,4 @@ def on_writer_not_ready(self) -> None:
         self.on_writer_closed()
 
     def on_writer_closed(self) -> None:
-        self.writer = None
+        self.writer.reset()

src/games/gamepanelwidget.py

@@ -109,6 +109,7 @@ def setupUi(self, widget: QWidget) -> None:
         layout = QVBoxLayout(widget)
         self.mapLabel = ClickableLabel()
         self.mapLabel.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.mapLabel.setFixedHeight(256)
         self.getMapButton = QPushButton("Download/Generate map")
 
         self.titleLabel = QLabel()

src/games/host_ui.py

@@ -34,7 +34,7 @@ def setupUi(self, widget: QWidget) -> None:
 
         self.titleEdit = QLineEdit()
         self.titleEdit.setFont(QFont("Segoe UI", 11))
-        self.titleEdit.setMaxLength(25)
+        self.titleEdit.setMaxLength(128)
         self.titleEdit.setPlaceholderText("[REQUIRED] Enter game name...")
 
         options_layout = QHBoxLayout()