#data-channel #web-rtc #p2p #signaling-server #send-receive

wasm-peers

Easy-to-use wrapper for WebRTC DataChannels peer-to-peer connections written in Rust and compiling to WASM

5 releases

0.4.1 Oct 3, 2022
0.4.0 Mar 2, 2022
0.3.2 Feb 7, 2022
0.3.1 Feb 7, 2022
0.3.0 Feb 7, 2022

#293 in WebAssembly

37 downloads per month

MIT/Apache

81KB
1K SLoC

wasm-peers logo

wasm-peers

crates.io docs.rs CI coverage status APACHE licensed MIT licensed pre-commit

This crate provides an easy-to-use wrapper around WebRTC and DataChannels for a peer-to-peer connections.

Overview

As creator of agar.io famously stated WebRTC is hard. This library aims to help, by abstracting away all the setup, and providing a simple way to send and receive messages over the data channel.

It's as easy as providing address to a signaling server instance from accompanying crate and specifying two callbacks. One that specifies what should happen when a connection is established, and one for when a message is received. After that you can send messages back and forth without worrying about the implementation details.

Library contains three network topologies, one-to-one, which creates an equal connection between two peers, one-to-many, which specifies a host and arbitrary number of clients and many-to-many that creates connection for each pair of peers and allows sending messages to any of them.

For a "production ready" apps built with this library check out either Live Document or Footballers.

Example

This example shows two peers sending ping and pong messages to each other.

use wasm_peers::ConnectionType;
use wasm_peers::one_to_one::NetworkManager;
use web_sys::console;

// there must be a signaling server from accompanying crate running on this port
const SIGNALING_SERVER_URL: &str = "ws://0.0.0.0:9001/one-to-one";

fn main() {
    // there must be some mechanism for exchanging session ids between peers
    let session_id = SessionId::new("some-session-id".to_string());
    let mut peer1 = NetworkManager::new(
        SIGNALING_SERVER_URL,
        session_id.clone(),
        ConnectionType::Stun,
    ).unwrap();

    let peer1_clone = peer1.clone();
    let peer1_on_open = move || peer1_clone.send_message("ping!").unwrap();
    let peer1_on_message = {
        move |message| {
            console::log_1(&format!("peer1 received message: {}", message).into());
        }
    };
    peer1.start(peer1_on_open, peer1_on_message).unwrap();

    let mut peer2 = NetworkManager::new(
        SIGNALING_SERVER_URL,
        session_id,
        ConnectionType::Stun,
    ).unwrap();
    let peer2_on_open = || { /* do nothing */ };
    let peer2_clone = peer2.clone();
    let peer2_on_message = {
        let peer2_received_message = peer2_received_message.clone();
        move |message| {
            console::log_1(&format!("peer2 received message: {}", message).into());
            peer2_clone.send_message("pong!").unwrap();
        }
    };
    peer2.start(peer2_on_open, peer2_on_message).unwrap();
}

For examples of other topologies check out the docs.

Roadmap

  • Add tests
  • Improve error handling
  • Introduce alternative API with futures
  • Add possibility to pass video/audio streams over established connection

Version History

  • 0.4
    • MiniServer callbacks don't accept UserId argument now (it'd always be hosts)
    • Fix documentation tests so that they compile
  • 0.3
    • Initial release to the public

Similar projects

License

This project is licensed under either of

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

Authors

Tomasz Karwowski LinkedIn

Acknowledgments

These projects helped me grasp WebRTC in Rust:

Also, special thanks to the guys with whom I did my B.Eng. thesis.

Dependencies

~8–11MB
~197K SLoC