How to advance the swarm state before entering the main eventloop

[Frederik-Baetens]

Hi, so this eventloop, closely taken from one of the chat examples, advances the swarm state with the next calls. Currently in order to get the adresses printed, I need to first pass an empty line, so the select! macro is passed through twice. I assume this is necessary because the swarm.next() needs to be polled twice before the Swarm::listeners(&swarm) call returns any adresses.

    let mut listening = false;
    loop {
        if !listening {
            for addr in Swarm::listeners(&swarm) {
                println!("Listening on {:?}", addr);
                listening = true;
            }
        }
        let to_publish = {
            tokio::select! {
                line = stdin.next_line() => {
                    let line = line.unwrap().expect("stdin closed");
                    if line != "" {
                        dbg!(&line);
                        Some((gossipsub_topic.clone(), line))
                    } else {
                        println!("{}", line);
                        None
                    }
                }
                event = swarm.next() => {
                    // All events are handled by the `NetworkBehaviourEventProcess`es.
                    // I.e. the `swarm.next()` future drives the `Swarm` without ever
                    // terminating.
                    panic!("Unexpected event: {:?}", event);
                }
            }
        };
        if let Some((topic, line)) = to_publish {
            swarm.publish(topic.clone(), line.as_bytes()).unwrap();
        }
        println!("hi");
    }

But this is a clumsy way of doing this. Is there a way to advance the swarm state a bit beforehand? I tried manually polling it, but I'm not sure how to get that to work. Like so (but this doesn't seem to progress the swarm state so that the addresses become available):

while Swarm::listeners(&swarm).peekable().peek().is_none() {
    match future::poll_fn(|cx| Poll::Ready(Pin::new(&mut swarm).poll_next(cx))).await {
        Poll::Ready(_) => panic!(),
        Poll::Pending => (),
    };
    println!("hi");
    tokio::time::sleep(Duration::from_millis(100)).await;
}

[Frederik-Baetens]

This worked quite well for me:

    future::poll_fn(|cx| {
        if Swarm::listeners(&swarm).peekable().peek().is_some() {
            Poll::Ready(None)
        } else {
            Pin::new(&mut swarm).poll_next(cx)
        }
    }).await;

[mxinden]

I am not quite sure I understand your problem description.

In case you would like to only call swarm.publish once the swarm is listening, you could poll stdin only when listening is true.

Currently in order to get the adresses printed, I need to first pass an empty line, so the select! macro is passed through twice.

This sounds like a bug which I can not reproduce. The swarm.next should be able to progress despite the status of stdin.

[Frederik-Baetens]

The swarm.next is able to make progress, but it never finishes (which isn't a problem on its own) so the select! doesn't complete before the first stdin line is processed (because stdin is the only option which can actually finish), which results in the addresses not being printed, leaving me unable to connect to a second node in order to start publishing some messages.

In the tokio chat example, this is resolved by using automatic peer finding through mdns, but I wanted to throw that out, so I needed the adresses before processing my first line of input.

And as an aside, after some more testing I discovered that my while loop in the original question did work, albeit somewhat unreliably because just polling a future in a while loop generally isn't a good idea.