From d6726d6f26fd799e4bac7a206fd7e62f3a779b75 Mon Sep 17 00:00:00 2001
From: Antoine Riard <ariard@student.42.fr>
Date: Fri, 7 Sep 2018 21:57:06 +0000
Subject: [PATCH] Refactor handle_revoke_and_ack to wrapper error handling
 function

---
 src/ln/channelmanager.rs | 101 ++++++++++++++++++++-------------------
 1 file changed, 53 insertions(+), 48 deletions(-)

diff --git a/src/ln/channelmanager.rs b/src/ln/channelmanager.rs
index 82fa06de1..748b71dcf 100644
--- 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> {
-- 
2.39.5