ci: update interop workflow

.github/workflows/interop-test.yml

@@ -1,32 +1,37 @@
 name: Interoperability Testing
-
 on:
   pull_request:
   push:
     branches:
-      - master
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
+      - "master"
 
 jobs:
-  # NOTE: during a pull request run, github creates a merge commit referenced in `github.sha`
-  # that merge commit is not a regular commit. You won't find it with a regular `git checkout SHA` and
-  # tools like `go get repo@SHA` won't find it.
-  #
-  # As a workaround, we generate a path to the actual pull request's commit, it looks like:
-  # `github.com/external-org/go-libp2p@latest-commit-on-their-branch`
-  run-ping-interop-cross-version:
-    uses: "libp2p/test-plans/.github/workflows/run-composition.yml@master"
-    with:
-      composition_file: "ping/_compositions/rust-cross-versions.toml"
-      custom_git_target: github.com/${{ github.event.pull_request.head.repo.full_name || github.event.repository.full_name }}
-      custom_git_reference: ${{ github.event.pull_request.head.sha || github.sha }}
-  run-ping-interop-cross-implementation:
-    uses: "libp2p/test-plans/.github/workflows/run-composition.yml@master"
+  build-ping-container:
+    name: Build Ping interop container
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: recursive
+      - name: Build image
+        working-directory: ./test-plans
+        run: make
+      - name: Upload ping versions info
+        uses: actions/upload-artifact@v3
+        with:
+          name: ping-versions
+          path: ./test-plans/ping-versions.json
+      - name: Upload image tar
+        uses: actions/upload-artifact@v3
+        with:
+          name: ping-image
+          path: ./test-plans/ping-image.tar
+  run-multidim-interop:
+    name: Run multidimensional interoperability tests
+    needs: build-ping-container
+    uses: "libp2p/test-plans/.github/workflows/run-testplans.yml@master"
     with:
-      composition_file: "ping/_compositions/all-interop-latest.toml"
-      custom_git_target: github.com/${{ github.event.pull_request.head.repo.full_name || github.event.repository.full_name }}
-      custom_git_reference: ${{ github.event.pull_request.head.sha || github.sha }}
-      custom_interop_target: rust
+      dir: "multidim-interop"
+      extra-versions: ping-versions
+      image-tar: ping-image
+      test-filter: "rust-libp2p-head"

test-plans/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+edition = "2021"
+name = "testcases"
+version = "0.1.0"
+
+# Required to avoid conflicts with parent workspace.
+[workspace]
+
+[dependencies]
+anyhow = "1"
+async-trait = "0.1.58"
+env_logger = "0.9.0"
+futures = "0.3.1"
+if-addrs = "0.7.0"
+log = "0.4"
+redis = { version = "0.22.1", features = ["tokio-native-tls-comp", "tokio-comp"] }
+tokio = { version = "1.24.1", features = ["full"] }
+
+libp2p = { path = "../", default_features = false, features = ["websocket", "quic",  "mplex", "yamux", "tcp", "tokio", "ping", "noise", "tls", "dns", "rsa", "macros", "webrtc"] }
+rand = "0.8.5"
+strum = { version = "0.24.1", features = ["derive"] }

test-plans/Dockerfile

@@ -0,0 +1,19 @@
+FROM rust:1.65-bullseye as builder
+WORKDIR /usr/src/libp2p
+
+# TODO fix this, it breaks reproducibility
+RUN apt-get update && apt-get install -y cmake protobuf-compiler
+
+COPY ./ ./
+
+RUN cd ./test-plans/ && cargo build  # Initial build acts as a cache.
+
+ARG BINARY_NAME
+RUN cd ./test-plans/ \
+    && cargo build --bin=${BINARY_NAME} \
+    && mv /usr/src/libp2p/test-plans/target/debug/${BINARY_NAME} /usr/local/bin/testplan
+
+FROM debian:bullseye-slim
+COPY --from=builder /usr/local/bin/testplan /usr/local/bin/testplan
+ENV RUST_BACKTRACE=1
+ENTRYPOINT ["testplan"]

test-plans/Makefile

@@ -0,0 +1,10 @@
+all: ping-image.tar
+
+ping-image.tar: Dockerfile Cargo.toml src
+	cd .. && docker build -t rust-libp2p-head -f test-plans/Dockerfile --build-arg BINARY_NAME=ping .
+	docker image save -o $@ rust-libp2p-head
+
+.PHONY: clean
+
+clean:
+	rm ping-image.tar

test-plans/README.md

@@ -0,0 +1,34 @@
+# test-plans test implementation
+
+This folder defines the implementation for the test-plans interop tests.
+
+# Running this test locally
+
+You can run this test locally by having a local Redis instance and by having
+another peer that this test can dial or listen for. For example to test that we
+can dial/listen for ourselves we can do the following:
+
+1. Start redis (needed by the tests): `docker run --rm -it -p 6379:6379
+   redis/redis-stack`.
+2. In one terminal run the dialer: `REDIS_ADDR=localhost:6379 ip="0.0.0.0"
+   transport=quic-v1 security=quic muxer=quic is_dialer="true" cargo run --bin ping`
+3. In another terminal, run the listener: `REDIS_ADDR=localhost:6379
+   ip="0.0.0.0" transport=quic-v1 security=quic muxer=quic is_dialer="false" cargo run --bin ping`
+
+
+To test the interop with other versions do something similar, except replace one
+of these nodes with the other version's interop test.
+
+# Running all interop tests locally with Compose
+
+To run this test against all released libp2p versions you'll need to have the
+(libp2p/test-plans)[https://github.com/libp2p/test-plans] checked out. Then do
+the following:
+
+1. Build the image: `make`.
+2. Build the images for all released versions in `libp2p/test-plans`: `(cd <path
+   to >/libp2p/test-plans/multidim-interop/ && make)`.
+3. Make a folder for the specified extra versions: `mkdir extra-versions && mv ping-versions.json extra-versions`
+4. Run the test:
+```
+RUST_LIBP2P_TEST_PLANS="$PWD"; (cd <path to >/libp2p/test-plans/multidim-interop/ && npm run test -- --extra-versions-dir=$RUST_LIBP2P_TEST_PLANS/extra-versions --name-filter="rust-libp2p-head")

test-plans/ping-versions.json

@@ -0,0 +1,20 @@
+[
+    {
+        "id": "rust-libp2p-head",
+        "containerImageID": "rust-libp2p-head",
+        "transports": [
+            "ws",
+            "tcp",
+            "quic-v1",
+            "webrtc"
+        ],
+        "secureChannels": [
+            "tls",
+            "noise"
+        ],
+        "muxers": [
+            "mplex",
+            "yamux"
+        ]
+    }
+]

test-plans/src/bin/ping.rs

@@ -0,0 +1,207 @@
+use std::collections::HashSet;
+use std::env;
+use std::time::Duration;
+
+use anyhow::{Context, Result};
+use async_trait::async_trait;
+use futures::{AsyncRead, AsyncWrite, StreamExt};
+use libp2p::core::muxing::StreamMuxerBox;
+use libp2p::core::transport::Boxed;
+use libp2p::core::upgrade::EitherUpgrade;
+use libp2p::swarm::{keep_alive, NetworkBehaviour, SwarmEvent};
+use libp2p::websocket::WsConfig;
+use libp2p::{
+    core, identity, mplex, noise, ping, webrtc, yamux, Multiaddr, PeerId, Swarm, Transport as _,
+};
+use testcases::{run_ping, Muxer, PingSwarm, SecProtocol, Transport};
+
+fn build_builder<T, C>(
+    builder: core::transport::upgrade::Builder<T>,
+    secure_channel_param: SecProtocol,
+    muxer_param: Muxer,
+    local_key: &identity::Keypair,
+) -> Boxed<(libp2p::PeerId, StreamMuxerBox)>
+where
+    T: libp2p::Transport<Output = C> + Send + Unpin + 'static,
+    <T as libp2p::Transport>::Error: Sync + Send + 'static,
+    <T as libp2p::Transport>::ListenerUpgrade: Send,
+    <T as libp2p::Transport>::Dial: Send,
+    C: AsyncRead + AsyncWrite + Send + Unpin + 'static,
+{
+    let mux_upgrade = match muxer_param {
+        Muxer::Yamux => EitherUpgrade::A(yamux::YamuxConfig::default()),
+        Muxer::Mplex => EitherUpgrade::B(mplex::MplexConfig::default()),
+    };
+
+    let timeout = Duration::from_secs(5);
+
+    match secure_channel_param {
+        SecProtocol::Noise => builder
+            .authenticate(noise::NoiseAuthenticated::xx(&local_key).unwrap())
+            .multiplex(mux_upgrade)
+            .timeout(timeout)
+            .boxed(),
+        SecProtocol::Tls => builder
+            .authenticate(libp2p::tls::Config::new(&local_key).unwrap())
+            .multiplex(mux_upgrade)
+            .timeout(timeout)
+            .boxed(),
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let local_key = identity::Keypair::generate_ed25519();
+    let local_peer_id = PeerId::from(local_key.public());
+
+    let transport_param: Transport =
+        testcases::from_env("transport").context("unsupported transport")?;
+
+    let ip = env::var("ip").context("ip environment variable is not set")?;
+
+    let is_dialer = env::var("is_dialer")
+        .unwrap_or("true".into())
+        .parse::<bool>()?;
+
+    let redis_addr = env::var("REDIS_ADDR")
+        .map(|addr| format!("redis://{addr}"))
+        .unwrap_or("redis://redis:6379".into());
+
+    let client = redis::Client::open(redis_addr).context("Could not connect to redis")?;
+
+    let (boxed_transport, local_addr) = match transport_param {
+        Transport::QuicV1 => {
+            let builder =
+                libp2p::quic::tokio::Transport::new(libp2p::quic::Config::new(&local_key))
+                    .map(|(p, c), _| (p, StreamMuxerBox::new(c)));
+            (builder.boxed(), format!("/ip4/{ip}/udp/0/quic-v1"))
+        }
+        Transport::Tcp => {
+            let builder = libp2p::tcp::tokio::Transport::new(libp2p::tcp::Config::new())
+                .upgrade(libp2p::core::upgrade::Version::V1Lazy);
+
+            let secure_channel_param: SecProtocol =
+                testcases::from_env("security").context("unsupported secure channel")?;
+
+            let muxer_param: Muxer =
+                testcases::from_env("muxer").context("unsupported multiplexer")?;
+
+            (
+                build_builder(builder, secure_channel_param, muxer_param, &local_key),
+                format!("/ip4/{ip}/tcp/0"),
+            )
+        }
+        Transport::Ws => {
+            let builder = WsConfig::new(libp2p::tcp::tokio::Transport::new(
+                libp2p::tcp::Config::new(),
+            ))
+            .upgrade(libp2p::core::upgrade::Version::V1Lazy);
+
+            let secure_channel_param: SecProtocol =
+                testcases::from_env("security").context("unsupported secure channel")?;
+
+            let muxer_param: Muxer =
+                testcases::from_env("muxer").context("unsupported multiplexer")?;
+
+            (
+                build_builder(builder, secure_channel_param, muxer_param, &local_key),
+                format!("/ip4/{ip}/tcp/0/ws"),
+            )
+        }
+        Transport::Webrtc => (
+            webrtc::tokio::Transport::new(
+                local_key,
+                webrtc::tokio::Certificate::generate(&mut rand::thread_rng())?,
+            )
+            .map(|(peer_id, conn), _| (peer_id, StreamMuxerBox::new(conn)))
+            .boxed(),
+            format!("/ip4/{ip}/udp/0/webrtc"),
+        ),
+    };
+
+    let swarm = OrphanRuleWorkaround(Swarm::with_tokio_executor(
+        boxed_transport,
+        Behaviour {
+            ping: ping::Behaviour::new(ping::Config::new().with_interval(Duration::from_secs(1))),
+            keep_alive: keep_alive::Behaviour,
+        },
+        local_peer_id,
+    ));
+
+    // Use peer id as a String so that `run_ping` does not depend on a specific libp2p version.
+    let local_peer_id = local_peer_id.to_string();
+    run_ping(client, swarm, &local_addr, &local_peer_id, is_dialer).await?;
+
+    Ok(())
+}
+
+#[derive(NetworkBehaviour)]
+struct Behaviour {
+    ping: ping::Behaviour,
+    keep_alive: keep_alive::Behaviour,
+}
+struct OrphanRuleWorkaround(Swarm<Behaviour>);
+
+#[async_trait]
+impl PingSwarm for OrphanRuleWorkaround {
+    async fn listen_on(&mut self, address: &str) -> Result<String> {
+        let id = self.0.listen_on(address.parse()?)?;
+
+        loop {
+            if let Some(SwarmEvent::NewListenAddr {
+                listener_id,
+                address,
+            }) = self.0.next().await
+            {
+                if address.to_string().contains("127.0.0.1") {
+                    continue;
+                }
+                if listener_id == id {
+                    return Ok(address.to_string());
+                }
+            }
+        }
+    }
+
+    fn dial(&mut self, address: &str) -> Result<()> {
+        self.0.dial(address.parse::<Multiaddr>()?)?;
+
+        Ok(())
+    }
+
+    async fn await_connections(&mut self, number: usize) {
+        let mut connected = HashSet::with_capacity(number);
+
+        while connected.len() < number {
+            if let Some(SwarmEvent::ConnectionEstablished { peer_id, .. }) = self.0.next().await {
+                connected.insert(peer_id);
+            }
+        }
+    }
+
+    async fn await_pings(&mut self, number: usize) -> Vec<Duration> {
+        let mut received_pings = Vec::with_capacity(number);
+
+        while received_pings.len() < number {
+            if let Some(SwarmEvent::Behaviour(BehaviourEvent::Ping(ping::Event {
+                peer: _,
+                result: Ok(ping::Success::Ping { rtt }),
+            }))) = self.0.next().await
+            {
+                received_pings.push(rtt);
+            }
+        }
+
+        received_pings
+    }
+
+    async fn loop_on_next(&mut self) {
+        loop {
+            self.0.next().await;
+        }
+    }
+
+    fn local_peer_id(&self) -> String {
+        self.0.local_peer_id().to_string()
+    }
+}