Update for 2nd edition.

Author: jimblandy

Cargo.lock

@@ -6,6 +6,6 @@ edition = "2018"
 
 [dependencies]
 async-std = { version = "1.7", features = ["unstable"] }
-tokio = { version = "0.3", features = ["sync"] }
+tokio = { version = "1.0", features = ["sync"] }
 serde = { version = "1.0", features = ["derive", "rc"] }
 serde_json = "1.0"

Cargo.toml

@@ -1,4 +1,3 @@
-//# send-commands
 use async_std::prelude::*;
 use async_chat::utils::{self, ChatResult};
 use async_std::io;
@@ -12,8 +11,9 @@ async fn send_commands(mut to_server: net::TcpStream) -> ChatResult<()> {
               to close the connection.");
 
     let mut command_lines = io::BufReader::new(io::stdin()).lines();
-    while let Some(command) = command_lines.next().await {
-        let command = command?;
+    while let Some(command_result) = command_lines.next().await {
+        let command = command_result?;
+        // See the GitHub repo for the definition of `parse_command`.
         let request = match parse_command(&command) {
             Some(request) => request,
             None => continue,
@@ -25,9 +25,7 @@ async fn send_commands(mut to_server: net::TcpStream) -> ChatResult<()> {
 
     Ok(())
 }
-//#end
 
-//# client-handle-replies
 use async_chat::FromServer;
 
 async fn handle_replies(from_server: net::TcpStream) -> ChatResult<()> {
@@ -47,9 +45,7 @@ async fn handle_replies(from_server: net::TcpStream) -> ChatResult<()> {
 
     Ok(())
 }
-//# end
 
-//# client-main
 use async_std::task;
 
 fn main() -> ChatResult<()> {
@@ -68,7 +64,6 @@ fn main() -> ChatResult<()> {
         Ok(())
     })
 }
-//# end
 
 use async_chat::FromClient;
 use std::sync::Arc;

src/bin/client.rs

@@ -1,6 +1,5 @@
 /// Handle a single client's connection.
 
-//# chat-serve
 use async_chat::{FromClient, FromServer};
 use async_chat::utils::{self, ChatResult};
 use async_std::prelude::*;
@@ -17,8 +16,8 @@ pub async fn serve(socket: TcpStream, groups: Arc<GroupTable>)
 
     let buffered = BufReader::new(socket);
     let mut from_client = utils::receive_as_json(buffered);
-    while let Some(request) = from_client.next().await {
-        let request = request?;
+    while let Some(request_result) = from_client.next().await {
+        let request = request_result?;
 
         let result = match request {
             FromClient::Join { group_name } => {
@@ -48,9 +47,7 @@ pub async fn serve(socket: TcpStream, groups: Arc<GroupTable>)
 
     Ok(())
 }
-//# end
 
-//# chat-Outbound
 use async_std::sync::Mutex;
 
 pub struct Outbound(Mutex<TcpStream>);
@@ -67,4 +64,3 @@ impl Outbound {
         Ok(())
     }
 }
-//# end

src/bin/server/connection.rs

@@ -1,6 +1,5 @@
 //! A chat group.
 
-//# group-type
 use async_std::task;
 use crate::connection::Outbound;
 use std::sync::Arc;
@@ -33,9 +32,7 @@ impl Group {
         let _ignored = self.sender.send(message);
     }
 }
-//# end
 
-//# handle_subscriber
 use async_chat::FromServer;
 use tokio::sync::broadcast::error::RecvError;
 
@@ -62,4 +59,3 @@ async fn handle_subscriber(group_name: Arc<String>,
         }
     }
 }
-//# end

src/bin/server/group.rs

@@ -1,4 +1,3 @@
-//# group-table
 use crate::group::Group;
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
@@ -25,5 +24,4 @@ impl GroupTable {
             .clone()
     }
 }
-//# end
 

src/bin/server/group_table.rs

@@ -1,33 +1,43 @@
 //! Asynchronous chat server.
+#![warn(rust_2018_idioms)]
+#![allow(elided_lifetimes_in_paths)]
 
-//# server-main
 use async_std::prelude::*;
-use async_std::{net, task};
 use async_chat::utils::ChatResult;
 use std::sync::Arc;
 
 mod connection;
 mod group;
 mod group_table;
 
+use connection::serve;
+
 fn main() -> ChatResult<()> {
     let address = std::env::args().nth(1).expect("Usage: server ADDRESS");
 
-    let groups = Arc::new(group_table::GroupTable::new());
+    let chat_group_table = Arc::new(group_table::GroupTable::new());
+
+    async_std::task::block_on(async {
+        // This code was shown in the chapter introduction.
+        use async_std::{net, task};
 
-    task::block_on(async {
         let listener = net::TcpListener::bind(address).await?;
 
         let mut new_connections = listener.incoming();
-        loop {
-            let socket = new_connections.next().await.unwrap()?;
-            let groups = groups.clone();
+        while let Some(socket_result) = new_connections.next().await {
+            let socket = socket_result?;
+            let groups = chat_group_table.clone();
             task::spawn(async {
-                if let Err(error) = connection::serve(socket, groups).await {
-                    eprintln!("Error: {}", error);
-                }
+                log_error(serve(socket, groups).await);
             });
         }
+
+        Ok(())
     })
 }
-//# end
+
+fn log_error(result: ChatResult<()>) {
+    if let Err(error) = result {
+        eprintln!("Error: {}", error);
+    }
+}

src/bin/server/main.rs

@@ -1,9 +1,10 @@
-pub mod utils;
-
-//# request-and-reply
+#![warn(rust_2018_idioms)]
+#![allow(elided_lifetimes_in_paths)]
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 
+pub mod utils;
+
 #[derive(Debug, Deserialize, Serialize, PartialEq)]
 pub enum FromClient {
     Join { group_name: Arc<String> },
@@ -21,4 +22,21 @@ pub enum FromServer {
     },
     Error(String),
 }
-//# end
+
+
+#[test]
+fn test_fromclient_json() {
+    use std::sync::Arc;
+
+    let from_client = FromClient::Post {
+        group_name: Arc::new("Dogs".to_string()),
+        message: Arc::new("Samoyeds rock!".to_string()),
+    };
+
+    let json = serde_json::to_string(&from_client).unwrap();
+    assert_eq!(json,
+               r#"{"Post":{"group_name":"Dogs","message":"Samoyeds rock!"}}"#);
+
+    assert_eq!(serde_json::from_str::<FromClient>(&json).unwrap(),
+               from_client);
+}

src/lib.rs

@@ -1,13 +1,10 @@
 //! Utilities for both clients and servers.
 
-//# ChatResult
 use std::error::Error;
 
 pub type ChatError = Box<dyn Error + Send + Sync + 'static>;
 pub type ChatResult<T> = Result<T, ChatError>;
-//# end
 
-//# send-as-json
 use async_std::prelude::*;
 use serde::Serialize;
 use std::marker::Unpin;
@@ -22,9 +19,7 @@ where
     outbound.write_all(json.as_bytes()).await?;
     Ok(())
 }
-//# end
 
-//# receive_as_json
 use serde::de::DeserializeOwned;
 
 pub fn receive_as_json<S, P>(inbound: S) -> impl Stream<Item = ChatResult<P>>
@@ -38,26 +33,3 @@ pub fn receive_as_json<S, P>(inbound: S) -> impl Stream<Item = ChatResult<P>>
             Ok(parsed)
         })
 }
-//# end
-
-#[test]
-fn test_fromclient_json() -> ChatResult<()> {
-    use std::sync::Arc;
-    use super::FromClient;
-
-    //# serialization
-    let from_client = FromClient::Post {
-        group_name: Arc::new("Dogs".to_string()),
-        message: Arc::new("Samoyeds rock!".to_string()),
-    };
-
-    let json = serde_json::to_string(&from_client)?;
-    assert_eq!(json,
-               r#"{"Post":{"group_name":"Dogs","message":"Samoyeds rock!"}}"#);
-
-    assert_eq!(serde_json::from_str::<FromClient>(&json)?,
-               from_client);
-    //# end
-
-    Ok(())
-}