Skip to content

Commit

Permalink
docs(all): add more examples to the API docs
Browse files Browse the repository at this point in the history
  • Loading branch information
@lionel-faber
lionel-faber committed Sep 9, 2020
1 parent f38288d commit 3f1db6e
Show file tree
Hide file tree
Showing 2 changed files with 82 additions and 34 deletions.
68 changes: 37 additions & 31 deletions src/api.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -80,7 +80,7 @@ impl QuicP2p {
/// # Example
///
/// ```
/// use quic_p2p::QuicP2p;
/// use qp2p::QuicP2p;
///
/// let quic_p2p = QuicP2p::new().expect("Error initializing QuicP2p");
/// ```
Expand All @@ -100,7 +100,7 @@ impl QuicP2p {
/// # Example
///
/// ```
/// use quic_p2p::{QuicP2p, Config};
/// use qp2p::{QuicP2p, Config};
/// use std::net::{IpAddr, Ipv4Addr, SocketAddr};
///
/// let mut config = Config::default();
Expand Down Expand Up @@ -177,22 +177,24 @@ impl QuicP2p {
/// # Example
///
/// ```
/// #[tokio::main]
/// async fn main() {
/// use quic_p2p::{QuicP2p, Config};
/// use qp2p::{QuicP2p, Config, Error};
/// use std::net::{IpAddr, Ipv4Addr, SocketAddr};
///
/// let mut config = Config::default();
/// config.ip = Some(IpAddr::V4(Ipv4Addr::LOCALHOST));
/// config.port = Some(3000);
/// let mut quic_p2p = QuicP2p::with_config(Some(config.clone()), Default::default(), true).expect("Error initializing QuicP2p");
/// let endpoint = quic_p2p.new_endpoint().expect("Error creating new endpoint");
/// let peer_addr = endpoint.local_address();
/// #[tokio::main]
/// async fn main() -> Result<(), Error> {
///
/// let mut config = Config::default();
/// config.ip = Some(IpAddr::V4(Ipv4Addr::LOCALHOST));
/// config.port = Some(3000);
/// let mut quic_p2p = QuicP2p::with_config(Some(config.clone()), Default::default(), true)?;
/// let endpoint = quic_p2p.new_endpoint()?;
/// let peer_addr = endpoint.local_address();
///
/// config.port = Some(3001);
/// let hcc = vec![peer_addr];
/// let mut quic_p2p = QuicP2p::with_config(Some(config), hcc.into(), true).expect("Error initializing QuicP2p");
/// let (endpoint, connection) = quic_p2p.bootstrap().await.expect("Error while bootstrapping");
/// config.port = Some(3001);
/// let hcc = vec![peer_addr];
/// let mut quic_p2p = QuicP2p::with_config(Some(config), hcc.into(), true)?;
/// let (endpoint, connection) = quic_p2p.bootstrap().await?;
/// Ok(())
/// }
/// ```
pub async fn bootstrap(&mut self) -> Result<(Endpoint, Connection)> {
Expand Down Expand Up @@ -242,18 +244,20 @@ impl QuicP2p {
/// # Example
///
/// ```
/// #[tokio::main]
/// async fn main() {
/// use quic_p2p::{QuicP2p, Config};
/// use qp2p::{QuicP2p, Config, Error};
/// use std::net::{IpAddr, Ipv4Addr, SocketAddr};
///
/// let mut config = Config::default();
/// config.ip = Some(IpAddr::V4(Ipv4Addr::LOCALHOST));
/// let mut quic_p2p = QuicP2p::with_config(Some(config.clone()), Default::default(), true).expect("Error initializing QuicP2p");
/// let peer_1 = quic_p2p.new_endpoint().expect("Error creating new endpoint");
/// let peer1_addr = peer_1.local_address();
/// #[tokio::main]
/// async fn main() -> Result<(), Error> {
///
/// let (peer_2, connection) = quic_p2p.connect_to(&peer1_addr).await.expect("Error when creating connection");
/// let mut config = Config::default();
/// config.ip = Some(IpAddr::V4(Ipv4Addr::LOCALHOST));
/// let mut quic_p2p = QuicP2p::with_config(Some(config.clone()), Default::default(), true)?;
/// let peer_1 = quic_p2p.new_endpoint()?;
/// let peer1_addr = peer_1.local_address();
///
/// let (peer_2, connection) = quic_p2p.connect_to(&peer1_addr).await?;
/// Ok(())
/// }
/// ```
pub async fn connect_to(&mut self, node_addr: &SocketAddr) -> Result<(Endpoint, Connection)> {
Expand All @@ -273,15 +277,17 @@ impl QuicP2p {
/// # Example
///
/// ```
/// #[tokio::main]
/// async fn main() {
/// use quic_p2p::{QuicP2p, Config};
/// use qp2p::{QuicP2p, Config, Error};
/// use std::net::{IpAddr, Ipv4Addr, SocketAddr};
/// #[tokio::main]
/// async fn main() -> Result<(), Error> {
///
/// let mut config = Config::default();
/// config.ip = Some(IpAddr::V4(Ipv4Addr::LOCALHOST));
/// let mut quic_p2p = QuicP2p::with_config(Some(config.clone()), Default::default(), true).expect("Error initializing QuicP2p");
/// let endpoint = quic_p2p.new_endpoint().expect("Error creating new endpoint");
/// let mut config = Config::default();
/// config.ip = Some(IpAddr::V4(Ipv4Addr::LOCALHOST));
/// let mut quic_p2p = QuicP2p::with_config(Some(config.clone()), Default::default(), true)?;
/// let endpoint = quic_p2p.new_endpoint()?;
/// Ok(())
/// }
/// ```
pub fn new_endpoint(&self) -> Result<Endpoint> {
trace!("Creating a new enpoint");
Expand Down
48 changes: 45 additions & 3 deletions src/connections.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -34,19 +34,61 @@ impl Connection {
Ok(Self { quic_conn })
}

/// Remote address
/// Returns the address of the connected peer.
///
/// # Example
///
/// ```
/// use qp2p::{QuicP2p, Config, Error};
/// use std::net::{IpAddr, Ipv4Addr, SocketAddr};
///
/// #[tokio::main]
/// async fn main() -> Result<(), Error> {
///
/// let mut config = Config::default();
/// config.ip = Some(IpAddr::V4(Ipv4Addr::LOCALHOST));
/// let mut quic_p2p = QuicP2p::with_config(Some(config.clone()), Default::default(), true)?;
/// let peer_1 = quic_p2p.new_endpoint()?;
/// let peer1_addr = peer_1.local_address();
///
/// let (peer_2, connection) = quic_p2p.connect_to(&peer1_addr).await?;
/// assert_eq!(connection.remote_address(), peer1_addr);
/// Ok(())
/// }
/// ```
pub fn remote_address(&self) -> SocketAddr {
self.quic_conn.remote_address()
}

/// Get connection streams for reading/writing
///
/// # Example
///
/// ```
/// use qp2p::{QuicP2p, Config, Error};
/// use std::net::{IpAddr, Ipv4Addr, SocketAddr};
///
/// #[tokio::main]
/// async fn main() -> Result<(), Error> {
///
/// let mut config = Config::default();
/// config.ip = Some(IpAddr::V4(Ipv4Addr::LOCALHOST));
/// let mut quic_p2p = QuicP2p::with_config(Some(config.clone()), Default::default(), true)?;
/// let peer_1 = quic_p2p.new_endpoint()?;
/// let peer1_addr = peer_1.local_address();
///
/// let (peer_2, connection) = quic_p2p.connect_to(&peer1_addr).await?;
/// let (send_stream, recv_stream) = connection.open_bi_stream().await?;
/// Ok(())
/// }
/// ```
pub async fn open_bi_stream(&self) -> Result<(SendStream, RecvStream)> {
let (send_stream, recv_stream) = self.quic_conn.open_bi().await?;
Ok((SendStream::new(send_stream), RecvStream::new(recv_stream)))
}

/// Send message to peer creating a bi-dreictional stream,
/// returning the streams to send and receive more messages.
/// Send message to the connected peer via a bi-directional stream.
/// This returns the streams to send additional messages / read responses sent using the same stream.
pub async fn send(&self, msg: Bytes) -> Result<(SendStream, RecvStream)> {
let (mut send_stream, recv_stream) = self.open_bi_stream().await?;
send_stream.send(msg).await?;
Expand Down

0 comments on commit 3f1db6e

Please sign in to comment.