Feat: Adding Yamux as default multiplexer, keeping Mplex as fallback (#538)

* feat: Replace mplex with yamux as default multiplexer in py-libp2p

* Retain Mplex alongside Yamux in new_swarm with messaging that Yamux is preferred

* moved !BBHII to a constant YAMUX_HEADER_FORMAT at the top of yamux.py with a comment explaining its structure

* renamed the news fragment to 534.feature.rst and updated the description

* renamed the news fragment to 534.feature.rst and updated the description

* added a docstring to clarify that Yamux does not support deadlines natively

* Remove the __main__ block entirely from test_yamux.py

* Replaced the print statements in test_yamux.py with logging.debug

* Added a comment linking to the spec for clarity

* Raise NotImplementedError in YamuxStream.set_deadline per review

* Add muxed_conn to YamuxStream and test deadline NotImplementedError

* Fix Yamux implementation to meet libp2p spec

* Fix None handling in YamuxStream.read and Yamux.read_stream

* Fix test_connected_peers.py to correctly handle peer connections

* fix: Ensure StreamReset is raised on read after local reset in yamux

* fix: Map MuxedStreamError to StreamClosed in NetStream.write for Yamux

* fix: Raise MuxedStreamReset in Yamux.read_stream for closed streams

* fix: Correct Yamux stream read behavior for NetStream tests

Fixed 	est_net_stream_read_after_remote_closed by updating NetStream.read to raise StreamEOF when the stream is remotely closed and no data is available, aligning with test expectations and Fixed 	est_net_stream_read_until_eof by modifying YamuxStream.read to block until the stream is closed (
ecv_closed=True) for
=-1 reads, ensuring data is only returned after remote closure.

* fix: Correct Yamux stream read behavior for NetStream tests

Fixed 	est_net_stream_read_after_remote_closed by updating NetStream.read to raise StreamEOF when the stream is remotely closed and no data is available, aligning with test expectations and Fixed 	est_net_stream_read_until_eof by modifying YamuxStream.read to block until the stream is closed (
ecv_closed=True) for
=-1 reads, ensuring data is only returned after remote closure.

* fix: raise StreamEOF when reading from closed stream with empty buffer

* fix: prioritize returning buffered data even after stream reset

* fix: prioritize returning buffered data even after stream reset

* fix: Ensure test_net_stream_read_after_remote_closed_and_reset passes in full suite

* fix: Add __init__.py to yamux module to fix documentation build

* fix: Add __init__.py to yamux module to fix documentation build

* fix: Add libp2p.stream_muxer.yamux to libp2p.stream_muxer.rst toctree

* fix: Correct title underline length in libp2p.stream_muxer.yamux.rst

* fix: Add a = so that is matches the libp2p.stream\_muxer.yamux length

* fix(tests): Resolve race condition in network notification test

* fix: fixing failing tests and examples with yamux and noise

* refactor: remove debug logging and improve x25519 tests

* fix: Add functionality for users to choose between Yamux and Mplex

* fix: increased trio sleep to 0.1 sec for slow environment

* feat: Add test for switching between Yamux and mplex

* refactor: move host fixtures to interop tests

* chore: Update __init__.py removing unused import

removed unused
```python
import os
import logging
```

* lint: fix import order

* fix: Resolve conftest.py conflict by removing trio test support

* fix: Resolve test skipping by keeping trio test support

* Fix: add a newline at end of the file

---------

Co-authored-by: acul71 <luca.pisani@birdo.net>
Co-authored-by: acul71 <34693171+acul71@users.noreply.github.com>

libp2p/network/connection/swarm_connection.py

@@ -1,3 +1,4 @@
+import logging
 from typing import (
     TYPE_CHECKING,
 )
@@ -37,30 +38,69 @@ class SwarmConn(INetConn):
         self.streams = set()
         self.event_closed = trio.Event()
         self.event_started = trio.Event()
+        if hasattr(muxed_conn, "on_close"):
+            logging.debug(f"Setting on_close for peer {muxed_conn.peer_id}")
+            muxed_conn.on_close = self._on_muxed_conn_closed
+        else:
+            logging.error(
+                f"muxed_conn for peer {muxed_conn.peer_id} has no on_close attribute"
+            )
 
     @property
     def is_closed(self) -> bool:
         return self.event_closed.is_set()
 
+    async def _on_muxed_conn_closed(self) -> None:
+        """Handle closure of the underlying muxed connection."""
+        peer_id = self.muxed_conn.peer_id
+        logging.debug(f"SwarmConn closing for peer {peer_id} due to muxed_conn closure")
+        # Only call close if we're not already closing
+        if not self.event_closed.is_set():
+            await self.close()
+
     async def close(self) -> None:
         if self.event_closed.is_set():
             return
+        logging.debug(f"Closing SwarmConn for peer {self.muxed_conn.peer_id}")
         self.event_closed.set()
+
+        # Close the muxed connection
+        try:
+            await self.muxed_conn.close()
+        except Exception as e:
+            logging.warning(f"Error while closing muxed connection: {e}")
+
+        # Perform proper cleanup of resources
         await self._cleanup()
 
     async def _cleanup(self) -> None:
+        # Remove the connection from swarm
+        logging.debug(f"Removing connection for peer {self.muxed_conn.peer_id}")
         self.swarm.remove_conn(self)
 
-        await self.muxed_conn.close()
+        # Only close the connection if it's not already closed
+        # Be defensive here to avoid exceptions during cleanup
+        try:
+            if not self.muxed_conn.is_closed:
+                await self.muxed_conn.close()
+        except Exception as e:
+            logging.warning(f"Error closing muxed connection: {e}")
 
         # This is just for cleaning up state. The connection has already been closed.
         # We *could* optimize this but it really isn't worth it.
+        logging.debug(f"Resetting streams for peer {self.muxed_conn.peer_id}")
         for stream in self.streams.copy():
-            await stream.reset()
+            try:
+                await stream.reset()
+            except Exception as e:
+                logging.warning(f"Error resetting stream: {e}")
+
         # Force context switch for stream handlers to process the stream reset event we
         # just emit before we cancel the stream handler tasks.
         await trio.sleep(0.1)
 
+        # Notify all listeners about the disconnection
+        logging.debug(f"Notifying disconnection for peer {self.muxed_conn.peer_id}")
         await self._notify_disconnected()
 
     async def _handle_new_streams(self) -> None:

libp2p/network/stream/net_stream.py

@@ -12,6 +12,7 @@ from libp2p.custom_types import (
 from libp2p.stream_muxer.exceptions import (
     MuxedStreamClosed,
     MuxedStreamEOF,
+    MuxedStreamError,
     MuxedStreamReset,
 )
 
@@ -68,7 +69,7 @@ class NetStream(INetStream):
         """
         try:
             await self.muxed_stream.write(data)
-        except MuxedStreamClosed as error:
+        except (MuxedStreamClosed, MuxedStreamError) as error:
             raise StreamClosed() from error
 
     async def close(self) -> None:

libp2p/network/swarm.py

@@ -313,7 +313,35 @@ class Swarm(Service, INetworkService):
         return False
 
     async def close(self) -> None:
-        await self.manager.stop()
+        """
+        Close the swarm instance and cleanup resources.
+        """
+        # Check if manager exists before trying to stop it
+        if hasattr(self, "_manager") and self._manager is not None:
+            await self._manager.stop()
+        else:
+            # Perform alternative cleanup if the manager isn't initialized
+            # Close all connections manually
+            if hasattr(self, "connections"):
+                for conn_id in list(self.connections.keys()):
+                    conn = self.connections[conn_id]
+                    await conn.close()
+
+                # Clear connection tracking dictionary
+                self.connections.clear()
+
+            # Close all listeners
+            if hasattr(self, "listeners"):
+                for listener in self.listeners.values():
+                    await listener.close()
+                self.listeners.clear()
+
+            # Close the transport if it exists and has a close method
+            if hasattr(self, "transport") and self.transport is not None:
+                # Check if transport has close method before calling it
+                if hasattr(self.transport, "close"):
+                    await self.transport.close()
+
         logger.debug("swarm successfully closed")
 
     async def close_peer(self, peer_id: ID) -> None: