use ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep};
use util::byte_utils;
use util::events::{EventsProvider,Event};
+use util::logger::{Logger, Record};
use std::collections::{HashMap,LinkedList};
use std::sync::{Arc, Mutex};
pending_events: Mutex<Vec<Event>>,
our_node_secret: SecretKey,
initial_syncs_sent: AtomicUsize,
+ logger: Arc<Logger>,
}
/// Manages and reacts to connection events. You probably want to use file descriptors as PeerIds.
/// PeerIds may repeat, but only after disconnect_event() has been called.
impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
- pub fn new(message_handler: MessageHandler, our_node_secret: SecretKey) -> PeerManager<Descriptor> {
+ pub fn new(message_handler: MessageHandler, our_node_secret: SecretKey, logger: Arc<Logger>) -> PeerManager<Descriptor> {
PeerManager {
message_handler: message_handler,
peers: Mutex::new(PeerHolder { peers: HashMap::new(), node_id_to_descriptor: HashMap::new() }),
pending_events: Mutex::new(Vec::new()),
our_node_secret: our_node_secret,
initial_syncs_sent: AtomicUsize::new(0),
+ logger,
}
}
match $thing {
Ok(x) => x,
Err(e) => {
- println!("Got error handling message: {}!", e.err);
if let Some(action) = e.action {
match action {
msgs::ErrorAction::UpdateFailHTLC { msg } => {
match $thing {
Ok(x) => x,
Err(_e) => {
- println!("Error decoding message");
//TODO: Handle e?
return Err(PeerHandleError{ no_connection_possible: false });
}
match $thing {
Ok(x) => x,
Err(_e) => {
- println!("Error decoding message, ignoring due to lnd spec incompatibility. See https://github.com/lightningnetwork/lnd/issues/1407");
+ log_debug!(self, "Error decoding message, ignoring due to lnd spec incompatibility. See https://github.com/lightningnetwork/lnd/issues/1407");
continue;
}
};
}
continue;
},
- Event::DisconnectPeer { ref node_id, ref msg } => {
- if let Some(mut descriptor) = peers.node_id_to_descriptor.remove(node_id) {
- if let Some(mut peer) = peers.peers.remove(&descriptor) {
- if let Some(ref msg) = *msg {
+ Event::HandleError { ref node_id, ref action } => {
+ if let Some(ref action) = *action {
+ match *action {
+ msgs::ErrorAction::UpdateFailHTLC { ref msg } => {
+ let (mut descriptor, peer) = get_peer_for_forwarding!(node_id, {
+ //TODO: Do whatever we're gonna do for handling dropped messages
+ });
+ peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg, 131)));
+ Self::do_attempt_write_data(&mut descriptor, peer);
+
+ },
+ msgs::ErrorAction::DisconnectPeer { ref msg } => {
+ if let Some(mut descriptor) = peers.node_id_to_descriptor.remove(node_id) {
+ if let Some(mut peer) = peers.peers.remove(&descriptor) {
+ if let Some(ref msg) = *msg {
+ peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg, 17)));
+ // This isn't guaranteed to work, but if there is enough free
+ // room in the send buffer, put the error message there...
+ Self::do_attempt_write_data(&mut descriptor, &mut peer);
+ }
+ }
+ descriptor.disconnect_socket();
+ self.message_handler.chan_handler.peer_disconnected(&node_id, false);
+ }
+ },
+ msgs::ErrorAction::IgnoreError => {
+ continue;
+ },
+ msgs::ErrorAction::SendErrorMessage { ref msg } => {
+ let (mut descriptor, peer) = get_peer_for_forwarding!(node_id, {
+ //TODO: Do whatever we're gonna do for handling dropped messages
+ });
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg, 17)));
- // This isn't guaranteed to work, but if there is enough free
- // room in the send buffer, put the error message there...
- Self::do_attempt_write_data(&mut descriptor, &mut peer);
- }
+ Self::do_attempt_write_data(&mut descriptor, peer);
+ },
}
- descriptor.disconnect_socket();
- self.message_handler.chan_handler.peer_disconnected(&node_id, false);
}
continue;
- },
+ }
}
upstream_events.push(event);
#[cfg(test)]
mod tests {
use ln::peer_handler::{PeerManager, MessageHandler, SocketDescriptor};
+ use ln::msgs;
use util::events;
use util::test_utils;
+ use util::logger::Logger;
use secp256k1::Secp256k1;
use secp256k1::key::{SecretKey, PublicKey};
let secp_ctx = Secp256k1::new();
let mut peers = Vec::new();
let mut rng = thread_rng();
+ let logger : Arc<Logger> = Arc::new(test_utils::TestLogger::new());
for _ in 0..peer_count {
let chan_handler = test_utils::TestChannelMessageHandler::new();
SecretKey::from_slice(&secp_ctx, &key_slice).unwrap()
};
let msg_handler = MessageHandler { chan_handler: Arc::new(chan_handler), route_handler: Arc::new(router) };
- let peer = PeerManager::new(msg_handler, node_id);
+ let peer = PeerManager::new(msg_handler, node_id, Arc::clone(&logger));
peers.push(peer);
}
let their_id = PublicKey::from_secret_key(&secp_ctx, &peers[1].our_node_secret).unwrap();
let chan_handler = test_utils::TestChannelMessageHandler::new();
- chan_handler.pending_events.lock().unwrap().push(events::Event::DisconnectPeer {
+ chan_handler.pending_events.lock().unwrap().push(events::Event::HandleError {
node_id: their_id,
- msg: None,
+ action: Some(msgs::ErrorAction::DisconnectPeer { msg: None }),
});
assert_eq!(chan_handler.pending_events.lock().unwrap().len(), 1);
peers[0].message_handler.chan_handler = Arc::new(chan_handler);