Refactor handle_revoke_and_ack to wrapper error handling function

diff --git a/src/ln/channelmanager.rs b/src/ln/channelmanager.rs
index 82fa06de1ccedd5aedb8adc5d60879b6e8e14d53..748b71dcf64d576541c6b56c678c891b209e0c82 100644 (file)
--- a/src/ln/channelmanager.rs
+++ b/src/ln/channelmanager.rs
@@ -1847,6 +1847,58 @@ impl ChannelManager {
                Ok((revoke_and_ack, commitment_signed))
        }
 
+       fn internal_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &msgs::RevokeAndACK) -> Result<Option<msgs::CommitmentUpdate>, MsgHandleErrInternal> {
+               let (res, mut pending_forwards, mut pending_failures, chan_monitor) = {
+                       let mut channel_state = self.channel_state.lock().unwrap();
+                       match channel_state.by_id.get_mut(&msg.channel_id) {
+                               Some(chan) => {
+                                       if chan.get_their_node_id() != *their_node_id {
+                                               //TODO: here and below MsgHandleErrInternal, #153 case
+                                               return Err(MsgHandleErrInternal::send_err_msg_no_close("Got a message for a channel from the wrong node!", msg.channel_id));
+                                       }
+                                       chan.revoke_and_ack(&msg).map_err(|e| MsgHandleErrInternal::from_maybe_close(e))?
+                               },
+                               None => return Err(MsgHandleErrInternal::send_err_msg_no_close("Failed to find corresponding channel", msg.channel_id))
+                       }
+               };
+               if let Err(_e) = self.monitor.add_update_monitor(chan_monitor.get_funding_txo().unwrap(), chan_monitor) {
+                       unimplemented!();
+               }
+               for failure in pending_failures.drain(..) {
+                       self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), &failure.0, failure.1);
+               }
+
+               let mut forward_event = None;
+               if !pending_forwards.is_empty() {
+                       let mut channel_state = self.channel_state.lock().unwrap();
+                       if channel_state.forward_htlcs.is_empty() {
+                               forward_event = Some(Instant::now() + Duration::from_millis(((rng::rand_f32() * 4.0 + 1.0) * MIN_HTLC_RELAY_HOLDING_CELL_MILLIS as f32) as u64));
+                               channel_state.next_forward = forward_event.unwrap();
+                       }
+                       for forward_info in pending_forwards.drain(..) {
+                               match channel_state.forward_htlcs.entry(forward_info.short_channel_id) {
+                                       hash_map::Entry::Occupied(mut entry) => {
+                                               entry.get_mut().push(forward_info);
+                                       },
+                                       hash_map::Entry::Vacant(entry) => {
+                                               entry.insert(vec!(forward_info));
+                                       }
+                               }
+                       }
+               }
+               match forward_event {
+                       Some(time) => {
+                               let mut pending_events = self.pending_events.lock().unwrap();
+                               pending_events.push(events::Event::PendingHTLCsForwardable {
+                                       time_forwardable: time
+                               });
+                       }
+                       None => {},
+               }
+
+               Ok(res)
+       }
+
        fn internal_announcement_signatures(&self, their_node_id: &PublicKey, msg: &msgs::AnnouncementSignatures) -> Result<(), MsgHandleErrInternal> {
                let (chan_announcement, chan_update) = {
                        let mut channel_state = self.channel_state.lock().unwrap();
@@ -2097,54 +2149,7 @@ impl ChannelMessageHandler for ChannelManager {
        }
 
        fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &msgs::RevokeAndACK) -> Result<Option<msgs::CommitmentUpdate>, HandleError> {
-               let (res, mut pending_forwards, mut pending_failures, chan_monitor) = {
-                       let mut channel_state = self.channel_state.lock().unwrap();
-                       match channel_state.by_id.get_mut(&msg.channel_id) {
-                               Some(chan) => {
-                                       if chan.get_their_node_id() != *their_node_id {
-                                               return Err(HandleError{err: "Got a message for a channel from the wrong node!", action: None})
-                                       }
-                                       chan.revoke_and_ack(&msg)?
-                               },
-                               None => return Err(HandleError{err: "Failed to find corresponding channel", action: None})
-                       }
-               };
-               if let Err(_e) = self.monitor.add_update_monitor(chan_monitor.get_funding_txo().unwrap(), chan_monitor) {
-                       unimplemented!();
-               }
-               for failure in pending_failures.drain(..) {
-                       self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), &failure.0, failure.1);
-               }
-
-               let mut forward_event = None;
-               if !pending_forwards.is_empty() {
-                       let mut channel_state = self.channel_state.lock().unwrap();
-                       if channel_state.forward_htlcs.is_empty() {
-                               forward_event = Some(Instant::now() + Duration::from_millis(((rng::rand_f32() * 4.0 + 1.0) * MIN_HTLC_RELAY_HOLDING_CELL_MILLIS as f32) as u64));
-                               channel_state.next_forward = forward_event.unwrap();
-                       }
-                       for forward_info in pending_forwards.drain(..) {
-                               match channel_state.forward_htlcs.entry(forward_info.short_channel_id) {
-                                       hash_map::Entry::Occupied(mut entry) => {
-                                               entry.get_mut().push(forward_info);
-                                       },
-                                       hash_map::Entry::Vacant(entry) => {
-                                               entry.insert(vec!(forward_info));
-                                       }
-                               }
-                       }
-               }
-               match forward_event {
-                       Some(time) => {
-                               let mut pending_events = self.pending_events.lock().unwrap();
-                               pending_events.push(events::Event::PendingHTLCsForwardable {
-                                       time_forwardable: time
-                               });
-                       }
-                       None => {},
-               }
-
-               Ok(res)
+               handle_error!(self, self.internal_revoke_and_ack(their_node_id, msg), their_node_id)
        }
 
        fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &msgs::UpdateFee) -> Result<(), HandleError> {