Cannot use nested #[derive(NetworkBehaviour)]

[xu-cheng]

Below is an example to reproduce this bug. Here there are two structures that derive NetworkBehaviour in a nested fashion.

src/main.rs

use anyhow::Result;
use futures::{future::poll_fn, prelude::*};
use libp2p::{
    identity::Keypair,
    ping::{Ping, PingConfig, PingEvent},
    swarm::{
        NetworkBehaviourAction, NetworkBehaviourEventProcess, PollParameters, Swarm, SwarmEvent,
    },
    NetworkBehaviour, PeerId,
};
use std::{
    collections::VecDeque,
    task::{Context, Poll},
};

#[derive(Default)]
struct FooEvent;

#[derive(NetworkBehaviour)]
#[behaviour(poll_method = "poll", out_event = "FooEvent")]
struct Foo {
    ping: Ping,
    #[behaviour(ignore)]
    events: VecDeque<FooEvent>,
}

impl NetworkBehaviourEventProcess<PingEvent> for Foo {
    fn inject_event(&mut self, event: PingEvent) {
        println!("recv ping {:?}", event);
        self.events.push_back(FooEvent::default());
    }
}

impl Foo {
    fn new() -> Self {
        Self {
            ping: Ping::new(PingConfig::new().with_keep_alive(true)),
            events: VecDeque::new(),
        }
    }
    fn poll<T>(
        &mut self,
        _: &mut Context,
        _: &mut impl PollParameters,
    ) -> Poll<NetworkBehaviourAction<T, FooEvent>> {
        if let Some(event) = self.events.pop_front() {
            return Poll::Ready(NetworkBehaviourAction::GenerateEvent(event));
        }

        Poll::Pending
    }
}

#[derive(NetworkBehaviour)]
struct Bar {
    foo: Foo,
}

impl NetworkBehaviourEventProcess<FooEvent> for Bar {
    fn inject_event(&mut self, _: FooEvent) {
        println!("recv foo event");
    }
}

impl Bar {
    fn new() -> Self {
        Self { foo: Foo::new() }
    }
}

#[tokio::main]
async fn main() -> Result<()> {
    let key1 = Keypair::generate_ed25519();
    let key2 = Keypair::generate_ed25519();
    let peer1 = PeerId::from(key1.public());
    let peer2 = PeerId::from(key2.public());

    let transport1 = libp2p::build_development_transport(key1)?;
    let transport2 = libp2p::build_development_transport(key2)?;

    let mut swarm1 = Swarm::new(transport1, Bar::new(), peer1);
    let mut swarm2 = Swarm::new(transport2, Bar::new(), peer2);

    Swarm::listen_on(&mut swarm1, "/ip4/127.0.0.1/tcp/0".parse()?)?;
    let address1 = loop {
        match swarm1.next_event().await {
            SwarmEvent::NewListenAddr(address) => break address,
            _ => {}
        }
    };
    println!("swarm1 listen on {}", address1);
    Swarm::dial_addr(&mut swarm2, address1)?;

    let _ = tokio::spawn(poll_fn(move |cx| {
        loop {
            match swarm1.poll_next_unpin(cx) {
                Poll::Ready(_) => {}
                Poll::Pending => break,
            }
        }

        Poll::<()>::Pending
    }));
    let _ = tokio::spawn(poll_fn(move |cx| {
        loop {
            match swarm2.poll_next_unpin(cx) {
                Poll::Ready(_) => {}
                Poll::Pending => break,
            }
        }

        Poll::<()>::Pending
    }));

    tokio::time::delay_for(tokio::time::Duration::from_secs(5)).await;

    Ok(())
}

Cargo.toml

[package]
name = "debug-p2p"
version = "0.1.0"
authors = ["Cheng XU <rust@xuc.me>"]
edition = "2018"
publish = false

[dependencies]
libp2p = "*"
futures = "*"
tokio = { version = "*", features = ["full"] }
anyhow = "*"

Running the above example, we get the following output, which means that neither of the inject_event function is called.

swarm1 listen on /ip4/127.0.0.1/tcp/54121

If we change the swarm to use Foo directly, that is:

- let mut swarm1 = Swarm::new(transport1, Bar::new(), peer1);
- let mut swarm2 = Swarm::new(transport2, Bar::new(), peer2);
+ let mut swarm1 = Swarm::new(transport1, Foo::new(), peer1);
+ let mut swarm2 = Swarm::new(transport2, Foo::new(), peer2);

We got the normal behaviour:

swarm1 listen on /ip4/127.0.0.1/tcp/55298
recv ping PingEvent { peer: PeerId("12D3KooWBQVD7UYtqd8hT38CjSAV7FTsJbEkyUveLyNedN7WfKEM"), result: Ok(Pong) }
recv ping PingEvent { peer: PeerId("12D3KooWPmpQJwavtw8nPQFkBniMYeWdKatXm1bjoctYd55T7xgi"), result: Ok(Ping { rtt: 1.421545ms }) }
recv ping PingEvent { peer: PeerId("12D3KooWPmpQJwavtw8nPQFkBniMYeWdKatXm1bjoctYd55T7xgi"), result: Ok(Pong) }
recv ping PingEvent { peer: PeerId("12D3KooWBQVD7UYtqd8hT38CjSAV7FTsJbEkyUveLyNedN7WfKEM"), result: Ok(Ping { rtt: 1.580406ms }) }

[thomaseizinger]

Not sure if it solves the problem, but you might be interested in the event_process = false attribute: https://docs.rs/libp2p/0.22.0/libp2p/swarm/trait.NetworkBehaviour.html#deriving-networkbehaviour

[xu-cheng]

I found out what is the wrong. #1681 should fix it.