dchat: created seperate seed and simplified codebase

Cargo.lock

@@ -1360,12 +1360,33 @@ dependencies = [
  "darkfi",
  "easy-parallel",
  "futures",
+ "log",
+ "num_cpus",
  "ringbuffer",
  "serde",
  "simplelog",
  "smol",
  "structopt",
  "structopt-toml",
+ "termion",
+ "url",
+]
+
+[[package]]
+name = "dchat_seed"
+version = "0.1.0"
+dependencies = [
+ "async-channel",
+ "async-executor",
+ "async-std",
+ "darkfi",
+ "dchat",
+ "easy-parallel",
+ "futures",
+ "log",
+ "num_cpus",
+ "simplelog",
+ "smol",
  "url",
 ]
 

Cargo.toml

@@ -37,6 +37,7 @@ members = [
 	"src/util/derive-internal",
 
     "example/dchat",
+    "example/dchat-seed",
 ]
 
 [dependencies]

example/dchat-seed/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "dchat_seed"
+version = "0.1.0"
+edition = "2021"
+description = "Seed node for dchat"
+
+
+[dependencies]
+darkfi = {path = "../../", features = ["net", "rpc"]}
+dchat = {path = "../dchat"}
+
+# Async
+futures = "0.3.0"
+async-std = "1"
+async-executor = "1.4.1"
+async-channel = "1.6.1"
+easy-parallel = "3.2.0"
+smol = "1.2.5"
+num_cpus = "1.13.1"
+
+#Misc
+url = "2.2.2"
+log = "0.4.17"
+simplelog = "0.12.0"
+
+

example/dchat-seed/src/main.rs

@@ -0,0 +1,89 @@
+use async_executor::Executor;
+use async_std::sync::Arc;
+use easy_parallel::Parallel;
+//use log::{error, info, warn};
+use url::Url;
+
+use darkfi::{
+    net,
+    net::Settings,
+    util::cli::{get_log_config, get_log_level},
+    Result,
+};
+
+#[async_std::main]
+async fn main() -> Result<()> {
+    let log_level = get_log_level(1);
+    let log_config = get_log_config();
+
+    let env_log_file_path = match std::env::var("DARKFI_LOG") {
+        Ok(p) => std::fs::File::create(p).unwrap(),
+        Err(_) => std::fs::File::create("/tmp/darkfi.log").unwrap(),
+    };
+
+    simplelog::CombinedLogger::init(vec![
+        simplelog::TermLogger::new(
+            log_level,
+            log_config.clone(),
+            simplelog::TerminalMode::Mixed,
+            simplelog::ColorChoice::Auto,
+        ),
+        simplelog::WriteLogger::new(log_level, log_config, env_log_file_path),
+    ])?;
+
+    let url = Url::parse("tcp://127.0.0.1:55555").unwrap();
+
+    let settings = Settings {
+        inbound: Some(url),
+        outbound_connections: 0,
+        manual_attempt_limit: 0,
+        seed_query_timeout_seconds: 8,
+        connect_timeout_seconds: 10,
+        channel_handshake_seconds: 4,
+        channel_heartbeat_seconds: 10,
+        outbound_retry_seconds: 1200,
+        external_addr: None,
+        peers: Vec::new(),
+        seeds: Vec::new(),
+        node_id: String::new(),
+    };
+
+    let ex = Arc::new(Executor::new());
+    let ex2 = ex.clone();
+
+    let p2p = net::P2p::new(settings).await;
+
+    let seed = DchatSeed::new(p2p);
+
+    let nthreads = num_cpus::get();
+    let (signal, shutdown) = async_channel::unbounded::<()>();
+    let (_, result) = Parallel::new()
+        .each(0..nthreads, |_| smol::future::block_on(ex.run(shutdown.recv())))
+        .finish(|| {
+            smol::future::block_on(async move {
+                seed.start(ex2).await?;
+                drop(signal);
+                Ok(())
+            })
+        });
+
+    result
+}
+
+struct DchatSeed {
+    p2p: net::P2pPtr,
+}
+
+impl DchatSeed {
+    fn new(p2p: net::P2pPtr) -> Self {
+        Self { p2p }
+    }
+
+    async fn start(&self, executor: Arc<Executor<'_>>) -> Result<()> {
+        self.p2p.clone().start(executor.clone()).await?;
+
+        self.p2p.clone().run(executor.clone()).await?;
+
+        Ok(())
+    }
+}

example/dchat/Cargo.toml

@@ -17,12 +17,15 @@ async-executor = "1.4.1"
 async-channel = "1.6.1"
 easy-parallel = "3.2.0"
 smol = "1.2.5"
+num_cpus = "1.13.1"
 
 # Misc
+log = "0.4.17"
 simplelog = "0.12.0"
 ringbuffer = "0.8.4"
 url = "2.2.2"
 clap = {version = "3.2.8", features = ["derive"]}
+termion = "1.5.6"
 
 # Encoding and parsing
 serde = {version = "1.0.138", features = ["derive"]}

example/dchat/chat_config.toml → example/dchat/dchat_config.toml

@@ -14,7 +14,8 @@ outbound_connections=5
 #peers=["tls://127.0.0.1:11003"]
 
 ## Seed nodes to connect to 
-seeds=["tls://irc0.dark.fi:11001", "tls://irc1.dark.fi:11001"]
+#seeds=["tls://irc0.dark.fi:11001", "tls://irc1.dark.fi:11001"]
+seeds=["tcp://127.0.0.1:55555"]
 
 ## Only used for debugging. Compromises privacy when set.
 #node_id = "foo"

example/dchat/src/dchatmsg.rs

@@ -1,9 +1,7 @@
-use async_std::sync::{Arc, Mutex};
 use darkfi::{
     net,
     util::serial::{SerialDecodable, SerialEncodable},
 };
-use ringbuffer::AllocRingBuffer;
 
 impl net::Message for Dchatmsg {
     fn name() -> &'static str {
@@ -11,8 +9,6 @@ impl net::Message for Dchatmsg {
     }
 }
 
-pub type DchatmsgsBuffer = Arc<Mutex<AllocRingBuffer<Dchatmsg>>>;
-
 #[derive(Debug, Clone, SerialEncodable, SerialDecodable)]
 pub struct Dchatmsg {
     pub message: String,

example/dchat/src/main.rs

@@ -1,16 +1,22 @@
-use async_channel::Receiver;
+use async_channel::{Receiver, Sender};
 use async_executor::Executor;
-use async_std::{
-    net::{TcpListener, TcpStream},
-    sync::{Arc, Mutex},
+use async_std::{net::TcpListener, sync::Arc};
+
+use easy_parallel::Parallel;
+//use futures::{AsyncRead, AsyncWrite};
+use log::{error, info};
+use simplelog::WriteLogger;
+//use std::net::SocketAddr;
+use std::{
+    fs::File,
+    io::{self, Write},
 };
-use clap::{Parser, Subcommand};
-use futures::{io::WriteHalf, AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
-use smol::Async;
-use url::Url;
+
+use structopt_toml::StructOptToml;
+use termion::{event::Key, input::TermRead};
 
 use darkfi::{
-    async_daemonize, cli_desc, net,
+    net,
     system::{Subscriber, SubscriberPtr},
     util::{
         cli::{get_log_config, get_log_level, spawn_config},
@@ -18,191 +24,188 @@ use darkfi::{
     },
     Result,
 };
-use simplelog::{ColorChoice, TermLogger, TerminalMode};
-use smol::future;
-use structopt_toml::StructOptToml;
 
 use crate::{
-    dchatmsg::{Dchatmsg, DchatmsgsBuffer},
+    dchatmsg::Dchatmsg,
     protocol_dchat::ProtocolDchat,
-    settings::{CONFIG_FILE, CONFIG_FILE_CONTENTS},
+    settings::{Args, CONFIG_FILE, CONFIG_FILE_CONTENTS},
 };
 
 pub mod dchatmsg;
 pub mod protocol_dchat;
-pub mod server;
 pub mod settings;
 
-const SIZE_OF_MSGS_BUFFER: usize = 4096;
-
-#[derive(Parser)]
-#[clap(name = "dchat", about = cli_desc!(), version)]
-#[clap(arg_required_else_help(true))]
-struct Args {
-    #[clap(short, parse(from_occurrences))]
-    /// Increase verbosity (-vvv supported)
-    verbose: u8,
-
-    #[clap(subcommand)]
-    command: Option<Dchatsubcommand>,
-}
-
-#[derive(Subcommand)]
-enum Dchatsubcommand {
-    Inbox,
-    Send { msg: String, addr: String },
-    Receive { addr: String },
-}
-
-#[async_std::main]
-async fn main() -> Result<()> {
-    let args = Args::parse();
-
-    let log_level = get_log_level(args.verbose.into());
-    let log_config = get_log_config();
-    TermLogger::init(log_level, log_config, TerminalMode::Mixed, ColorChoice::Auto)?;
-
-    let dchat = Dchat::new();
-
-    match args.command {
-        Some(sc) => match sc {
-            Dchatsubcommand::Inbox => {
-                eprintln!("inbox");
-            }
-            Dchatsubcommand::Send { msg, addr } => {
-                dchat.send(msg, addr).await?;
-            }
-            Dchatsubcommand::Receive { addr } => {
-                dchat.receive(addr).await?;
-            }
-        },
-        None => {}
-    }
-    Ok(())
-}
 struct Dchat {
+    //accept_addr: String,
+    //connect_addr: String,
     //dchatmsgs_buffer: DchatmsgsBuffer,
-    //p2p: net::P2pPtr,
-    //senders: SubscriberPtr<Dchatmsg>,
+    p2p: net::P2pPtr,
 }
 
 impl Dchat {
-    //fn new(dchatmsgs_buffer: DchatmsgsBuffer, p2p: net::P2pPtr) -> Self {
-    //    let senders = Subscriber::new();
-    //    Self { dchatmsgs_buffer, p2p, senders }
-    //}
-    fn new() -> Arc<Self> {
-        Arc::new(Self {})
+    fn new(p2p: net::P2pPtr) -> Self {
+        Self { p2p }
     }
 
-    async fn receive(self: Arc<Self>, addr: String) -> Result<()> {
-        smol::block_on(async {
-            let listener = TcpListener::bind(&addr).await?;
-            eprintln!("Listening on {}", listener.local_addr()?);
+    async fn render(&self, ex: Arc<Executor<'_>>) -> Result<()> {
+        info!("DCHAT::render()::start");
+        let mut stdout = io::stdout().lock();
+        let stdin = termion::async_stdin();
+        let mut keys = stdin.keys();
+
+        stdout.write_all(
+            b"Welcome to dchat
+    s: send message
+    i. inbox
+    q: quit \n",
+        )?;
+
+        ex.spawn(async move {
             loop {
-                let (stream, peer_addr) = listener.accept().await?;
-                println!("Accepted client: {}", peer_addr);
-                smol::spawn(self.clone().read_msg(stream)).detach();
+                let k = keys.next();
+                match k {
+                    Some(k) => match k {
+                        Ok(k) => match k {
+                            Key::Char('q') => {
+                                info!("DCHAT::Q pressed.... exiting");
+                                break
+                            }
+                            Key::Char('i') => {}
+                            Key::Char('s') => {}
+                            _ => {}
+                        },
+                        Err(e) => {
+                            error!("found error: {}", e);
+                        }
+                    },
+                    None => {}
+                }
             }
         })
+        .detach();
+        Ok(())
+    }
+
+    async fn register_protocol(
+        &self,
+        p2p_send_channel: Sender<Dchatmsg>,
+        //p2p: net::P2pPtr,
+    ) -> Result<()> {
+        info!("DCHAT::register_protocol()::start");
+        let registry = self.p2p.protocol_registry();
+        registry
+            .register(net::SESSION_ALL, move |channel, p2p| {
+                let sender = p2p_send_channel.clone();
+                async move { ProtocolDchat::init(channel, p2p).await }
+            })
+            .await;
+        info!("DCHAT::register_protocol()::stop");
+        Ok(())
     }
 
-    async fn send(&self, msg: String, addr: String) -> Result<()> {
-        let mut stream = TcpStream::connect(&addr).await?;
-        eprintln!("Connected to {}", stream.local_addr()?);
-        stream.write_all(msg.as_bytes()).await?;
-        eprintln!("Sending '{}'", msg);
+    async fn start(
+        &self,
+        executor: Arc<Executor<'_>>,
+        settings: Args,
+        p2p_recv_channel: Receiver<Dchatmsg>,
+        p2p_send_channel: Sender<Dchatmsg>,
+    ) -> Result<()> {
+        info!("DCHAT::start()::start");
+        let dchat = Dchat::new(self.p2p.clone());
+
+        self.p2p.clone().start(executor.clone()).await?;
+
+        dchat.register_protocol(p2p_send_channel, self.p2p.clone()).await?;
+
+        let result = dchat.render(executor.clone()).await;
+
+        if let Err(e) = result {
+            error!("Rendering failed {}", e);
+        };
+
+        let executor_cloned = executor.clone();
+        executor_cloned.spawn(self.p2p.clone().run(executor.clone())).detach();
+
+        self.send().await?;
+
+        let listenaddr = settings.listen.socket_addrs(|| None)?[0];
+        let listener = TcpListener::bind(listenaddr).await?;
+
+        executor
+            .spawn(async move {
+                loop {
+                    let (_stream, peer_addr) = match listener.accept().await {
+                        Ok((s, a)) => (s, a),
+                        Err(e) => {
+                            error!("failed accepting new connections: {}", e);
+                            continue
+                        }
+                    };
+
+                    info!("dchat accepted new client: {}", peer_addr);
+                }
+            })
+            .detach();
+
+        info!("DCHAT::start()::stop");
         Ok(())
     }
 
-    async fn read_msg(self: Arc<Self>, mut stream: TcpStream) -> Result<()> {
-        let mut buffer = [0u8; 4];
-        stream.read_exact(&mut buffer).await?;
-        let buffer = std::str::from_utf8(&buffer).unwrap();
-        eprintln!("{}", buffer);
+    async fn send(&self) -> Result<()> {
+        let dchatmsg = Dchatmsg { message: "helloworld".to_string() };
+        self.p2p.broadcast(dchatmsg).await?;
         Ok(())
     }
-    //fn start_p2p_receive_loop(
-    //    &self,
-    //    executor: Arc<Executor<'_>>,
-    //    p2p_receiver: Receiver<Dchatmsg>,
-    //) {
-    //    let senders = self.senders.clone();
-    //    executor
-    //        .spawn(async move {
-    //            while let Ok(msg) = p2p_receiver.recv().await {
-    //                senders.notify(msg).await;
-    //            }
-    //        })
-    //        .detach();
-    //}
 }
 
-//#[async_std::main]
-//async_daemonize!(realmain);
-//async fn realmain(settings: Args, executor: Arc<Executor<'_>>) -> Result<()> {
-//    //let dchatmsgs_buffer: DchatmsgsBuffer =
-//    //    Arc::new(Mutex::new(ringbuffer::AllocRingBuffer::with_capacity(SIZE_OF_MSGS_BUFFER)));
-//    //// Pick up channel settings from the TOML configuration
-//    //let cfg_path = get_config_path(settings.config, CONFIG_FILE)?;
-//
-//    //let net_settings = settings.net;
-//    //let (p2p_send_channel, p2p_recv_channel) = async_channel::unbounded::<Dchatmsg>();
-//    //let p2p = net::P2p::new(net_settings.into()).await;
-//    //let p2p = p2p.clone();
-//
-//    //let registry = p2p.protocol_registry();
-//
-//    //let dchatmsgs_buffer_cloned = dchatmsgs_buffer.clone();
-//
-//    //registry
-//    //    .register(net::SESSION_ALL, move |channel, p2p| {
-//    //        let sender = p2p_send_channel.clone();
-//    //        let privmsgs_buffer_cloned = dchatmsgs_buffer_cloned.clone();
-//    //        async move { ProtocolDchat::init(channel, sender, p2p, privmsgs_buffer_cloned).await }
-//    //    })
-//    //    .await;
-//
-//    //p2p.clone().start(executor.clone()).await?;
-//
-//    //let executor_cloned = executor.clone();
-//    //executor_cloned.spawn(p2p.clone().run(executor.clone())).detach();
-//
-//    //let listenaddr = settings.listen.socket_addrs(|| None)?[0];
-//    //let listener = TcpListener::bind(listenaddr).await?;
-//
-//    //let executor_cloned = executor.clone();
-//    //executor
-//    //    .spawn(async move {
-//    //        let dchat = Dchatd::new(dchatmsgs_buffer.clone(), p2p.clone());
-//
-//    //        dchat.start_p2p_receive_loop(executor_cloned.clone(), p2p_recv_channel);
-//
-//    //        loop {
-//    //            let (stream, peer_addr) = match listener.accept().await {
-//    //                Ok((s, a)) => (s, a),
-//    //                Err(e) => {
-//    //                    //error!("failed accepting new connections: {}", e);
-//    //                    continue;
-//    //                }
-//    //            };
-//
-//    //            //ircd.process_new_connection(executor_cloned.clone(), stream, peer_addr).await
-//
-//    //            //if let Err(e) = result {
-//    //            //    error!("Failed processing connection {}: {}", peer_addr, e);
-//    //            //    continue;
-//    //            //};
-//
-//    //            //info!("IRC Accepted new client: {}", peer_addr);
-//    //        }
-//    //    })
-//    //    .detach();
-//
-//    //let (signal, shutdown) = async_channel::bounded::<()>(1);
-//
-//    //
-//    //shutdown.recv().await?;
-//
-//    Ok(())
-//}
+#[async_std::main]
+async fn main() -> Result<()> {
+    //let options = ProgramOptions::load()?;
+    //let verbosity_level = options.app.occurrences_of("verbose");
+
+    let args = Args::from_args_with_toml("").unwrap();
+    let cfg_path = get_config_path(args.config, CONFIG_FILE)?;
+    spawn_config(&cfg_path, CONFIG_FILE_CONTENTS.as_bytes())?;
+
+    let log_level = get_log_level(args.verbose);
+    let log_config = get_log_config();
+
+    // TODO: clean up
+    if args.log_path.is_none() {
+        let log_path = "/tmp/dchat.log";
+        let file = File::create(log_path).unwrap();
+        WriteLogger::init(log_level, log_config, file)?;
+    } else {
+        let file = File::create(args.log_path.unwrap()).unwrap();
+        WriteLogger::init(log_level, log_config, file)?;
+    }
+
+    let args = Args::from_args_with_toml(&std::fs::read_to_string(cfg_path)?).unwrap();
+
+    let settings = args;
+    let net_settings = settings.net.clone();
+
+    let (p2p_send_channel, p2p_recv_channel) = async_channel::unbounded::<Dchatmsg>();
+    let p2p = net::P2p::new(net_settings.into()).await;
+    let p2p = p2p.clone();
+
+    let nthreads = num_cpus::get();
+    let (signal, shutdown) = async_channel::unbounded::<()>();
+
+    let ex = Arc::new(Executor::new());
+    let ex2 = ex.clone();
+
+    let dchat = Dchat::new(p2p.clone());
+
+    let (_, result) = Parallel::new()
+        .each(0..nthreads, |_| smol::future::block_on(ex.run(shutdown.recv())))
+        .finish(|| {
+            smol::future::block_on(async move {
+                dchat.start(ex2, settings.clone(), p2p_recv_channel, p2p_send_channel).await?;
+                drop(signal);
+                Ok(())
+            })
+        });
+
+    result
+}

example/dchat/src/protocol_dchat.rs

@@ -2,26 +2,26 @@ use async_executor::Executor;
 use async_std::sync::Arc;
 use async_trait::async_trait;
 use darkfi::{net, Result};
+use log::debug;
 
-use crate::dchatmsg::{Dchatmsg, DchatmsgsBuffer};
-use ringbuffer::{RingBufferExt, RingBufferWrite};
+use crate::dchatmsg::Dchatmsg;
 
 pub struct ProtocolDchat {
     jobsman: net::ProtocolJobsManagerPtr,
-    notify_queue_sender: async_channel::Sender<Dchatmsg>,
+    //sender: async_channel::Sender<Dchatmsg>,
     msg_sub: net::MessageSubscription<Dchatmsg>,
     p2p: net::P2pPtr,
-    msgs: DchatmsgsBuffer,
     channel: net::ChannelPtr,
 }
 
 impl ProtocolDchat {
     pub async fn init(
         channel: net::ChannelPtr,
-        notify_queue_sender: async_channel::Sender<Dchatmsg>,
+        //sender: async_channel::Sender<Dchatmsg>,
         p2p: net::P2pPtr,
-        msgs: DchatmsgsBuffer,
     ) -> net::ProtocolBasePtr {
+        debug!(target: "dchat", "ProtocolDchat::init() [START]");
+
         let message_subsytem = channel.get_message_subsystem();
         message_subsytem.add_dispatch::<Dchatmsg>().await;
 
@@ -29,47 +29,36 @@ impl ProtocolDchat {
             channel.subscribe_msg::<Dchatmsg>().await.expect("Missing DchatMsg dispatcher!");
 
         Arc::new(Self {
-            notify_queue_sender,
-            msg_sub,
             jobsman: net::ProtocolJobsManager::new("ProtocolDchat", channel.clone()),
+            //sender,
+            msg_sub,
             p2p,
-            msgs,
             channel,
         })
     }
 
     async fn handle_receive_msg(self: Arc<Self>) -> Result<()> {
-        let exclude_list = vec![self.channel.address()];
-
-        let msgs_buffer = self.msgs.lock().await;
-        let msgs = msgs_buffer.to_vec();
-        drop(msgs_buffer);
-        for m in msgs {
-            self.channel.send(m.clone()).await?;
-        }
+        debug!(target: "dchat", "ProtocolDchat::handle_receive_msg() [START]");
 
         loop {
             let msg = self.msg_sub.receive().await?;
-            let mut msg = (*msg).to_owned();
 
-            // add the msg to the buffer
-            self.msgs.lock().await.push(msg.clone());
+            let msg = (*msg).to_owned();
 
-            self.notify_queue_sender.send(msg.clone()).await?;
+            //self.sender.send(msg.clone()).await?;
 
-            self.p2p.broadcast_with_exclude(msg, &exclude_list).await?;
+            self.p2p.broadcast(msg).await?;
         }
     }
 }
 
 #[async_trait]
 impl net::ProtocolBase for ProtocolDchat {
-    /// Starts ping-pong keep-alive messages exchange. Runs ping-pong in the
-    /// protocol task manager, then queues the reply. Sends out a ping and
-    /// waits for pong reply. Waits for ping and replies with a pong.
     async fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
+        debug!(target: "dchat", "ProtocolDchat::ProtocolBase::start() [START]");
         self.jobsman.clone().start(executor.clone());
         self.jobsman.clone().spawn(self.clone().handle_receive_msg(), executor.clone()).await;
+        debug!(target: "dchat", "ProtocolDchat::ProtocolBase::start() [STOP]");
         Ok(())
     }
 

example/dchat/src/server.rs

@@ -1,59 +0,0 @@
-use futures::{io::WriteHalf, AsyncRead, AsyncWrite, AsyncWriteExt};
-use ringbuffer::{RingBufferExt, RingBufferWrite};
-use std::net::SocketAddr;
-
-use darkfi::{net::P2pPtr, system::SubscriberPtr, Result};
-
-use crate::dchatmsg::{Dchatmsg, DchatmsgsBuffer};
-
-pub struct DchatserverConnection<C: AsyncRead + AsyncWrite + Send + Unpin + 'static> {
-    // server stream
-    write_stream: WriteHalf<C>,
-    peer_address: SocketAddr,
-    // msgs
-    dchatmsgs_buffer: DchatmsgsBuffer,
-    // p2p
-    p2p: P2pPtr,
-    senders: SubscriberPtr<Dchatmsg>,
-    subscriber_id: u64,
-}
-
-impl<C: AsyncRead + AsyncWrite + Send + Unpin + 'static> DchatserverConnection<C> {
-    pub fn new(
-        write_stream: WriteHalf<C>,
-        peer_address: SocketAddr,
-        dchatmsgs_buffer: DchatmsgsBuffer,
-        p2p: P2pPtr,
-        senders: SubscriberPtr<Dchatmsg>,
-        subscriber_id: u64,
-    ) -> Self {
-        Self { write_stream, peer_address, dchatmsgs_buffer, p2p, senders, subscriber_id }
-    }
-
-    async fn reply(&mut self, message: &str) -> Result<()> {
-        self.write_stream.write_all(message.as_bytes()).await?;
-        //debug!("Sent {}", message);
-        Ok(())
-    }
-
-    async fn update(&mut self, line: String) -> Result<()> {
-        // read from STDIN??
-        let mut tokens = line.split_ascii_whitespace();
-        Ok(())
-    }
-
-    async fn on_receive_dchatmsg(&mut self, message: &str, target: &str) -> Result<()> {
-        let protocol_msg = Dchatmsg { message: message.to_string() };
-
-        {
-            (*self.dchatmsgs_buffer.lock().await).push(protocol_msg.clone())
-        }
-
-        self.senders.notify_with_exclude(protocol_msg.clone(), &[self.subscriber_id]).await;
-
-        //debug!(target: "ircd", "PRIVMSG to be sent: {:?}", protocol_msg);
-        self.p2p.broadcast(protocol_msg).await?;
-
-        Ok(())
-    }
-}

example/dchat/src/settings.rs

@@ -4,8 +4,8 @@ use structopt::StructOpt;
 use structopt_toml::StructOptToml;
 use url::Url;
 
-pub const CONFIG_FILE: &str = "chat_config.toml";
-pub const CONFIG_FILE_CONTENTS: &str = include_str!("../chat_config.toml");
+pub const CONFIG_FILE: &str = "dchat_config.toml";
+pub const CONFIG_FILE_CONTENTS: &str = include_str!("../dchat_config.toml");
 
 #[derive(Clone, Debug, Deserialize, StructOpt, StructOptToml)]
 #[serde(default)]
@@ -15,6 +15,10 @@ pub struct Args {
     #[structopt(long)]
     pub config: Option<String>,
 
+    /// Sets a custom log path
+    #[structopt(long)]
+    pub log_path: Option<String>,
+
     /// IRC listen URL
     #[structopt(long = "listen", default_value = "tcp://127.0.0.1:11066")]
     pub listen: Url,
@@ -24,5 +28,5 @@ pub struct Args {
 
     /// Increase verbosity
     #[structopt(short, parse(from_occurrences))]
-    pub verbose: u8,
+    pub verbose: u64,
 }