book/dchat: remove duplicate files

doc/src/learn/dchat/creating-dchat/custom-message.md

@@ -1,45 +0,0 @@
-# Creating a Message type
-
-We'll start by creating a custom Message type called Dchatmsg. This is the
-data structure that we'll use to send messages between dchat instances.
-
-Messages on the p2p network must implement the Message trait. Message is a
-generic type that standardizes all messages on DarkFi's p2p network.
-
-We define a custom type called Dchatmsg that implements the Message
-trait. We also add serde's SerialEncodable and SerialDecodable to our
-struct definition so our messages can be parsed by the network.
-
-The Message trait requires that we implement a method called name(),
-which returns a str of the struct's name.
-
-```
-use darkfi::{
-    net,
-    util::serial::{SerialDecodable, SerialEncodable},
-};
-
-impl net::Message for Dchatmsg {
-    fn name() -> &'static str {
-        "Dchatmsg"
-    }
-}
-
-#[derive(Debug, Clone, SerialEncodable, SerialDecodable)]
-pub struct Dchatmsg {
-    pub msg: String,
-}
-```
-
-For the purposes of our chat program, we will also define a buffer where
-we can write messages upon receiving them on the p2p network. We'll wrap
-this in a Mutex to ensure thread safety and an Arc pointer so we can
-pass it around.
-
-```
-use async_std::sync::{Arc, Mutex};
-
-pub type DchatmsgsBuffer = Arc<Mutex<Vec<Dchatmsg>>>;
-```
-
-

doc/src/learn/dchat/creating-dchat/custom-protocol.md

@@ -1,105 +0,0 @@
-# ProtocolDchat
-
-Let's start tying these concepts together. We'll define a struct called
-ProtocolDchat that contains a MessageSubscription to Dchatmsg and a
-pointer to the ProtocolJobsManager. We'll also include the DchatmsgsBuffer
-in the struct as it will come in handy later on.
-
-```
-use darkfi::net;
-
-use crate::dchatmsg::{Dchatmsg, DchatmsgsBuffer};
-
-pub struct ProtocolDchat {
-    jobsman: net::ProtocolJobsManagerPtr,
-    msg_sub: net::MessageSubscription<Dchatmsg>,
-    msgs: DchatmsgsBuffer,
-}
-```
-
-Next we'll implement the trait ProtocolBase. ProtocolBase requires two
-functions, start() and name(). In start() we will start up the Protocol
-Jobs Manager. name() will return a str of the protocol name.
-
-```
-use async_executor::Executor;
-use async_std::sync::Arc;
-use async_trait::async_trait;
-use darkfi::{net, Result};
-
-use crate::dchatmsg::{Dchatmsg, DchatmsgsBuffer};
-
-#[async_trait]
-impl net::ProtocolBase for ProtocolDchat {
-    async fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
-        self.jobsman.clone().start(executor.clone());
-        Ok(())
-    }
-
-    fn name(&self) -> &'static str {
-        "ProtocolDchat"
-    }
-}
-```
-
-Once that's done, we'll need to create a ProtocolDchat constructor that
-we will pass to the ProtocolRegistry to register our protocol. The
-constructor takes a pointer to channel which it uses to invoke the
-Message Subsystem and add Dchatmsg as to the list of dispatchers. Next,
-we'll create a message subscription to Dchatmsg using the method
-subscribe_msg().
-
-We'll also initialize the Protocol Jobs Manager and finally return a
-pointer to the protocol.
-
-```
-impl ProtocolDchat {
-    pub async fn init(channel: net::ChannelPtr, msgs: DchatmsgsBuffer) -> net::ProtocolBasePtr {
-        let message_subsytem = channel.get_message_subsystem();
-        message_subsytem.add_dispatch::<Dchatmsg>().await;
-
-        let msg_sub = channel
-            .subscribe_msg::<Dchatmsg>()
-            .await
-            .expect("Missing DchatMsg dispatcher!");
-
-        Arc::new(Self {
-            jobsman: net::ProtocolJobsManager::new("ProtocolDchat", channel.clone()),
-            msg_sub,
-            msgs,
-        })
-    }
-}
-```
-
-We're nearly there. But right now the protocol doesn't actually do
-anything. Let's write a method called handle_receive_msg() which receives
-a message on our message subscription and adds it to DchatmsgsBuffer.
- 
-Put this inside the ProtocolDchat implementation:
-
-```
-async fn handle_receive_msg(self: Arc<Self>) -> Result<()> {
-    while let Ok(msg) = self.msg_sub.receive().await {
-        let msg = (*msg).to_owned();
-        self.msgs.lock().await.push(msg);
-    }
-
-    Ok(())
-}
-```
-
-As a final step, let's add that task to the jobs manager that is invoked
-in start():
-
-```
-async fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
-    self.jobsman.clone().start(executor.clone());
-    self.jobsman
-        .clone()
-        .spawn(self.clone().handle_receive_msg(), executor.clone())
-        .await;
-    Ok(())
-}
-```
-

doc/src/learn/dchat/creating-dchat/understanding-protocols.md

@@ -1,54 +0,0 @@
-# Protocols
-
-We now need to implement a custom protocol which defines how our chat
-program interacts with the p2p network.
-
-We've already interacted with several protocols already. Protocols
-are automatically activated when nodes connect to eachother on the
-p2p network. Here are examples of two protocols that every node runs
-continuously in the background:
-
-[ProtocolPing](../../../src/net/protocol/protocol_ping.rs): sends ping,
-receives pong
-[ProtocolAddress](../../../src/net/protocol/protocol_address.rs): receives
-a get_address message, sends an address message
-
-Under the hood, these protocols have a few similarities:
-
-1. They create a subscription to a message type, such as Ping and Pong.
-2. They implement [ProtocolBase](../../../src/net/protocol/protocol_base.rs),
-DarkFi's generic protocol trait.
-3. They run asynchronously using the
-[ProtocolJobsManager](../../../src/net/protocol/protocol_jobs_manager.rs).
-4. They hold a pointer to [Channel](../../../src/net/channel.rs) which
-invokes the [MessageSubsystem](../../../src/net/message_subscriber).
-
-This introduces several generic interfaces that we must use to build
-our custom protocol. In particular:
-
-1. The Message Subsystem
-
-MessageSubsystem is a generic publish/subscribe class that can
-dispatch any kind of message to a list of dispatchers. This is how we
-can send and receive custom messages on the p2p network.
-
-2. Message Subscription
-
-A subscription to a message type. 
-
-3. The Protocol Registry 
-
-ProtocolRegistry takes any kind of generic protocol and initializes it. We
-use it through the method register() which passes a protocol constructor
-and a session bitflag which determines which sessions (outbound, inbound,
-or seed) will run our protocol.
-
-4. ProtocolJobsManager
-
-An asynchronous job manager that spawns and stops tasks created by
-protocols across the network.
-
-5. ProtocolBase
-
-A generic protocol trait that all protocols must implement.
-