From: 
Subject: Debian changes

The Debian packaging of python-snitun is maintained in git, using a workflow
similar to the one described in dgit-maint-merge(7).
The Debian delta is represented by this one combined patch; there isn't a
patch queue that can be represented as a quilt series.

A detailed breakdown of the changes is available from their canonical
representation -- git commits in the packaging repository.
For example, to see the changes made by the Debian maintainer in the first
upload of upstream version 1.2.3, you could use:

    % git clone https://git.dgit.debian.org/python-snitun
    % cd python-snitun
    % git log --oneline 1.2.3..debian/1.2.3-1 -- . ':!debian'

(If you have dgit, use `dgit clone python-snitun`, rather than plain `git clone`.)

We don't use debian/source/options single-debian-patch because it has bugs.
Therefore, NMUs etc. may nevertheless have made additional patches.

---

diff --git a/snitun/server/worker.py b/snitun/server/worker.py
index 8dfa7f2..2aff6ce 100644
--- a/snitun/server/worker.py
+++ b/snitun/server/worker.py
@@ -63,10 +63,10 @@ class ServerWorker(ForkServerProcess):
         self._metrics_task: asyncio.Task | None = None
 
         # Communication between Parent/Child
-        self._manager: SyncManager = Manager()
-        self._new = self._manager.Queue()
-        self._sync = self._manager.dict()
-        self._peer_count = self._manager.Value("peer_count", 0)
+        manager: SyncManager = Manager()
+        self._new = manager.Queue()
+        self._sync = manager.dict()
+        self._peer_count = manager.Value("i", 0)
 
     def __getstate__(self) -> dict[str, Any]:
         """Return picklable state for spawn/forkserver.
@@ -158,12 +158,12 @@ class ServerWorker(ForkServerProcess):
         """Event stream peer connection data."""
         if event == PeerManagerEvent.CONNECTED:
             if peer.hostname not in self._sync:
-                self._peer_count.set(self._peer_count.value + 1)
+                self._peer_count.value += 1
             for hostname in peer.all_hostnames:
                 self._sync[hostname] = None
         else:
             if peer.hostname in self._sync:
-                self._peer_count.set(self._peer_count.value - 1)
+                self._peer_count.value -= 1
             for hostname in peer.all_hostnames:
                 self._sync.pop(hostname, None)
 
diff --git a/tests/server/test_run.py b/tests/server/test_run.py
index cc206f4..2324752 100644
--- a/tests/server/test_run.py
+++ b/tests/server/test_run.py
@@ -414,29 +414,47 @@ def test_snitun_worker_runner(
 
     multiplexer = loop.run_until_complete(_create_multiplexer())
 
-    for payload in payloads:
-        sock_ssl.sendall(payload)
-        loop.run_until_complete(asyncio.sleep(0.1))
+    multiplexer_shutdown = False
+    try:
+        for payload in payloads:
+            sock_ssl.sendall(payload)
+            loop.run_until_complete(asyncio.sleep(0.1))
 
-    assert peer_messages
-    assert peer_messages[0] == TLS_1_2
-    assert peer_address
-    assert peer_address[0] == IP_ADDR
+        async def _wait_for_peer_message() -> None:
+            """Wait for the worker to forward the TLS payload."""
+            for _ in range(100):
+                if peer_messages:
+                    return
+                await asyncio.sleep(0.1)
 
-    loop.call_soon_threadsafe(multiplexer.shutdown)
+        loop.run_until_complete(_wait_for_peer_message())
 
-    async def _wait_for_shutdown() -> None:
-        """Wait for shutdown."""
-        waiter = multiplexer.wait()
-        await waiter
+        assert peer_messages
+        assert peer_messages[0] == TLS_1_2
+        assert peer_address
+        assert peer_address[0] == IP_ADDR
 
-    loop.run_until_complete(_wait_for_shutdown())
-    time.sleep(1)
+        loop.call_soon_threadsafe(multiplexer.shutdown)
+        multiplexer_shutdown = True
 
-    assert not any(worker.is_responsible_peer(hostname) for worker in server._workers)
+        async def _wait_for_shutdown() -> None:
+            """Wait for shutdown."""
+            waiter = multiplexer.wait()
+            await waiter
 
-    sock_ssl.close()
-    server.stop()
+        loop.run_until_complete(_wait_for_shutdown())
+
+        time.sleep(1)
+
+        assert not any(
+            worker.is_responsible_peer(hostname) for worker in server._workers
+        )
+    finally:
+        if not multiplexer_shutdown:
+            loop.call_soon_threadsafe(multiplexer.shutdown)
+            loop.run_until_complete(multiplexer.wait())
+        sock_ssl.close()
+        server.stop()
 
 
 def test_snitun_worker_timeout(event_loop: asyncio.AbstractEventLoop) -> None:
