load program options and interpret privmsg commands

src/bin/ircd.rs

@@ -1,3 +1,5 @@
+#[macro_use]
+extern crate clap;
 use std::{
     io,
     net::{SocketAddr, TcpListener, TcpStream},
@@ -14,7 +16,7 @@ use log::{debug, error, info, warn};
 use simplelog::{ColorChoice, LevelFilter, TermLogger, TerminalMode};
 use smol::Async;
 
-use drk::{Error, Result};
+use drk::{Error, Result, net};
 
 /*
 NICK fifififif
@@ -74,17 +76,28 @@ impl ServerConnection {
                 self.is_user_init = true;
             }
             "JOIN" => {
-                let channel = tokens.next().ok_or(Error::MalformedPacket)?;
-                self.channels.push(channel.to_string());
+                // Ignore since channels are all autojoin
+                //let channel = tokens.next().ok_or(Error::MalformedPacket)?;
+                //self.channels.push(channel.to_string());
 
-                let join_reply = format!(":{}!darkfi@127.0.0.1 JOIN {}\n", self.nickname, channel);
-                self.reply(&join_reply).await?;
+                //let join_reply = format!(":{}!darkfi@127.0.0.1 JOIN {}\n", self.nickname, channel);
+                //self.reply(&join_reply).await?;
 
                 //self.write_stream.write_all(b":f00!f00@127.0.0.1 PRIVMSG #dev :y0\n").await?;
             }
             "PING" => {
                 self.reply("PONG").await?;
             }
+            "PRIVMSG" => {
+                let channel = tokens.next().ok_or(Error::MalformedPacket)?;
+
+                let substr_idx = line.find(':').ok_or(Error::MalformedPacket)?;
+                if substr_idx >= line.len() {
+                    return Err(Error::MalformedPacket)
+                }
+                let message = &line[substr_idx + 1..];
+                info!("Message {}: {}", channel, message);
+            }
             _ => {}
         }
 
@@ -93,6 +106,12 @@ impl ServerConnection {
             let register_reply = format!(":darkfi 001 {} :Let there be dark\n", self.nickname);
             self.reply(&register_reply).await?;
             self.is_registered = true;
+
+            // Auto-joins
+            for channel in ["#dev", "#markets", "#welcome"] {
+                let join_reply = format!(":{}!darkfi@127.0.0.1 JOIN {}\n", self.nickname, channel);
+                self.reply(&join_reply).await?;
+            }
         }
 
         Ok(())
@@ -142,7 +161,7 @@ async fn process(stream: Async<TcpStream>, peer_addr: SocketAddr) {
     }
 }
 
-async fn start(executor: Arc<Executor<'_>>) -> Result<()> {
+async fn start(executor: Arc<Executor<'_>>, options: ProgramOptions) -> Result<()> {
     let accept_addr = ([127, 0, 0, 1], 6667);
     let listener = match Async::<TcpListener>::bind(accept_addr) {
         Ok(listener) => listener,
@@ -160,6 +179,19 @@ async fn start(executor: Arc<Executor<'_>>) -> Result<()> {
     };
     info!("Listening on {}", local_addr);
 
+    /*
+    let p2p = net::P2p::new(options.network_settings);
+    // Performs seed session
+    p2p.clone().start(executor.clone()).await?;
+    // Actual main p2p session
+    let ex2 = executor.clone();
+    executor.spawn(async move {
+        if let Err(err) = p2p.run(ex2).await {
+            error!("Error: p2p run failed {}", err);
+        }
+    }).detach();
+    */
+
     loop {
         let (stream, peer_addr) = match listener.accept().await {
             Ok((s, a)) => (s, a),
@@ -174,6 +206,75 @@ async fn start(executor: Arc<Executor<'_>>) -> Result<()> {
     }
 }
 
+struct ProgramOptions {
+    network_settings: net::Settings,
+    log_path: Box<std::path::PathBuf>,
+}
+
+impl ProgramOptions {
+    fn load() -> Result<ProgramOptions> {
+        let app = clap_app!(dfi =>
+            (version: "0.1.0")
+            (author: "Amir Taaki <amir@dyne.org>")
+            (about: "Dark node")
+            (@arg ACCEPT: -a --accept +takes_value "Accept address")
+            (@arg SEED_NODES: -s --seeds ... "Seed nodes")
+            (@arg CONNECTS: -c --connect ... "Manual connections")
+            (@arg CONNECT_SLOTS: --slots +takes_value "Connection slots")
+            (@arg LOG_PATH: --log +takes_value "Logfile path")
+            (@arg RPC_PORT: -r --rpc +takes_value "RPC port")
+        )
+        .get_matches();
+
+        let accept_addr = if let Some(accept_addr) = app.value_of("ACCEPT") {
+            Some(accept_addr.parse()?)
+        } else {
+            None
+        };
+
+        let mut seed_addrs: Vec<SocketAddr> = vec![];
+        if let Some(seeds) = app.values_of("SEED_NODES") {
+            for seed in seeds {
+                seed_addrs.push(seed.parse()?);
+            }
+        }
+
+        let mut manual_connects: Vec<SocketAddr> = vec![];
+        if let Some(connections) = app.values_of("CONNECTS") {
+            for connect in connections {
+                manual_connects.push(connect.parse()?);
+            }
+        }
+
+        let connection_slots = if let Some(connection_slots) = app.value_of("CONNECT_SLOTS") {
+            connection_slots.parse()?
+        } else {
+            0
+        };
+
+        let log_path = Box::new(
+            if let Some(log_path) = app.value_of("LOG_PATH") {
+                std::path::Path::new(log_path)
+            } else {
+                std::path::Path::new("/tmp/darkfid.log")
+            }
+            .to_path_buf(),
+        );
+
+        Ok(ProgramOptions {
+            network_settings: net::Settings {
+                inbound: accept_addr,
+                outbound_connections: connection_slots,
+                external_addr: accept_addr,
+                peers: manual_connects,
+                seeds: seed_addrs,
+                ..Default::default()
+            },
+            log_path,
+        })
+    }
+}
+
 fn main() -> Result<()> {
     TermLogger::init(
         LevelFilter::Debug,
@@ -182,6 +283,9 @@ fn main() -> Result<()> {
         ColorChoice::Auto,
     )?;
 
+    let options = ProgramOptions::load()?;
+
     let ex = Arc::new(Executor::new());
-    smol::block_on(ex.run(start(ex.clone())))
+    smol::block_on(ex.run(start(ex.clone(), options)))
 }
+

src/net/p2p.rs

@@ -82,7 +82,7 @@ impl P2p {
         inbound.stop().await;
         outbound.stop().await;
 
-        debug!(target: "net", "P2p::run() [BEGIN]");
+        debug!(target: "net", "P2p::run() [END]");
         Ok(())
     }