book: suppress warnings in code samples

Author: djc

docs/book/src/quinn/certificate-certs.rs

@@ -30,6 +30,7 @@ fn generate_self_signed_cert() -> Result<
     Ok((cert_der, key))
 }
 
+#[allow(unused_variables)]
 fn main() {
     let (self_signed_certs, self_signed_key) = generate_self_signed_cert().unwrap();
     let (certs, key) = read_certs_from_file().unwrap();

docs/book/src/quinn/certificate-insecure.rs

@@ -59,6 +59,7 @@ impl rustls::client::danger::ServerCertVerifier for SkipServerVerification {
     }
 }
 
+#[allow(dead_code)] // Included in `certificate.md`
 fn configure_client() -> Result<ClientConfig, NoInitialCipherSuite> {
     let crypto = rustls::ClientConfig::builder()
         .dangerous()
@@ -70,6 +71,4 @@ fn configure_client() -> Result<ClientConfig, NoInitialCipherSuite> {
     )?)))
 }
 
-fn main() {
-    let client_config = configure_client().unwrap();
-}
+fn main() {}

docs/book/src/quinn/certificate.md

@@ -25,7 +25,7 @@ Then, allow the client to skip the certificate validation by implementing [Serve
 After that, modify the [ClientConfig][ClientConfig] to use this [ServerCertVerifier][ServerCertVerifier] implementation.
 
 ```rust
-{{#include certificate-insecure.rs:62:71}}
+{{#include certificate-insecure.rs:63:72}}
 ```
 
 Finally, if you plug this [ClientConfig][ClientConfig] into the [Endpoint::set_default_client_config()][set_default_client_config] your client endpoint should verify all connections as trustworthy.

docs/book/src/quinn/data-transfer.md

@@ -34,13 +34,13 @@ For example, from the connection initiator to the peer and the other way around.
 *open bidirectional stream*
 
 ```rust
-{{#include data-transfer.rs:4:10}}
+{{#include data-transfer.rs:5:11}}
 ```
 
 *iterate incoming bidirectional stream(s)*
 
 ```rust
-{{#include data-transfer.rs:12:20}}
+{{#include data-transfer.rs:14:22}}
 ```
 
 ## Unidirectional Streams
@@ -51,13 +51,13 @@ It is possible to get reliability without ordering (so no head-of-line blocking)
 *open unidirectional stream*
 
 ```rust
-{{#include data-transfer.rs:22:27}}
+{{#include data-transfer.rs:25:30}}
 ```
 
 *iterating incoming unidirectional stream(s)*
 
 ```rust
-{{#include data-transfer.rs:29:35}}
+{{#include data-transfer.rs:33:39}}
 ```
 
 ## Unreliable Messaging
@@ -68,13 +68,13 @@ This could be useful if data arrival isn't essential or when high throughput is
 *send datagram*
 
 ```rust
-{{#include data-transfer.rs:37:40}}
+{{#include data-transfer.rs:42:45}}
 ```
 
 *iterating datagram stream(s)*
 
 ```rust
-{{#include data-transfer.rs:42:48}}
+{{#include data-transfer.rs:48:54}}
 ```
 
 [Endpoint]: https://docs.rs/quinn/latest/quinn/struct.Endpoint.html

docs/book/src/quinn/data-transfer.rs

@@ -1,6 +1,7 @@
 use bytes::Bytes;
 use quinn::Connection;
 
+#[allow(dead_code, unused_variables)] // Included in `data-transfer.md`
 async fn open_bidirectional_stream(connection: Connection) -> anyhow::Result<()> {
     let (mut send, mut recv) = connection.open_bi().await?;
     send.write_all(b"test").await?;
@@ -9,6 +10,7 @@ async fn open_bidirectional_stream(connection: Connection) -> anyhow::Result<()>
     Ok(())
 }
 
+#[allow(dead_code)] // Included in `data-transfer.md`
 async fn receive_bidirectional_stream(connection: Connection) -> anyhow::Result<()> {
     while let Ok((mut send, mut recv)) = connection.accept_bi().await {
         // Because it is a bidirectional stream, we can both send and receive.
@@ -19,13 +21,15 @@ async fn receive_bidirectional_stream(connection: Connection) -> anyhow::Result<
     Ok(())
 }
 
+#[allow(dead_code)] // Included in `data-transfer.md`
 async fn open_unidirectional_stream(connection: Connection) -> anyhow::Result<()> {
     let mut send = connection.open_uni().await?;
     send.write_all(b"test").await?;
     send.finish()?;
     Ok(())
 }
 
+#[allow(dead_code)] // Included in `data-transfer.md`
 async fn receive_unidirectional_stream(connection: Connection) -> anyhow::Result<()> {
     while let Ok(mut recv) = connection.accept_uni().await {
         // Because it is a unidirectional stream, we can only receive not send back.
@@ -34,15 +38,19 @@ async fn receive_unidirectional_stream(connection: Connection) -> anyhow::Result
     Ok(())
 }
 
+#[allow(dead_code)] // Included in `data-transfer.md`
 async fn send_unreliable(connection: Connection) -> anyhow::Result<()> {
     connection.send_datagram(Bytes::from(&b"test"[..]))?;
     Ok(())
 }
 
+#[allow(dead_code)] // Included in `data-transfer.md`
 async fn receive_datagram(connection: Connection) -> anyhow::Result<()> {
     while let Ok(received_bytes) = connection.read_datagram().await {
         // Because it is a unidirectional stream, we can only receive not send back.
         println!("request: {:?}", received_bytes);
     }
     Ok(())
 }
+
+fn main() {}

docs/book/src/quinn/set-up-connection.md

@@ -22,7 +22,7 @@ The [server()][server] method, which can be used for this, returns the `Endpoint
 `Endpoint` is used to start outgoing connections and accept incoming connections.
 
 ```rust
-{{#include set-up-connection.rs:15:27}}
+{{#include set-up-connection.rs:16:28}}
 ```
 
 **Client**
@@ -32,7 +32,7 @@ The client needs to connect to the server using the [connect(server_name)][conne
 The `SERVER_NAME` argument is the DNS name, matching the certificate configured in the server.
 
 ```rust
-{{#include set-up-connection.rs:29:39}}
+{{#include set-up-connection.rs:31:41}}
 ```
 <br><hr>
 

docs/book/src/quinn/set-up-connection.rs

@@ -12,23 +12,25 @@ fn server_addr() -> SocketAddr {
     "127.0.0.1:5001".parse::<SocketAddr>().unwrap()
 }
 
+#[allow(dead_code, unused_variables)] // Included in `set-up-connection.md`
 async fn server(config: ServerConfig) -> Result<(), Box<dyn Error>> {
     // Bind this endpoint to a UDP socket on the given server address.
     let endpoint = Endpoint::server(config, server_addr())?;
 
     // Start iterating over incoming connections.
     while let Some(conn) = endpoint.accept().await {
-        let mut connection = conn.await?;
+        let connection = conn.await?;
 
         // Save connection somewhere, start transferring, receiving data, see DataTransfer tutorial.
     }
 
     Ok(())
 }
 
+#[allow(dead_code, unused_variables)] // Included in `set-up-connection.md`
 async fn client() -> Result<(), Box<dyn Error>> {
     // Bind this endpoint to a UDP socket on the given client address.
-    let mut endpoint = Endpoint::client(client_addr())?;
+    let endpoint = Endpoint::client(client_addr())?;
 
     // Connect to the server passing in the server name which is supposed to be in the server certificate.
     let connection = endpoint.connect(server_addr(), SERVER_NAME)?.await?;
@@ -37,3 +39,5 @@ async fn client() -> Result<(), Box<dyn Error>> {
 
     Ok(())
 }
+
+fn main() {}