is the swarm the only way to publish and listen for incoming messages

[revoltez]

from what i understand, the swarm is the way to go in order to publish and listen for incoming messages.

I have created a simple struct that contains a field that needs to be accessed by two threads, so I put it behind a Arc and Mutex:

pub struct GossipTest {
    swarm: Arc<Mutex<Swarm<Gossipsub>>>,
}

The first function listen(), needs to lock on the swarm field and call select_next_some() which returns a Future that resolves when the next item in this stream is ready. Which means it keeps holding the lock on that field.

pub async fn listen(swarm: Arc<Mutex<Swarm<Gossipsub>>>, addr: Multiaddr) {
    let addr = swarm.lock().await.listen_on(addr).unwrap();
    loop {
        match swarm.lock().await.select_next_some().await {
            SwarmEvent::NewListenAddr { address, .. } => println!("Listening on {:?}", address),
            SwarmEvent::Behaviour(event) => println!("{:?}", event),
            _ => {}
        }
        tokio::time::sleep(Duration::from_millis(500)).await;
    }
}

But I need to access and lock that Mutex in another method, I need to use the same field to send messages and receive messages at the same time:

pub async fn test() {
    let test_gossip = StreamsGossip::new().await;
    let swarm_clone = test_gossip.swarm.clone();

    tokio::spawn(async {
        TestGossip::listen(swarm_clone, self_addr).await;
    });
    loop {
        //second lock here
        test_gossip
            .swarm
            .lock()
            .await
            .behaviour_mut()
            .publish(topic, message)
            .ok();
        tokio::time::sleep(Duration::from_millis(5000)).await;
    }
}

Are there any ways to listen for messages and publishing them using the swarm at the same time? Or am I using a bad way to publish and listen for messages at the same time?

[elenaf9]

Hi @revoltez,
examples/file-sharing.rs might be helpful here. It showcases an alternative architecture for driving and accessing a swarm in a larger application, without a Mutex.
The basic idea there is that the swarm is polled in an event-loop running in a background task, and actions are performed by sending commands via a mpsc channel to this background task. The event-loop performs actions on the swarm accordingly, and returns their result in a one-shot channel once they resolved. This allows to trigger multiple async actions in parallel from multiple threads, since each thread can simply hold one copy of the mpsc::Sender.
Let me know if this helps. 🙂

[revoltez]

someone else suggested the same solution which makes it the best, thanks it helps a lot