fix: Remove circular dependencies across workspace (#3023)

Circular dependencies are problematic in several ways:

- They result in cognitive overhead for developers, in trying to figure out what depends on what.
- They present `cargo` with limits in what order the crates can be compiled in.
- They invalidate build caches unnecessarily thus forcing `cargo` to rebuild certain crates.
- They cause problems with tooling such as `release-please`.

To actually break the circular dependencies, this patch inlines the uses of `development_transport` in the examples and tests for all sub-crates. This is only meant to be a short-term fix until https://github.com/libp2p/rust-libp2p/issues/3111 and https://github.com/libp2p/rust-libp2p/pull/2888 are fixed.

To ensure we don't accidentally reintroduce this dependency, we add a basic CI that queries `cargo metadata` using `jq`.

Resolves https://github.com/libp2p/rust-libp2p/issues/3053.
Fixes https://github.com/libp2p/rust-libp2p/issues/3223.
Related: https://github.com/libp2p/rust-libp2p/pull/2918#discussion_r976514245
Related: https://github.com/googleapis/release-please/issues/1662

protocols/mdns/Cargo.toml

@@ -32,10 +32,12 @@ async-io = ["dep:async-io", "if-watch/smol"]
 [dev-dependencies]
 async-std = { version = "1.9.0", features = ["attributes"] }
 env_logger = "0.10.0"
-libp2p = { path = "../..", features = ["full"] }
+libp2p-noise = { path = "../../transports/noise" }
+libp2p-swarm = { path = "../../swarm", features = ["tokio", "async-std"] }
+libp2p-tcp = { path = "../../transports/tcp", features = ["tokio", "async-io"] }
+libp2p-yamux = { path = "../../muxers/yamux" }
 tokio = { version = "1.19", default-features = false, features = ["macros", "rt", "rt-multi-thread", "time"] }
 
-
 [[test]]
 name = "use-async-std"
 required-features = ["async-io"]

protocols/mdns/src/behaviour/timer.rs

@@ -20,18 +20,17 @@
 
 use std::{
     marker::Unpin,
-    pin::Pin,
-    task::{Context, Poll},
     time::{Duration, Instant},
 };
 
-/// Simple wrapper for the differents type of timers
+/// Simple wrapper for the different type of timers
 #[derive(Debug)]
+#[cfg(any(feature = "async-io", feature = "tokio"))]
 pub struct Timer<T> {
     inner: T,
 }
 
-/// Builder interface to homogenize the differents implementations
+/// Builder interface to homogenize the different implementations
 pub trait Builder: Send + Unpin + 'static {
     /// Creates a timer that emits an event once at the given time instant.
     fn at(instant: Instant) -> Self;
@@ -48,6 +47,10 @@ pub mod asio {
     use super::*;
     use async_io::Timer as AsioTimer;
     use futures::Stream;
+    use std::{
+        pin::Pin,
+        task::{Context, Poll},
+    };
 
     /// Async Timer
     pub type AsyncTimer = Timer<AsioTimer>;
@@ -86,6 +89,10 @@ pub mod tokio {
     use super::*;
     use ::tokio::time::{self, Instant as TokioInstant, Interval, MissedTickBehavior};
     use futures::Stream;
+    use std::{
+        pin::Pin,
+        task::{Context, Poll},
+    };
 
     /// Tokio wrapper
     pub type TokioTimer = Timer<Interval>;

protocols/mdns/tests/use-async-std.rs

@@ -19,12 +19,10 @@
 // DEALINGS IN THE SOFTWARE.use futures::StreamExt;
 
 use futures::StreamExt;
-use libp2p::{
-    identity,
-    mdns::{async_io::Behaviour, Config, Event},
-    swarm::{Swarm, SwarmEvent},
-    PeerId,
-};
+use libp2p_core::{identity, upgrade::Version, PeerId, Transport};
+use libp2p_mdns::Event;
+use libp2p_mdns::{async_io::Behaviour, Config};
+use libp2p_swarm::{Swarm, SwarmEvent};
 use std::error::Error;
 use std::time::Duration;
 
@@ -60,7 +58,11 @@ async fn test_expired_async_std() -> Result<(), Box<dyn Error>> {
 async fn create_swarm(config: Config) -> Result<Swarm<Behaviour>, Box<dyn Error>> {
     let id_keys = identity::Keypair::generate_ed25519();
     let peer_id = PeerId::from(id_keys.public());
-    let transport = libp2p::development_transport(id_keys).await?;
+    let transport = libp2p_tcp::async_io::Transport::default()
+        .upgrade(Version::V1)
+        .authenticate(libp2p_noise::NoiseAuthenticated::xx(&id_keys).unwrap())
+        .multiplex(libp2p_yamux::YamuxConfig::default())
+        .boxed();
     let behaviour = Behaviour::new(config)?;
     let mut swarm = Swarm::with_async_std_executor(transport, behaviour, peer_id);
     swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse()?)?;

protocols/mdns/tests/use-tokio.rs

@@ -18,12 +18,10 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.use futures::StreamExt;
 use futures::StreamExt;
-use libp2p::{
-    identity,
-    mdns::{tokio::Behaviour, Config, Event},
-    swarm::{Swarm, SwarmEvent},
-    PeerId,
-};
+use libp2p_core::{identity, upgrade::Version, PeerId, Transport};
+use libp2p_mdns::{tokio::Behaviour, Config, Event};
+use libp2p_swarm::Swarm;
+use libp2p_swarm::SwarmEvent;
 use std::error::Error;
 use std::time::Duration;
 
@@ -56,7 +54,11 @@ async fn test_expired_tokio() -> Result<(), Box<dyn Error>> {
 async fn create_swarm(config: Config) -> Result<Swarm<Behaviour>, Box<dyn Error>> {
     let id_keys = identity::Keypair::generate_ed25519();
     let peer_id = PeerId::from(id_keys.public());
-    let transport = libp2p::tokio_development_transport(id_keys)?;
+    let transport = libp2p_tcp::tokio::Transport::default()
+        .upgrade(Version::V1)
+        .authenticate(libp2p_noise::NoiseAuthenticated::xx(&id_keys).unwrap())
+        .multiplex(libp2p_yamux::YamuxConfig::default())
+        .boxed();
     let behaviour = Behaviour::new(config)?;
     let mut swarm = Swarm::with_tokio_executor(transport, behaviour, peer_id);
     swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse()?)?;