diff --git a/.travis.yml b/.travis.yml index ad316e6..32de9c8 100644 --- a/.travis.yml +++ b/.travis.yml @@ -24,7 +24,7 @@ install: # load travis-cargo before_script: - | - cargo install cargo-travis && + (cargo install cargo-travis || true) && export PATH=$HOME/.cargo/bin:$PATH # the main build diff --git a/bitcrustd/Cargo.toml b/bitcrustd/Cargo.toml index dd8720c..7d656b4 100644 --- a/bitcrustd/Cargo.toml +++ b/bitcrustd/Cargo.toml @@ -6,8 +6,8 @@ authors = ["Chris MacNaughton "] [dependencies] bitcrust-net = {path = "../net"} clap = "~2.25" -simple_logger = "*" -log = "0.3" +slog = { version = "1.3.2", features = ["max_level_trace", "release_max_level_info"] } +slog-term = "1.3.2" multiqueue = "~0.3.2" ring = "0.12" serde_derive = "1.0" diff --git a/bitcrustd/src/config.rs b/bitcrustd/src/config.rs index 8da2350..8427524 100644 --- a/bitcrustd/src/config.rs +++ b/bitcrustd/src/config.rs @@ -5,9 +5,12 @@ use std::io::{Read, Write}; use std::path::PathBuf; use clap::{App, Arg, ArgMatches, SubCommand}; -use log::LogLevel; +use slog::Level; use ring::{digest, rand, hmac}; use ring::rand::SecureRandom; +use slog; +use slog_term; +use slog::DrainExt; use toml; #[cfg(test)] @@ -49,7 +52,8 @@ pub struct ConfigFile { } pub struct Config { - pub log_level: LogLevel, + pub logger: slog::Logger, + pub log_level: Level, raw_key: [u8; 32], signing_key: hmac::SigningKey } @@ -57,10 +61,10 @@ pub struct Config { impl<'a, 'b> Config { pub fn from_args(matches: &ArgMatches) -> Config { let log_level = match matches.occurrences_of("debug") { - 0 => LogLevel::Warn, - 1 => LogLevel::Info, - 2 => LogLevel::Debug, - 3 | _ => LogLevel::Trace, + 0 => Level::Warning, + 1 => Level::Info, + 2 => Level::Debug, + 3 | _ => Level::Trace, }; let config_file_path: PathBuf = matches.value_of("config").map(|p| PathBuf::from(&p)).unwrap_or_else(|| { let mut path = home_dir().expect("Can't figure out where your $HOME is"); @@ -82,6 +86,7 @@ impl<'a, 'b> Config { a.copy_from_slice(&config_from_file.key); Config { + logger: slog::Logger::root(slog_term::streamer().compact().build().fuse(), o!()), log_level: log_level, raw_key: a, signing_key: key, @@ -148,7 +153,8 @@ impl Clone for Config { Config { log_level: self.log_level, raw_key: self.raw_key, - signing_key: hmac::SigningKey::new(&digest::SHA256, &self.raw_key) + signing_key: hmac::SigningKey::new(&digest::SHA256, &self.raw_key), + logger: self.logger.clone(), } } } \ No newline at end of file diff --git a/bitcrustd/src/main.rs b/bitcrustd/src/main.rs index 695f212..7734aaa 100644 --- a/bitcrustd/src/main.rs +++ b/bitcrustd/src/main.rs @@ -1,9 +1,9 @@ #[macro_use] extern crate clap; #[macro_use] -extern crate log; +extern crate slog; +extern crate slog_term; extern crate bitcrust_net; -extern crate simple_logger; extern crate multiqueue; extern crate ring; extern crate rusqlite; @@ -33,7 +33,7 @@ fn main() { match matches.subcommand() { ("node", Some(node_matches)) => { - simple_logger::init_with_level(config.log_level).expect("Couldn't initialize logger"); + // simple_logger::init_with_level(config.log_level).expect("Couldn't initialize logger"); node(node_matches, &config); } ("balance", Some(balance_matches)) => { @@ -70,7 +70,7 @@ fn stats(matches: &ArgMatches, config: &Config) { } fn connected_peers(_matches: &ArgMatches, config: &Config, host: String) { - let connection = BitcoinNetworkConnection::new(host.clone()) + let connection = BitcoinNetworkConnection::new(host.clone(), &config.logger) .expect(&format!("Couldn't connect to a node running on {}", host)); let _ = connection.try_send(peer::Peer::version()); loop { @@ -95,7 +95,7 @@ fn connected_peers(_matches: &ArgMatches, config: &Config, host: String) { let auth = AuthenticatedBitcrustMessage::create(config.key()); match connection.try_send(Message::BitcrustPeerCountRequest(auth)) { Ok(_) => {}, - Err(e) => warn!("Error sending request: {:?}", e), + Err(e) => warn!(config.logger, "Error sending request: {:?}", e), } loop { if let Some(msg) = connection.try_recv() { diff --git a/bitcrustd/src/peer.rs b/bitcrustd/src/peer.rs index 71bb0a3..5b8130f 100644 --- a/bitcrustd/src/peer.rs +++ b/bitcrustd/src/peer.rs @@ -8,6 +8,7 @@ use std::str::FromStr; use std::time::{UNIX_EPOCH, SystemTime}; use multiqueue::{BroadcastReceiver, BroadcastSender}; +use slog; use bitcrust_net::{BitcoinNetworkConnection, BitcoinNetworkError, NetAddr, Message, AddrMessage, Services, VersionMessage}; @@ -44,6 +45,7 @@ pub struct Peer { closed: bool, last_read: Instant, thread_speed: Duration, + logger: slog::Logger, } impl Debug for Peer { @@ -79,19 +81,20 @@ impl Peer { pub fn new>(host: T, sender: &BroadcastSender, receiver: &BroadcastReceiver, - config: &Config) + config: &Config, logger: &slog::Logger) -> Result { - Peer::new_with_addrs(host, HashSet::with_capacity(1000), sender, receiver, config) + Peer::new_with_addrs(host, HashSet::with_capacity(1000), sender, receiver, config, logger) } pub fn with_stream>(host: T, socket: TcpStream, sender: &BroadcastSender, receiver: &BroadcastReceiver, - config: &Config) -> Result { + config: &Config, logger: &slog::Logger) -> Result { let host = host.into(); - debug!("Initialized incoming peer with host: {}", host); - let connection = BitcoinNetworkConnection::with_stream(host.clone(), socket)?; + let logger = logger.new(o!("host" => host.clone())); + debug!(logger, "Initialized incoming peer with host: {}", host); + let connection = BitcoinNetworkConnection::with_stream(host.clone(), socket, &logger)?; Ok(Peer { config: config.clone(), host: host, @@ -110,6 +113,7 @@ impl Peer { last_read: Instant::now(), closed: false, thread_speed: Duration::from_millis(250), + logger: logger, }) } @@ -117,10 +121,11 @@ impl Peer { addrs: HashSet, sender: &BroadcastSender, receiver: &BroadcastReceiver, - config: &Config) + config: &Config, logger: &slog::Logger) -> Result { let host = host.into(); - let connection = BitcoinNetworkConnection::new(host.clone())?; + let logger = logger.new(o!("host" => host.clone())); + let connection = BitcoinNetworkConnection::new(host.clone(), &logger)?; Ok(Peer { config: config.clone(), host: host, @@ -139,6 +144,7 @@ impl Peer { last_read: Instant::now(), closed: false, thread_speed: Duration::from_millis(250), + logger: logger, }) } @@ -152,7 +158,7 @@ impl Peer { match message { Message::Version(_) => {} _ => { - debug!("Received {:?} prior to VERSION", message); + debug!(self.logger, "Received {:?} prior to VERSION", message); return; } } @@ -181,7 +187,7 @@ impl Peer { } Message::FeeFilter(_fee) => {} Message::Ping(nonce) => { - debug!("[{}] Ping", self.host); + debug!(self.logger, "[{}] Ping", self.host); let _ = self.send(Message::Pong(nonce)); } Message::Pong(_nonce) => {} @@ -215,7 +221,7 @@ impl Peer { // Support for alert messages has been removed from bitcoin core in March 2016. // Read more at https://github.com/bitcoin/bitcoin/pull/7692 if name != "alert" { - debug!("{} : Not handling {} yet ({:?})", + debug!(self.logger, "{} : Not handling {} yet ({:?})", self.host, name, to_hex_string(&message)) @@ -227,14 +233,14 @@ impl Peer { let count = self.peers_connected; let _ = self.send(Message::BitcrustPeerCount(count)); } else { - warn!("Message: {:?}", msg); - warn!("Invalid authenticated request!"); + warn!(self.logger, "Message: {:?}", msg); + warn!(self.logger, "Invalid authenticated request!"); self.closed = true; } } Message::BitcrustPeerCount(_count) => {} _ => { - debug!("Not handling {:?} yet", message); + debug!(self.logger, "Not handling {:?} yet", message); } }; } @@ -265,7 +271,7 @@ impl Peer { }; if self.inbound_messages > 0 { if self.bad_messages >= self.inbound_messages * 2 { - warn!("{} sent us {} requests, and {} bad ones", + warn!(self.logger, "{} sent us {} requests, and {} bad ones", self.host, self.inbound_messages, self.bad_messages); diff --git a/bitcrustd/src/peer_manager.rs b/bitcrustd/src/peer_manager.rs index ca827c2..33405b0 100644 --- a/bitcrustd/src/peer_manager.rs +++ b/bitcrustd/src/peer_manager.rs @@ -9,6 +9,7 @@ use std::thread; use multiqueue::{BroadcastReceiver, BroadcastSender, broadcast_queue}; use rusqlite::{Error, Connection}; +use slog; use bitcrust_net::{NetAddr, Services}; use client_message::ClientMessage; @@ -22,6 +23,7 @@ pub struct PeerManager { sender: BroadcastSender, receiver: BroadcastReceiver, peers: Vec<(String, thread::JoinHandle<()>)>, + logger: slog::Logger, } //pub time: Option, @@ -32,10 +34,12 @@ pub struct PeerManager { impl PeerManager { pub fn new(config: &Config) -> PeerManager { let mut path = home_dir().expect("Can't figure out where your $HOME is"); + let logger = config.logger.new(o!("PeerManager" => 1)); + path.push(".bitcrust.dat"); - debug!("Connecting to DB at {:?}", path); + debug!(logger, "Connecting to DB at {:?}", path); let db = Connection::open(path).expect("Couldn't open SQLite connection"); - debug!("Have a database connection"); + debug!(logger, "Have a database connection"); db.execute(" CREATE TABLE IF NOT EXISTS peers ( time \ @@ -68,13 +72,14 @@ impl PeerManager { .collect(); addrs }; - info!("Pulled {} addrs from the database", addrs.len()); + info!(logger, "Pulled {} addrs from the database", addrs.len()); let (sender, receiver) = broadcast_queue(200); - debug!("Setup peers"); + debug!(logger, "Setup peers"); PeerManager { + logger: logger, config: config.clone(), database: db, addrs: addrs, @@ -85,7 +90,7 @@ impl PeerManager { } pub fn execute(&mut self) -> ! { - debug!("Executing!"); + debug!(self.logger, "Executing!"); let (sender, receiver) = channel(); let peer_sender = self.sender.clone(); @@ -94,9 +99,10 @@ impl PeerManager { let sleep_duration = Duration::from_millis(200); let connected_peers = Arc::new(Mutex::new(0)); let listener_peers = connected_peers.clone(); + let logger = self.logger.clone(); thread::spawn(move || { let sender = sender.clone(); - info!("Spawning listener"); + info!(logger, "Spawning listener"); let listener = TcpListener::bind("0.0.0.0:8333").unwrap(); // accept connections and process them serially @@ -106,27 +112,27 @@ impl PeerManager { Ok((socket, addr)) => { let host = format!("{}", addr); let addr = NetAddr::from_socket_addr(addr); - match Peer::with_stream(host, socket, &peer_sender, &peer_receiver, &peer_config, ) { + match Peer::with_stream(host, socket, &peer_sender, &peer_receiver, &peer_config, &logger) { Ok(mut peer) => { - debug!("new client: {:?}", peer); + debug!(logger, "new client: {:?}", peer); if let Ok(peers) = listener_peers.try_lock() { peer.connected_peers(*peers); } let _ = sender.send((addr, peer.run(false))); } Err(e) => { - debug!("Some error happened while creating the Peer: {:?}", e); + debug!(logger, "Some error happened while creating the Peer: {:?}", e); } } } - Err(e) => debug!("couldn't get client: {:?}", e), + Err(e) => debug!(logger, "couldn't get client: {:?}", e), } } }); // self.initialize_peers(); let mut recieved = false; loop { - trace!("Currently connected to {}/{} peers", + trace!(self.logger, "Currently connected to {}/{} peers", self.peers.len(), self.addrs.len()); @@ -150,7 +156,7 @@ impl PeerManager { TryRecvError::Empty => { // thread::sleep_ms(200); } - TryRecvError::Disconnected => trace!("Remote end has disconnected?"), + TryRecvError::Disconnected => trace!(self.logger, "Remote end has disconnected?"), } @@ -164,13 +170,13 @@ impl PeerManager { Ok((addr, peer_handle)) => { let _ = self.update_time(&addr); self.peers.push((addr.to_host(), peer_handle)); - debug!("Connected to a new inbound peer"); + debug!(self.logger, "Connected to a new inbound peer"); recieved = true; } Err(e) => { match e { TryRecvError::Empty => {} - TryRecvError::Disconnected => trace!("Listener has disconnected?"), + TryRecvError::Disconnected => trace!(self.logger, "Listener has disconnected?"), } } } @@ -189,11 +195,11 @@ impl PeerManager { } fn addr_message(&mut self, addrs: Vec) { - info!("Peer sent us {} new addrs", addrs.len()); + info!(self.logger, "Peer sent us {} new addrs", addrs.len()); for addr in addrs.into_iter() { match self.add_addr(addr) { Ok(_) => {} - Err(e) => warn!("Error adding addr: {:?}", e), + Err(e) => warn!(self.logger, "Error adding addr: {:?}", e), } } } @@ -216,19 +222,19 @@ impl PeerManager { if self.peers.len() >= 100 { break; } - match Peer::new(&host[..], &self.sender, &self.receiver, &self.config) { + match Peer::new(&host[..], &self.sender, &self.receiver, &self.config, &self.logger) { Ok(peer) => { let _ = self.update_time(addr); self.peers.push((host.to_string(), peer.run(true))); if let Ok(mut peers) = connected_peers.try_lock() { *peers += 1; } - debug!("Self.peers.len(): {}", self.peers.len()); + debug!(self.logger, "Self.peers.len(): {}", self.peers.len()); } Err(e) => { - debug!("Failed to connect to peer at {} :: {:?}", addr.ip, e); + debug!(self.logger, "Failed to connect to peer at {} :: {:?}", addr.ip, e); let r = self.remove_addr(&addr); - debug!("Removing addr res: {:?}", r); + debug!(self.logger, "Removing addr res: {:?}", r); } }; } @@ -244,11 +250,11 @@ impl PeerManager { ] .iter() { // info!("Trying to connect") - match Peer::new(*hostname, &self.sender, &self.receiver, &self.config) { + match Peer::new(*hostname, &self.sender, &self.receiver, &self.config, &self.logger) { Ok(peer) => { self.peers.push((hostname.to_string(), peer.run(true))); } - Err(e) => warn!("Error connecting to {}: {:?}", hostname, e), + Err(e) => warn!(self.logger, "Error connecting to {}: {:?}", hostname, e), } } @@ -292,7 +298,7 @@ impl PeerManager { .prepare("UPDATE peers SET time = ? WHERE ip = ? AND port = ?") { Ok(s) => s, Err(e) => { - warn!("Couldn't prepare peer: {:?}", e); + warn!(self.logger, "Couldn't prepare peer: {:?}", e); return None; } }; @@ -301,7 +307,7 @@ impl PeerManager { &format!("{}", addr.port)]) { Ok(s) => s, Err(e) => { - warn!("Couldn't update addr's time: {:?}", e); + warn!(self.logger, "Couldn't update addr's time: {:?}", e); return None; } }; diff --git a/net/Cargo.toml b/net/Cargo.toml index 265834e..b772a0c 100644 --- a/net/Cargo.toml +++ b/net/Cargo.toml @@ -10,7 +10,8 @@ authors = [ bitflags = "0.7" circular = "~0.2" byteorder = "1" -log = "0.3" +slog = { version = "1.3.2", features = ["max_level_trace", "release_max_level_info"] } +slog-term = "1.3.2" multiqueue = "~0.3.2" # nom = "^2.2" rand = "0.3" diff --git a/net/src/bitcoin_network_connection.rs b/net/src/bitcoin_network_connection.rs index f73318f..27af8c7 100644 --- a/net/src/bitcoin_network_connection.rs +++ b/net/src/bitcoin_network_connection.rs @@ -6,11 +6,13 @@ use std::time::{Duration}; use circular::Buffer; use nom::{ErrorKind, Err, IResult, Needed}; +use slog; use message::Message; use parser::message; pub struct BitcoinNetworkConnection { + logger: slog::Logger, host: String, buffer: RefCell, socket: RefCell, @@ -26,8 +28,9 @@ pub enum BitcoinNetworkError { } impl BitcoinNetworkConnection { - pub fn new(host: String) -> Result { - info!("Trying to initialize connection to {}", host); + pub fn new(host: String, logger: &slog::Logger) -> Result { + let logger = logger.new(o!("host" => host.clone())); + info!(logger, "Trying to initialize connection to {}", host); let addrs: Vec<_> = host.to_socket_addrs()? .collect(); let mut socket = None; @@ -45,18 +48,12 @@ impl BitcoinNetworkConnection { socket.set_read_timeout(Some(Duration::from_secs(2)))?; // .expect("set_read_timeout call failed"); socket.set_write_timeout(Some(Duration::from_secs(2)))?; - - Ok(BitcoinNetworkConnection { - host: host, - // Allocate a buffer with 4MB of capacity - buffer: RefCell::new(Buffer::with_capacity(1024 * 1024 * 4)), - socket: RefCell::new(socket), - needed: RefCell::new(0), - bad_messages: RefCell::new(0), - }) + + BitcoinNetworkConnection::with_stream(host, socket, &logger) } - pub fn with_stream(host: String, socket: TcpStream) -> Result { + pub fn with_stream(host: String, socket: TcpStream, logger: &slog::Logger) -> Result { + let logger = logger.new(o!("host" => host.clone())); socket.set_read_timeout(Some(Duration::from_secs(2)))?; // .expect("set_read_timeout call failed"); socket.set_write_timeout(Some(Duration::from_secs(2)))?; @@ -68,6 +65,7 @@ impl BitcoinNetworkConnection { socket: RefCell::new(socket), needed: RefCell::new(0), bad_messages: RefCell::new(0), + logger: logger, }) } @@ -79,9 +77,9 @@ impl BitcoinNetworkConnection { // } pub fn try_send(&self, message: Message) -> Result<(), Error> { - trace!("{} About to write: {:?}", self.host, message); + trace!(self.logger, "{} About to write: {:?}", self.host, message); let written = self.socket.borrow_mut().write(&message.encode(false))?; - trace!("{} Written: {:}", self.host, written); + trace!(self.logger, "{} Written: {:}", self.host, written); Ok(()) } @@ -91,7 +89,7 @@ impl BitcoinNetworkConnection { pub fn try_recv(&self) -> Option> { let len = self.buffer.borrow().available_data(); - trace!("[{}] Buffer len: {}", self.host, len); + trace!(self.logger, "[{}] Buffer len: {}", self.host, len); if let Some(message) = self.try_parse() { return Some(message); } @@ -123,7 +121,7 @@ impl BitcoinNetworkConnection { } let mut trim = false; let mut consume = 0; - let parsed = match message(&self.buffer.borrow().data(), &self.host) { + let parsed = match message(&self.buffer.borrow().data(), &self.host, &self.logger) { IResult::Done(remaining, msg) => Some((msg, remaining.len())), IResult::Incomplete(len) => { if let Needed::Size(s) = len { @@ -134,7 +132,7 @@ impl BitcoinNetworkConnection { IResult::Error(e) => { match e { Err::Code(ErrorKind::Custom(i)) => { - warn!("{} Gave us bad data!", self.host); + warn!(self.logger, "{} Gave us bad data!", self.host); consume = i; trim = true; } @@ -177,7 +175,7 @@ impl BitcoinNetworkConnection { // if read == 0 { // return; // } - trace!("[{} / {}] Read: {}, Need: {}", + trace!(self.logger, "[{} / {}] Read: {}, Need: {}", self.buffer.borrow().available_data(), self.buffer.borrow().capacity(), read, diff --git a/net/src/lib.rs b/net/src/lib.rs index d64ac13..fcb40d1 100644 --- a/net/src/lib.rs +++ b/net/src/lib.rs @@ -5,7 +5,8 @@ extern crate bitflags; extern crate byteorder; extern crate circular; #[macro_use] -extern crate log; +extern crate slog; +extern crate slog_term; extern crate multiqueue; #[macro_use] extern crate nom; diff --git a/net/src/message/mod.rs b/net/src/message/mod.rs index 0e386fc..888a692 100644 --- a/net/src/message/mod.rs +++ b/net/src/message/mod.rs @@ -34,6 +34,11 @@ mod tests { use std::str::FromStr; use std::net::Ipv6Addr; + + use slog; + use slog_term; + use slog::DrainExt; + use net_addr::NetAddr; use super::*; use services::Services; @@ -41,6 +46,7 @@ mod tests { use parser::message; #[test] fn it_parses_a_version_message() { + let l = slog::Logger::root(slog_term::streamer().compact().build().fuse(), o!()); // taken from my Satoshi client's response on 25 April, 2017 let input = [0xF9, 0xBE, 0xB4, 0xD9, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x00, 0x00, 0x00, @@ -118,7 +124,7 @@ mod tests { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]; - let res = message(&input, &"test".to_string()); + let res = message(&input, &"test".to_string(), &l); println!("Message: {:?}", res); res.unwrap(); // assert!(res.is_ok()) diff --git a/net/src/parser.rs b/net/src/parser.rs index 35f5c3a..efc38ce 100644 --- a/net/src/parser.rs +++ b/net/src/parser.rs @@ -3,6 +3,7 @@ use std::net::Ipv6Addr; use nom; use nom::{le_u16, le_u32, le_u64, le_i32, le_i64, be_u16, IResult}; use sha2::{Sha256, Digest}; +use slog; use message::Message; use message::{ @@ -93,12 +94,12 @@ named!(header
, message_type: take_str!(12) >> payload_len: le_u32 >> checksum: take!(4) >> - ({trace!("message_type: {:?}\tpayload len: {}", message_type, payload_len); Header { + (Header { network: magic, message_type: message_type.trim_matches(0x00 as char).into(), len: payload_len, checksum: checksum, - }}) + }) )); #[inline] @@ -106,23 +107,23 @@ named!(raw_message, do_parse!( header: header >> body: take!(header.len) >> - ({trace!("Body.len: {}", body.len()); + ( RawMessage { network: header.network, message_type: header.message_type, //.trim_matches(0x00 as char).into(), len: header.len, checksum: header.checksum, body: body - }} + } ) )); -pub fn message<'a>(i: &'a [u8], name: &String) -> IResult<&'a [u8], Message> { +pub fn message<'a>(i: &'a [u8], name: &String, logger: &slog::Logger) -> IResult<&'a [u8], Message> { let raw_message_result = raw_message(&i); match raw_message_result { IResult::Done(i, raw_message) => { if !raw_message.valid() { - warn!("Invalid message from {}\n\t{:?}", name, raw_message); + warn!(logger, "Invalid message from {}\n\t{:?}", name, raw_message); // return IResult::Error(nom::ErrorKind::Custom(0)); return IResult::Error(nom::Err::Code(nom::ErrorKind::Custom(raw_message.len + 20))); } @@ -566,32 +567,37 @@ named!(pub addr, #[cfg(test)] mod parse_tests { + use slog_term; use super::*; mod simple_messages { + use slog::DrainExt; use super::*; #[test] fn it_parses_ping(){ + let l = slog::Logger::root(slog_term::streamer().compact().build().fuse(), o!()); let input = Message::Ping(12); let encoded = input.encode(false); - let parsed = message(&encoded, &"".to_string()).unwrap().1; + let parsed = message(&encoded, &"".to_string(), &l).unwrap().1; assert_eq!(input, parsed); } #[test] fn it_parses_pong(){ + let l = slog::Logger::root(slog_term::streamer().compact().build().fuse(), o!()); let input = Message::Pong(12); let encoded = input.encode(false); - let parsed = message(&encoded, &"".to_string()).unwrap().1; + let parsed = message(&encoded, &"".to_string(), &l).unwrap().1; assert_eq!(input, parsed); } #[test] fn it_parses_feefilter(){ + let l = slog::Logger::root(slog_term::streamer().compact().build().fuse(), o!()); let input = Message::FeeFilter(12); let encoded = input.encode(false); - let parsed = message(&encoded, &"".to_string()).unwrap().1; + let parsed = message(&encoded, &"".to_string(), &l).unwrap().1; assert_eq!(input, parsed); } } @@ -1084,20 +1090,22 @@ mod parse_tests { mod bitcrust_messages { use super::*; - + use slog::DrainExt; #[test] fn it_parses_peer_count() { + let l = slog::Logger::root(slog_term::streamer().compact().build().fuse(), o!()); let input = Message::BitcrustPeerCount(12); let encoded = input.encode(false); - let parsed = message(&encoded, &"".to_string()).unwrap().1; + let parsed = message(&encoded, &"".to_string(), &l).unwrap().1; assert_eq!(input, parsed); } #[test] fn it_parses_peer_count_request() { + let l = slog::Logger::root(slog_term::streamer().compact().build().fuse(), o!()); let input = Message::BitcrustPeerCountRequest(AuthenticatedBitcrustMessage::default()); let encoded = input.encode(false); - let parsed = message(&encoded, &"".to_string()).unwrap().1; + let parsed = message(&encoded, &"".to_string(), &l).unwrap().1; assert_eq!(input, parsed); } @@ -1106,40 +1114,46 @@ mod parse_tests { mod messages { use super::*; + use slog::DrainExt; #[test] fn it_parses_notfound() { + let l = slog::Logger::root(slog_term::streamer().compact().build().fuse(), o!()); let input_message = Message::NotFound(NotfoundMessage{inventory: vec![InventoryVector::default()]}); let encoded = input_message.encode(false); - let parsed = message(&encoded, &"".to_string()).unwrap().1; + let parsed = message(&encoded, &"".to_string(), &l).unwrap().1; assert_eq!(input_message, parsed); } #[test] fn it_parses_block() { + let l = slog::Logger::root(slog_term::streamer().compact().build().fuse(), o!()); let input_message = Message::Block(BlockMessage::default()); let encoded = input_message.encode(false); - let parsed = message(&encoded, &"".to_string()).unwrap().1; + let parsed = message(&encoded, &"".to_string(), &l).unwrap().1; assert_eq!(input_message, parsed); } #[test] fn it_parses_sendcompact() { + let l = slog::Logger::root(slog_term::streamer().compact().build().fuse(), o!()); let input_message = Message::SendCompact(SendCmpctMessage::default()); let encoded = input_message.encode(false); - let parsed = message(&encoded, &"".to_string()).unwrap().1; + let parsed = message(&encoded, &"".to_string(), &l).unwrap().1; assert_eq!(input_message, parsed); } #[test] fn it_parses_getdata() { + let l = slog::Logger::root(slog_term::streamer().compact().build().fuse(), o!()); let input_message = Message::GetData(GetdataMessage{inventory: vec![InventoryVector::default()]}); let encoded = input_message.encode(false); - let parsed = message(&encoded, &"".to_string()).unwrap().1; + let parsed = message(&encoded, &"".to_string(), &l).unwrap().1; assert_eq!(input_message, parsed); } #[test] fn it_parses_a_tx_message() { + let l = slog::Logger::root(slog_term::streamer().compact().build().fuse(), o!()); let input = [ // Message header: 0xF9 ,0xBE ,0xB4 ,0xD9, // - main network magic bytes @@ -1193,7 +1207,7 @@ mod parse_tests { 0x00 ,0x00 ,0x00 ,0x00, // - lock time ]; - let parsed = message(&input, &"name".to_string()); + let parsed = message(&input, &"name".to_string(), &l); let (_rest, msg) = parsed.unwrap(); match msg { Message::Tx(ref tx) => { @@ -1207,6 +1221,7 @@ mod parse_tests { #[test] fn it_parses_a_version_message() { + let l = slog::Logger::root(slog_term::streamer().compact().build().fuse(), o!()); // taken from my Satoshi client's response on 25 April, 2017 let input = [0xF9, 0xBE, 0xB4, 0xD9, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00, 0x7F, 0xA7, 0xD3, 0xE8, 0x7F, 0x11, @@ -1223,13 +1238,14 @@ mod parse_tests { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]; - let res = message(&input, &"test".to_string()); + let res = message(&input, &"test".to_string(), &l); println!("Message: {:?}", res); // assert!(res.is_ok()) } #[test] fn it_parses_version_from_docs() { + let l = slog::Logger::root(slog_term::streamer().compact().build().fuse(), o!()); let input = [ // Message Header: 0xF9, 0xBE, 0xB4, 0xD9, //- Main network magic bytes @@ -1247,12 +1263,13 @@ mod parse_tests { 0x0F, 0x2F, 0x53, 0x61, 0x74, 0x6F, 0x73, 0x68, 0x69, 0x3A, 0x30, 0x2E, 0x37, 0x2E, 0x32, 0x2F, //- "/Satoshi:0.7.2/" sub-version string (string is 15 bytes long) 0xC0, 0x3E, 0x03, 0x00 //- Last block sending node has is block #212672 ]; - let output = message(&input, &"test".to_string()); + let output = message(&input, &"test".to_string(), &l); println!("Output: {:?}", output); } #[test] fn it_parses_an_addr_from_docs() { + let l = slog::Logger::root(slog_term::streamer().compact().build().fuse(), o!()); let input = [// Message Header: 0xF9, 0xBE, @@ -1312,7 +1329,7 @@ mod parse_tests { 0x20, 0x8D]; - let parsed = message(&input, &"test".to_string()); + let parsed = message(&input, &"test".to_string(), &l); println!("Parsed addr: {:?}", parsed.unwrap()); } }