swarm with ffi

[blackshadowsoftwareltd]

I am working with FFI. I created a function to run libp2p via FFI. everything is working perfectly.
suppose. my main FFI function(rust) is running and listening to events of the libp2p.

now I need to send a message to a peer via another FFI function(rust).
but as the requirement of the package I need Swarm to send a message. how can I get this Swarm which has been created in the main FFI (rust) function?

[thomaseizinger]

I am guessing your first FFI function spawns some kind of thread that drives the swarm with an event loop?

I'd create channels to send data in and out of this loop.

From your first FFI function, I'd return some opaque handle type that needs to be passed in on the other functions again. (This is typical for FFI and not specific to libp2p).

On the Rust side, you can then use that handle to associate the ends of the channel with them and send data into them to the Swarm.

[canewsin]

@blackshadowsoftwareltd you can look into this repo I made where FFI target is dart lang
https://github.com/decentnetwork/decentnet/blob/master/src/api/common.rs

[thomaseizinger]

I'd recommend to restructure your code such that you have a single event loop that:

• polls a channel for incoming messages
• polls the swarm for events

You can then create FFI functions to send messages into that channel.

You should always continuously poll the swarm otherwise anything on the network will not make progress. Think of Swarm like a Future. It is lazy and will not do work unless polled.

See the file-sharing example for details.

[blackshadowsoftwareltd]

pub type EventStreamCallback = extern "C" fn(*const u8, usize);

#[no_mangle]
pub extern "C" fn **run_peer_2_peer**(callback: EventStreamCallback) {
    let rt = Runtime::new().unwrap();
    let result = rt.block_on(run_p2p(callback));

    match result {
        Ok(()) => CString::new("====================").unwrap(),
        Err(e) => CString::new(format!("\n Rust Error: {}", e)).unwrap(),
    };
}

pub async fn run_p2p(callback: EventStreamCallback) -> Result<(), Box<dyn Error>> {
    // read_as_buff().await;
    let (local_peer_id, trns, behaviour, topic) = configure_swarm()?;
    let mut swarm = SwarmBuilder::with_async_std_executor(trns, behaviour, local_peer_id).build();

    swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse()?)?;

    println!("Enter messages via STDIN and they will be sent to connected peers using Gossipsub");
    listen_event(callback, &mut swarm, &topic, &local_peer_id).await;
    Ok(())
}

pub fn configure_swarm() -> Result<
    (
        PeerId,
        Boxed<(PeerId, StreamMuxerBox)>,
        MyBehaviour,
        IdentTopic,
    ),
    Box<dyn Error>,
> {
    let id_keys = identity::Keypair::generate_ed25519();
    let local_peer_id = PeerId::from(id_keys.public());
    println!("Local PeerID: {}", local_peer_id);

    let noise_config = noise::Config::new(&id_keys)?;
    let trns = tcp::async_io::Transport::default()
        .upgrade(Version::V1)
        .authenticate(noise_config)
        .multiplex(yamux::Config::default())
        .boxed();

    let message_id_fn = |message: &gossipsub::Message| {
        let mut s = DefaultHasher::new();
        message.data.hash(&mut s);
        gossipsub::MessageId::from(s.finish().to_string())
    };

    let gossipsub_config = gossipsub::ConfigBuilder::default()
        .heartbeat_interval(Duration::from_secs(1))
        .validation_mode(gossipsub::ValidationMode::Strict)
        .message_id_fn(message_id_fn)
        .build()?;

    let mut gossipsub = gossipsub::Behaviour::new(
        gossipsub::MessageAuthenticity::Signed(id_keys),
        gossipsub_config,
    )?;
    let topic = gossipsub::IdentTopic::new("test-net");
    gossipsub.subscribe(&topic)?;

    let mdns = mdns::async_io::Behaviour::new(mdns::Config::default(), local_peer_id)?;
    let behaviour = MyBehaviour { gossipsub, mdns };

    Ok((local_peer_id, trns, behaviour, topic))
}

method ### run_peer_2_peer is my ffi function.
method ### listen_event listen to all events of libp2p (like the package example, taking input from the terminal). and when I receive any message I return back to my dart function via callback. It's working perfectly (when I send text message terminal to rust ffi function).
now I wanna send a message dart function to the rust ffi function. then rust function will be sent via libp2p.
but the problem is I can start ffi rust function for the one time to start the libp2p connection. now how can I send a message after the connection is established?
Thank you so much for giving time.

[thomaseizinger]

My advice from above still stands:

I'd recommend to restructure your code such that you have a single event loop that:

• polls a channel for incoming messages
• polls the swarm for events

You can then create FFI functions to send messages into that channel.

You should extend your listen_event function to also poll the receiver-end of a channel. You can store the sender-end in a static variable like you do with some of the other state.

You can then create an FFI function that accesses that Sender and sends the parameters as a message into it. The message will be received by the Receiver within the event-loop where you can pass it to the Swarm.

See https://github.com/libp2p/rust-libp2p/blob/master/examples/file-sharing/src/network.rs.