From 93d688c47978af006e43621f7db8904edd093a47 Mon Sep 17 00:00:00 2001 From: Revertron Date: Sat, 20 Feb 2021 16:28:10 +0100 Subject: [PATCH] Added a decent logging. --- Cargo.toml | 2 ++ src/blockchain/blockchain.rs | 27 +++++++++--------- src/blockchain/filter.rs | 4 ++- src/context.rs | 3 +- src/keys.rs | 20 ++++++++------ src/main.rs | 53 ++++++++++++++++++++++-------------- src/miner.rs | 15 +++++----- src/p2p/network.rs | 39 +++++++++++++------------- src/p2p/peers.rs | 7 +++-- 9 files changed, 98 insertions(+), 72 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 54e43ad..6461436 100644 --- a/Cargo.toml +++ b/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" diff --git a/src/blockchain/blockchain.rs b/src/blockchain/blockchain.rs index 99cb996..956af13 100644 --- a/src/blockchain/blockchain.rs +++ b/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::>(5).unwrap().as_slice()); let signature = Bytes::from_bytes(statement.read::>(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) -> 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) diff --git a/src/blockchain/filter.rs b/src/blockchain/filter.rs index 9be95ad..a56c981 100644 --- a/src/blockchain/filter.rs +++ b/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> @@ -17,8 +18,9 @@ impl DnsFilter for BlockchainFilter { fn lookup(&self, qname: &str, qtype: QueryType) -> Option { 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 = match serde_json::from_str(&data) { Err(_) => { return None; } Ok(records) => { records } diff --git a/src/context.rs b/src/context.rs index 2c168d9..0eba862 100644 --- a/src/context.rs +++ b/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; diff --git a/src/keys.rs b/src/keys.rs index 54cf6f6..f418614 100644 --- a/src/keys.rs +++ b/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] -pub fn test_signature() { - let keystore: Keystore = Keystore::new(); - let data = b"{ identity: 178135D209C697625E3EC71DA5C760382E54936F824EE5083908DA66B14ECE18,\ +#[cfg(test)] +mod tests { + #[test] + pub fn test_signature() { + let keystore: Keystore = Keystore::new(); + let data = b"{ identity: 178135D209C697625E3EC71DA5C760382E54936F824EE5083908DA66B14ECE18,\ confirmation: A4A0AFECD1A511825226F0D3437C6C6BDAE83554040AA7AEB49DEFEAB0AE9EA4 }"; - let signature = keystore.sign(data); - assert!(Keystore::check(data, keystore.get_public().as_bytes(), &signature), "Wrong signature!") -} + let signature = keystore.sign(data); + assert!(Keystore::check(data, keystore.get_public().as_bytes(), &signature), "Wrong signature!") + } +} \ No newline at end of file diff --git a/src/main.rs b/src/main.rs index 2fbef3e..f11e075 100644 --- a/src/main.rs +++ b/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 = 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"); } - Some(block) => { println!("Loaded DB with origin {:?}", &block.hash); } + None => { info!("No blocks found in DB"); } + Some(block) => { info!("Loaded DB with origin {:?}", &block.hash); } } let settings_copy = settings.clone(); let context: Arc> = Arc::new(Mutex::new(Context::new(settings, keystore, blockchain))); @@ -116,14 +129,14 @@ fn start_dns_server(context: &Arc>, 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>, miner: Arc>) { .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>, miner: Arc>) { }; 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>, miner: Arc>) { 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>, miner: Arc>) { 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>, miner: Arc>) { 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>, miner: Arc>) { 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::>(&records).is_ok() { let keystore = { let guard = context.lock().unwrap(); @@ -237,7 +250,7 @@ fn run_interface(context: Arc>, miner: Arc>) { }; 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>(miner: Arc>, name: S, keystore: fn create_domain>(miner: Arc>, name: S, data: S, keystore: &Keystore) { let name = name.into(); - println!("Generating domain {}", name); + info!("Generating domain or zone {}", name); //let rec_vector: Vec = records.into().trim().split("\n").map(|s| s.trim()).map(String::from).collect(); //let tags_vector: Vec = 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>) { 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) -> Option 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>, 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) diff --git a/src/miner.rs b/src/miner.rs index cf86700..90e87e6 100644 --- a/src/miner.rs +++ b/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) -> Option { 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; diff --git a/src/p2p/network.rs b/src/p2p/network.rs index ca080ac..7cb3287 100644 --- a/src/p2p/network.rs +++ b/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>, 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>, 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, ()> { let data_size = match stream.read_u32::() { 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, ()> { 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>, 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>, 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>, 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, 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, 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); } } } diff --git a/src/p2p/peers.rs b/src/p2p/peers.rs index c079b97..1321ced 100644 --- a/src/p2p/peers.rs +++ b/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, @@ -36,7 +37,7 @@ impl Peers { } pub fn add_peers_from_exchange(&mut self, peers: Vec) { - 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); } } }