Sweetbread/Alfis
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added a decent logging.

Browse Source
This commit is contained in:
Revertron
2021-02-20 16:28:10 +01:00
parent bf341dc802
commit 93d688c479
9 changed files with 98 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Cargo.toml
+2
View File
@@ -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
+14 -13
View File
@@ -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
+3 -1
View File
@@ -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
+2 -1
View File
@@ -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
+7 -3
View File
@@ -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() {
#[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!")
}
}
src/main.rs
+33 -20
View File
@@ -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"); }
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<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
+8 -7
View File
@@ -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
+20 -19
View File
@@ -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
+4 -3
View File
@@ -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);
}
}
}