Added a decent logging.

Cargo.toml

@@ -11,6 +11,8 @@ repository = "https://github.com/Revertron/Alfis"
 
 [dependencies]
 getopts = "0.2.21"
+log = "0.4.14"
+simple_logger = "1.11.0"
 rust-crypto = "^0.2"
 num_cpus = "1.13.0"
 byteorder = "1.3.2"

src/blockchain/blockchain.rs

@@ -2,6 +2,7 @@ use sqlite::{Connection, State, Statement};
 
 use crate::{Block, Bytes, Keystore, Transaction};
 use crate::settings::Settings;
+use log::{trace, debug, info, warn, error};
 
 const DB_NAME: &str = "blockchain.db";
 
@@ -30,18 +31,18 @@ impl Blockchain {
             Ok(mut statement) => {
                 while statement.next().unwrap() == State::Row {
                     match Self::get_block_from_statement(&mut statement) {
-                        None => { println!("Something wrong with block in DB!"); }
+                        None => { error!("Something wrong with block in DB!"); }
                         Some(block) => {
-                            println!("Loaded last block: {:?}", &block);
+                            info!("Loaded last block: {:?}", &block);
                             self.version = block.version;
                             self.last_block = Some(block);
                         }
                     }
-                    println!("Blockchain version from DB = {}", self.version);
+                    debug!("Blockchain version from DB = {}", self.version);
                 }
             }
             Err(_) => {
-                println!("No blockchain database found. Creating new.");
+                info!("No blockchain database found. Creating new.");
                 self.db.execute("
                     CREATE TABLE blocks (
                                          'id' BIGINT,
@@ -64,10 +65,10 @@ impl Blockchain {
 
     pub fn add_block(&mut self, block: Block) -> Result<(), &str> {
         if !self.check_block(&block, &self.last_block) {
-            println!("Bad block found, ignoring:\n{:?}", &block);
+            warn!("Bad block found, ignoring:\n{:?}", &block);
             return Err("Bad block found, ignoring");
         }
-        println!("Adding block:\n{:?}", &block);
+        info!("Adding block:\n{:?}", &block);
         self.blocks.push(block.clone());
         self.last_block = Some(block.clone());
         let transaction = block.transaction.clone();
@@ -124,11 +125,11 @@ impl Blockchain {
                 while statement.next().unwrap() == State::Row {
                     return match Self::get_block_from_statement(&mut statement) {
                         None => {
-                            println!("Something wrong with block in DB!");
+                            error!("Something wrong with block in DB!");
                             None
                         }
                         Some(block) => {
-                            println!("Loaded block: {:?}", &block);
+                            debug!("Loaded block: {:?}", &block);
                             Some(block)
                         }
                     }
@@ -136,7 +137,7 @@ impl Blockchain {
                 None
             }
             Err(_) => {
-                println!("Can't find block {}", index);
+                warn!("Can't find requested block {}", index);
                 None
             }
         }
@@ -192,7 +193,7 @@ impl Blockchain {
             let pub_key = Bytes::from_bytes(statement.read::<Vec<u8>>(5).unwrap().as_slice());
             let signature = Bytes::from_bytes(statement.read::<Vec<u8>>(6).unwrap().as_slice());
             let transaction = Transaction { identity, confirmation, method, data, pub_key, signature };
-            println!("Got transaction: {:?}", &transaction);
+            debug!("Got transaction: {:?}", &transaction);
             if transaction.check_for(domain) {
                 return Some(transaction.data);
             }
@@ -227,13 +228,13 @@ impl Blockchain {
 
     fn check_block(&self, block: &Block, prev_block: &Option<Block>) -> bool {
         if !check_block_hash(block) {
-            println!("{:?} has wrong hash! Ignoring!", &block);
+            warn!("{:?} has wrong hash! Ignoring!", &block);
             return false;
         }
         // TODO make transaction not Optional
         let transaction = block.transaction.as_ref().unwrap();
         if !check_transaction_signature(&transaction) {
-            println!("{:?} has wrong signature! Ignoring block!", &transaction);
+            warn!("{:?} has wrong signature! Ignoring block!", &transaction);
             return false;
         }
         match prev_block {
@@ -250,7 +251,7 @@ impl Blockchain {
             }
             Some(prev) => {
                 if block.index != prev.index + 1 {
-                    println!("Discarding block with index {} as not needed now", block.index);
+                    info!("Discarding block with index {} as not needed now", block.index);
                     return false;
                 }
                 block.prev_block_hash.eq(&prev.hash)

src/blockchain/filter.rs

@@ -2,6 +2,7 @@ use crate::Context;
 use std::sync::{Mutex, Arc};
 use crate::dns::filter::DnsFilter;
 use crate::dns::protocol::{DnsPacket, QueryType, DnsRecord, DnsQuestion};
+use log::{trace, debug, info, warn, error};
 
 pub struct BlockchainFilter {
     context: Arc<Mutex<Context>>
@@ -17,8 +18,9 @@ impl DnsFilter for BlockchainFilter {
     fn lookup(&self, qname: &str, qtype: QueryType) -> Option<DnsPacket> {
         let data = self.context.lock().unwrap().blockchain.get_domain_info(qname);
         match data {
-            None => { println!("Not found info for domain {}", &qname); }
+            None => { debug!("Not found data for domain {}", &qname); }
             Some(data) => {
+                info!("Found data for domain {}", &qname);
                 let records: Vec<DnsRecord> = match serde_json::from_str(&data) {
                     Err(_) => { return None; }
                     Ok(records) => { records }

src/context.rs

@@ -1,6 +1,7 @@
 use crate::{Blockchain, Bus, Keystore};
 use crate::event::Event;
 use crate::settings::Settings;
+use log::{trace, debug, info, warn, error};
 
 pub struct Context {
     pub settings: Settings,
@@ -20,7 +21,7 @@ impl Context {
         let filename = &name.into();
         match Keystore::from_file(filename, &password.into()) {
             None => {
-                println!("Error loading keystore '{}'!", filename);
+                warn!("Error loading keystore '{}'!", filename);
             },
             Some(keystore) => {
                 self.keystore = keystore;

src/keys.rs

@@ -13,6 +13,7 @@ use std::path::Path;
 use serde::{Serialize, Deserialize, Serializer, Deserializer};
 // For deserialization
 use serde::de::{Error as DeError, Visitor};
+use log::{trace, debug, info, warn, error};
 use crate::hash_is_good;
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -61,7 +62,7 @@ impl Keystore {
                 f.write_all(&self.seed).expect("Error saving keystore");
                 self.path = filename.to_owned();
             }
-            Err(_) => { println!("Error saving key file!"); }
+            Err(_) => { error!("Error saving key file!"); }
         }
     }
 
@@ -203,11 +204,14 @@ impl<'dd> Deserialize<'dd> for Bytes {
     }
 }
 
-#[test]
+#[cfg(test)]
-pub fn test_signature() {
+mod tests {
-    let keystore: Keystore = Keystore::new();
+    #[test]
-    let data = b"{ identity: 178135D209C697625E3EC71DA5C760382E54936F824EE5083908DA66B14ECE18,\
+    pub fn test_signature() {
+        let keystore: Keystore = Keystore::new();
+        let data = b"{ identity: 178135D209C697625E3EC71DA5C760382E54936F824EE5083908DA66B14ECE18,\
     confirmation: A4A0AFECD1A511825226F0D3437C6C6BDAE83554040AA7AEB49DEFEAB0AE9EA4 }";
-    let signature = keystore.sign(data);
+        let signature = keystore.sign(data);
-    assert!(Keystore::check(data, keystore.get_public().as_bytes(), &signature), "Wrong signature!")
+        assert!(Keystore::check(data, keystore.get_public().as_bytes(), &signature), "Wrong signature!")
+    }
 }

src/main.rs

@@ -18,6 +18,8 @@ use rand::RngCore;
 use serde::Deserialize;
 use web_view::*;
 use getopts::Options;
+use simple_logger::{SimpleLogger};
+use log::{trace, debug, info, warn, error, LevelFilter};
 
 use alfis::{Blockchain, Bytes, Context, Keystore, Transaction};
 use alfis::event::Event;
@@ -47,13 +49,15 @@ fn main() {
         AttachConsole(ATTACH_PARENT_PROCESS);
     }
 
-    println!("ALFIS 0.1.0");
+    println!("Starting ALFIS 0.1.0");
     let args: Vec<String> = env::args().collect();
     let program = args[0].clone();
 
     let mut opts = Options::new();
     opts.optflag("h","help", "Print this help menu");
     opts.optflag("n","nogui","Run without graphic user interface");
+    opts.optflag("v","verbose","Show more debug messages");
+    opts.optflag("d","debug","Show trace messages, more than debug");
     opts.optopt("c","config","Path to config file", "");
 
     let opt_matches = match opts.parse(&args[1..]) {
@@ -69,18 +73,27 @@ fn main() {
 
     let no_gui = opt_matches.opt_present("n");
 
+    let mut level = LevelFilter::Info;
+    if opt_matches.opt_present("v") {
+        level = LevelFilter::Debug;
+    }
+    if opt_matches.opt_present("d") {
+        level = LevelFilter::Trace;
+    }
+    SimpleLogger::new().with_level(level).init().unwrap();
+
     let settings = Settings::load(SETTINGS_FILENAME).expect("Error loading settings");
     let keystore: Keystore = match Keystore::from_file(&settings.key_file, "") {
         None => {
-            println!("Generated temporary keystore. Please, generate full-privileged keys.");
+            warn!("Generated temporary keystore. Please, generate full-privileged keys.");
             Keystore::new()
         }
         Some(keystore) => { keystore }
     };
     let blockchain: Blockchain = Blockchain::new(&settings);
     match blockchain.get_block(0) {
-        None => { println!("No blocks found in DB"); }
+        None => { info!("No blocks found in DB"); }
-        Some(block) => { println!("Loaded DB with origin {:?}", &block.hash); }
+        Some(block) => { info!("Loaded DB with origin {:?}", &block.hash); }
     }
     let settings_copy = settings.clone();
     let context: Arc<Mutex<Context>> = Arc::new(Mutex::new(Context::new(settings, keystore, blockchain)));
@@ -116,14 +129,14 @@ fn start_dns_server(context: &Arc<Mutex<Context>>, settings: &Settings) {
     if server_context.enable_udp {
         let udp_server = DnsUdpServer::new(server_context.clone(), 20);
         if let Err(e) = udp_server.run_server() {
-            println!("Failed to bind UDP listener: {:?}", e);
+            error!("Failed to bind UDP listener: {:?}", e);
         }
     }
 
     if server_context.enable_tcp {
         let tcp_server = DnsTcpServer::new(server_context.clone(), 20);
         if let Err(e) = tcp_server.run_server() {
-            println!("Failed to bind TCP listener: {:?}", e);
+            error!("Failed to bind TCP listener: {:?}", e);
         }
     }
 }
@@ -156,14 +169,14 @@ fn run_interface(context: Arc<Mutex<Context>>, miner: Arc<Mutex<Miner>>) {
         .user_data(())
         .invoke_handler(|web_view, arg| {
             use Cmd::*;
-            println!("Command {}", arg);
+            debug!("Command {}", arg);
             match serde_json::from_str(arg).unwrap() {
                 Loaded => {
                     web_view.eval("showMiningIndicator(false);").expect("Error evaluating!");
                     let handle = web_view.handle();
                     let mut c = context.lock().unwrap();
                     c.bus.register(move |_uuid, e| {
-                        println!("Got event from bus {:?}", &e);
+                        debug!("Got event from bus {:?}", &e);
                         let eval = match e {
                             Event::KeyCreated { path, public } => { format!("keystoreChanged('{}', '{}');", &path, &public) }
                             Event::KeyLoaded { path, public } => { format!("keystoreChanged('{}', '{}');", &path, &public) }
@@ -176,7 +189,7 @@ fn run_interface(context: Arc<Mutex<Context>>, miner: Arc<Mutex<Miner>>) {
                         };
 
                         if !eval.is_empty() {
-                            println!("Evaluating {}", &eval);
+                            debug!("Evaluating {}", &eval);
                             handle.dispatch(move |web_view| {
                                 web_view.eval(&eval.replace("\\", "\\\\"))
                             }).expect("Error dispatching!");
@@ -184,7 +197,7 @@ fn run_interface(context: Arc<Mutex<Context>>, miner: Arc<Mutex<Miner>>) {
                         true
                     });
                     let eval = format!("keystoreChanged('{}', '{}');", c.keystore.get_path(), &c.keystore.get_public().to_string());
-                    println!("Evaluating {}", &eval);
+                    debug!("Evaluating {}", &eval);
                     web_view.eval(&eval.replace("\\", "\\\\")).expect("Error evaluating!");
                 }
                 LoadKey {} => {
@@ -194,10 +207,10 @@ fn run_interface(context: Arc<Mutex<Context>>, miner: Arc<Mutex<Miner>>) {
                         Some(file_name) => {
                             match Keystore::from_file(&file_name, "") {
                                 None => {
-                                    println!("Error loading keystore '{}'!", &file_name);
+                                    error!("Error loading keystore '{}'!", &file_name);
                                 },
                                 Some(keystore) => {
-                                    println!("Loaded keystore with key: {:?}", &keystore.get_public());
+                                    info!("Loaded keystore with key: {:?}", &keystore.get_public());
                                     let mut c = context.lock().unwrap();
                                     c.bus.post(Event::KeyLoaded {path: keystore.get_path().to_owned(), public: keystore.get_public().to_string()});
                                     c.set_keystore(keystore);
@@ -218,7 +231,7 @@ fn run_interface(context: Arc<Mutex<Context>>, miner: Arc<Mutex<Miner>>) {
                             let path = new_path.clone();
                             let public = c.keystore.get_public().to_string();
                             c.keystore.save(&new_path, "");
-                            println!("Key file saved to {}", &path);
+                            info!("Key file saved to {}", &path);
                             c.bus.post(Event::KeySaved {path, public });
                         }
                     }
@@ -229,7 +242,7 @@ fn run_interface(context: Arc<Mutex<Context>>, miner: Arc<Mutex<Miner>>) {
                     web_view.eval(&format!("domainAvailable({})", available)).expect("Error evaluating!");
                 }
                 CreateDomain { name, records, .. } => {
-                    println!("Got records: {}", records);
+                    debug!("Got records: {}", records);
                     if serde_json::from_str::<Vec<DnsRecord>>(&records).is_ok() {
                         let keystore = {
                             let guard = context.lock().unwrap();
@@ -237,7 +250,7 @@ fn run_interface(context: Arc<Mutex<Context>>, miner: Arc<Mutex<Miner>>) {
                         };
                         create_domain(miner.clone(), name, records, &keystore);
                     } else {
-                        println!("Error in DNS records for domain!");
+                        warn!("Error in DNS records for domain!");
                         web_view.eval(&format!("showWarning('{}');", "Something wrong with your records! Please, correct the error and try again."));
                     }
                 }
@@ -266,7 +279,7 @@ fn create_genesis<S: Into<String>>(miner: Arc<Mutex<Miner>>, name: S, keystore:
 
 fn create_domain<S: Into<String>>(miner: Arc<Mutex<Miner>>, name: S, data: S, keystore: &Keystore) {
     let name = name.into();
-    println!("Generating domain {}", name);
+    info!("Generating domain or zone {}", name);
     //let rec_vector: Vec<String> = records.into().trim().split("\n").map(|s| s.trim()).map(String::from).collect();
     //let tags_vector: Vec<String> = tags.into().trim().split(",").map(|s| s.trim()).map(String::from).collect();
     let transaction = create_transaction(keystore, name, "domain".into(), data.into());
@@ -296,10 +309,10 @@ fn create_key(context: Arc<Mutex<Context>>) {
             miners_count.fetch_add(1, Ordering::Relaxed);
             match generate_key(KEYSTORE_DIFFICULTY, mining.clone()) {
                 None => {
-                    println!("Keystore mining finished");
+                    debug!("Keystore mining finished");
                 }
                 Some(keystore) => {
-                    println!("Key mined successfully: {:?}", &keystore.get_public());
+                    info!("Key mined successfully: {:?}", &keystore.get_public());
                     let mut c = context.lock().unwrap();
                     mining.store(false,Ordering::Relaxed);
                     c.bus.post(Event::KeyCreated {path: keystore.get_path().to_owned(), public: keystore.get_public().to_string()});
@@ -327,7 +340,7 @@ fn generate_key(difficulty: usize, mining: Arc<AtomicBool>) -> Option<Keystore>
         rng.fill_bytes(&mut buf);
         let keystore = Keystore::from_bytes(&buf);
         if keystore.hash_is_good(difficulty) {
-            println!("Generated keypair: {:?}", &keystore);
+            info!("Generated keypair: {:?}", &keystore);
             return Some(keystore);
         }
         if !mining.load(Ordering::Relaxed) {
@@ -347,7 +360,7 @@ fn create_server_context(context: Arc<Mutex<Context>>, settings: &Settings) -> A
     server_context.filters.push(Box::new(BlockchainFilter::new(context)));
     match server_context.initialize() {
         Ok(_) => {}
-        Err(e) => { panic!("Server failed to initialize: {:?}", e); }
+        Err(e) => { panic!("DNS server failed to initialize: {:?}", e); }
     }
 
     Arc::new(server_context)

src/miner.rs

@@ -7,6 +7,7 @@ use chrono::Utc;
 use crypto::digest::Digest;
 use crypto::sha2::Sha256;
 use num_cpus;
+use log::{trace, debug, info, warn, error};
 
 use crate::{Block, Bytes, Context, hash_is_good, Transaction};
 use crate::event::Event;
@@ -58,7 +59,7 @@ impl Miner {
 
                 let mut lock = transactions.lock().unwrap();
                 if lock.len() > 0 {
-                    println!("Got new transaction to mine");
+                    info!("Got new transaction to mine");
                     let transaction = lock.remove(0);
                     mining.store(true, Ordering::Relaxed);
                     Miner::mine_internal(context.clone(), transactions.clone(), transaction, mining.clone(), cond_var.clone());
@@ -98,7 +99,7 @@ impl Miner {
             let last_block = { context.lock().unwrap().blockchain.last_block() };
             match last_block {
                 None => {
-                    println!("Mining genesis block");
+                    warn!("Mining genesis block");
                     // Creating a block with that signed transaction
                     Block::new(0, Utc::now().timestamp(), version, Bytes::zero32(), Some(transaction.clone()))
                 },
@@ -111,7 +112,7 @@ impl Miner {
 
         let live_threads = Arc::new(AtomicU32::new(0u32));
         let cpus = num_cpus::get();
-        println!("Starting {} threads for mining", cpus);
+        debug!("Starting {} threads for mining", cpus);
         for _ in 0..cpus {
             let transactions = transactions.clone();
             let context = context.clone();
@@ -124,7 +125,7 @@ impl Miner {
                 live_threads.fetch_add(1, Ordering::Relaxed);
                 match find_hash(&mut Sha256::new(), block, mining.clone()) {
                     None => {
-                        println!("Mining did not find suitable hash or was stopped");
+                        debug!("Mining did not find suitable hash or was stopped");
                         let count = live_threads.fetch_sub(1, Ordering::Relaxed);
                         // If this is the last thread, but mining was not stopped by another thread
                         if count == 0 && mining.load(Ordering::Relaxed) {
@@ -138,9 +139,9 @@ impl Miner {
                         let index = block.index;
                         let mut context = context.lock().unwrap();
                         if context.blockchain.add_block(block).is_err() {
-                            println!("Error adding mined block!");
+                            warn!("Error adding mined block!");
                             if index == 0 {
-                                println!("To mine genesis block you need to make 'origin' an empty string in config.");
+                                error!("To mine genesis block you need to make 'origin' an empty string in config.");
                             }
                         }
                         context.bus.post(Event::MinerStopped);
@@ -155,7 +156,7 @@ impl Miner {
 fn find_hash(digest: &mut dyn Digest, mut block: Block, running: Arc<AtomicBool>) -> Option<Block> {
     let mut buf: [u8; 32] = [0; 32];
     block.random = rand::random();
-    println!("Mining block {}", serde_json::to_string(&block).unwrap());
+    debug!("Mining block {}", serde_json::to_string(&block).unwrap());
     for nonce in 0..std::u64::MAX {
         if !running.load(Ordering::Relaxed) {
             return None;

src/p2p/network.rs

@@ -10,6 +10,7 @@ use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use mio::{Events, Interest, Poll, Registry, Token};
 use mio::event::Event;
 use mio::net::{TcpListener, TcpStream};
+use log::{trace, debug, info, warn, error};
 
 use crate::{Context, Block, p2p::Message, p2p::State, p2p::Peer, p2p::Peers};
 use std::net::{SocketAddr, IpAddr, SocketAddrV4, Shutdown};
@@ -38,7 +39,7 @@ impl Network {
         // Starting server socket
         let addr = listen_addr.parse().expect("Error parsing listen address");
         let mut server = TcpListener::bind(addr).expect("Can't bind to address");
-        println!("Started node listener on {}", server.local_addr().unwrap());
+        debug!("Started node listener on {}", server.local_addr().unwrap());
 
         let mut events = Events::with_capacity(64);
         let mut poll = Poll::new().expect("Unable to create poll");
@@ -60,7 +61,7 @@ impl Network {
 
                 // Process each event.
                 for event in events.iter() {
-                    println!("Event for socket {} is {:?}", event.token().0, &event);
+                    trace!("Event for socket {} is {:?}", event.token().0, &event);
                     // We can use the token we previously provided to `register` to determine for which socket the event is.
                     match event.token() {
                         SERVER => {
@@ -77,7 +78,7 @@ impl Network {
                                         }
                                     }
 
-                                    println!("Accepted connection from: {}", address);
+                                    info!("Accepted connection from: {}", address);
                                     let token = next(&mut unique_token);
                                     poll.registry().register(&mut stream, token, Interest::READABLE).expect("Error registering poll");
                                     peers.add_peer(token, Peer::new(address, stream, State::Connected, true));
@@ -98,7 +99,7 @@ impl Network {
                                                         let stream = peer.get_stream();
                                                         let _ = poll.registry().deregister(stream);
                                                         let _ = stream.shutdown(Shutdown::Both);
-                                                        println!("Peer connection {:?} has shut down", &peer.get_addr());
+                                                        info!("Peer connection {:?} has shut down", &peer.get_addr());
                                                     }
                                                 }
                                             }
@@ -108,7 +109,7 @@ impl Network {
                                         }
                                     }
                                 }
-                                None => { println!("Odd event from poll"); }
+                                None => { warn!("Odd event from poll"); }
                             }
                         }
                     }
@@ -141,7 +142,7 @@ fn handle_connection_event(context: Arc<Mutex<Context>>, peers: &mut Peers, regi
             let data = data.unwrap();
             match Message::from_bytes(data) {
                 Ok(message) => {
-                    println!("Got message from socket {}: {:?}", &event.token().0, &message);
+                    debug!("Got message from socket {}: {:?}", &event.token().0, &message);
                     let new_state = handle_message(context.clone(), message, peers, &event.token());
                     let peer = peers.get_mut_peer(&event.token()).unwrap();
                     let stream = peer.get_stream();
@@ -179,28 +180,28 @@ fn handle_connection_event(context: Arc<Mutex<Context>>, peers: &mut Peers, regi
     }
 
     if event.is_writable() {
-        //println!("Socket {} is writable", event.token().0);
+        trace!("Socket {} is writable", event.token().0);
         match peers.get_mut_peer(&event.token()) {
             None => {}
             Some(peer) => {
                 match peer.get_state().clone() {
                     State::Connecting => {
-                        println!("Sending hello to socket {}", event.token().0);
+                        debug!("Sending hello to socket {}", event.token().0);
                         let data: String = {
                             let c = context.lock().unwrap();
                             let message = Message::hand(&c.settings.origin, c.settings.version, c.settings.public);
                             serde_json::to_string(&message).unwrap()
                         };
                         send_message(peer.get_stream(), &data.into_bytes());
-                        //println!("Sent hello through socket {}", event.token().0);
+                        debug!("Sent hello through socket {}", event.token().0);
                     }
                     State::Message { data } => {
-                        println!("Sending data to socket {}: {}", event.token().0, &String::from_utf8(data.clone()).unwrap());
+                        debug!("Sending data to socket {}: {}", event.token().0, &String::from_utf8(data.clone()).unwrap());
                         send_message(peer.get_stream(), &data);
                     }
                     State::Connected => {}
                     State::Idle { from } => {
-                        println!("Odd version of pings :)");
+                        debug!("Odd version of pings :)");
                         if from.elapsed().as_secs() >= 30 {
                             let data: String = {
                                 let c = context.lock().unwrap();
@@ -227,11 +228,11 @@ fn read_message(stream: &mut TcpStream) -> Result<Vec<u8>, ()> {
     let data_size = match stream.read_u32::<BigEndian>() {
         Ok(size) => { size as usize }
         Err(e) => {
-            println!("Error reading from socket! {}", e);
+            error!("Error reading from socket! {}", e);
             0
         }
     };
-    println!("Payload size is {}", data_size);
+    trace!("Payload size is {}", data_size);
     if data_size > MAX_PACKET_SIZE {
         return Err(());
     }
@@ -255,7 +256,7 @@ fn read_message(stream: &mut TcpStream) -> Result<Vec<u8>, ()> {
             Err(ref err) if interrupted(err) => continue,
             // Other errors we'll consider fatal.
             Err(_) => {
-                println!("Error reading message, only {} bytes read", bytes_read);
+                debug!("Error reading message, only {} bytes read", bytes_read);
                 return Err(())
             },
         }
@@ -286,7 +287,7 @@ fn handle_message(context: Arc<Mutex<Context>>, message: Message, peers: &mut Pe
                 peer.set_public(public);
                 State::message(Message::shake(&origin, version, true, my_height))
             } else {
-                println!("Handshake from unsupported chain or version");
+                warn!("Handshake from unsupported chain or version");
                 State::Error
             }
         }
@@ -335,7 +336,7 @@ fn handle_message(context: Arc<Mutex<Context>>, message: Message, peers: &mut Pe
             }
         }
         Message::Block { index, block } => {
-            println!("Received block {}", index);
+            info!("Received block {}", index);
             let block: Block = match serde_json::from_str(&block) {
                 Ok(block) => block,
                 Err(_) => return State::Error
@@ -346,7 +347,7 @@ fn handle_message(context: Arc<Mutex<Context>>, message: Message, peers: &mut Pe
                 let mut context = context.lock().unwrap();
                 match context.blockchain.add_block(block) {
                     Ok(_) => { context.bus.post(crate::event::Event::BlockchainChanged); }
-                    Err(_) => { println!("Error adding received block"); }
+                    Err(_) => { warn!("Error adding received block"); }
                 }
             });
             State::idle()
@@ -360,7 +361,7 @@ fn connect_peers(peers_addrs: Vec<String>, poll: &mut Poll, peers: &mut Peers, u
         let addr: SocketAddr = peer.parse().expect(&format!("Error parsing peer address {}", &peer));
         match TcpStream::connect(addr.clone()) {
             Ok(mut stream) => {
-                println!("Created connection to peer {}", &peer);
+                info!("Created connection to peer {}", &peer);
                 let token = next(unique_token);
                 poll.registry().register(&mut stream, token, Interest::WRITABLE).unwrap();
                 let mut peer = Peer::new(addr, stream, State::Connecting, false);
@@ -368,7 +369,7 @@ fn connect_peers(peers_addrs: Vec<String>, poll: &mut Poll, peers: &mut Peers, u
                 peers.add_peer(token, peer);
             }
             Err(e) => {
-                println!("Error connecting to peer {}: {}", &peer, e);
+                error!("Error connecting to peer {}: {}", &peer, e);
             }
         }
     }

src/p2p/peers.rs

@@ -6,6 +6,7 @@ use crate::p2p::{Peer, State, Message};
 use crate::p2p::network::LISTEN_PORT;
 use crate::p2p::network::next;
 use rand::random;
+use log::{trace, debug, info, warn, error};
 
 pub struct Peers {
     peers: HashMap<Token, Peer>,
@@ -36,7 +37,7 @@ impl Peers {
     }
 
     pub fn add_peers_from_exchange(&mut self, peers: Vec<String>) {
-        println!("Got peers: {:?}", &peers);
+        info!("Got peers: {:?}", &peers);
         // TODO make it return error if these peers are wrong and seem like an attack
         for peer in peers.iter() {
             let addr: SocketAddr = peer.parse().expect(&format!("Error parsing peer {}", peer));
@@ -109,7 +110,7 @@ impl Peers {
         for addr in self.new_peers.iter() {
             match TcpStream::connect(addr.clone()) {
                 Ok(mut stream) => {
-                    println!("Created connection to peer {}", &addr);
+                    info!("Created connection to peer {}", &addr);
                     let token = next(unique_token);
                     registry.register(&mut stream, token, Interest::WRITABLE).unwrap();
                     let mut peer = Peer::new(addr.clone(), stream, State::Connecting, false);
@@ -117,7 +118,7 @@ impl Peers {
                     self.peers.insert(token, peer);
                 }
                 Err(e) => {
-                    println!("Error connecting to peer {}: {}", &addr, e);
+                    error!("Error connecting to peer {}: {}", &addr, e);
                 }
             }
         }