Rebroadcast channel update of a force-closed channel, if needed

- This commit adds the ability to rebroadcast the channel update message
  for a force closed channel if we fail to broadcast it to any peer at
the time of closing of channel.

Author: shaavan

lightning/src/ln/channelmanager.rs

@@ -1257,6 +1257,10 @@ where
 
 	pending_offers_messages: Mutex<Vec<PendingOnionMessage<OffersMessage>>>,
 
+	/// Tracks the channel_update message that were not broadcasted because
+	/// we were not connected to any peers.
+	pending_broadcast_messages: Mutex<Vec<MessageSendEvent>>,
+
 	entropy_source: ES,
 	node_signer: NS,
 	signer_provider: SP,
@@ -2338,6 +2342,7 @@ where
 			funding_batch_states: Mutex::new(BTreeMap::new()),
 
 			pending_offers_messages: Mutex::new(Vec::new()),
+			pending_broadcast_messages: Mutex::new(Vec::new()),
 
 			entropy_source,
 			node_signer,
@@ -2841,14 +2846,30 @@ where
 		if let Some(update) = update_opt {
 			// Try to send the `BroadcastChannelUpdate` to the peer we just force-closed on, but if
 			// not try to broadcast it via whatever peer we have.
+			let brodcast_message_evt = events::MessageSendEvent::BroadcastChannelUpdate {
+				msg: update
+			};
+
 			let per_peer_state = self.per_peer_state.read().unwrap();
-			let a_peer_state_opt = per_peer_state.get(peer_node_id)
-				.ok_or(per_peer_state.values().next());
-			if let Ok(a_peer_state_mutex) = a_peer_state_opt {
-				let mut a_peer_state = a_peer_state_mutex.lock().unwrap();
-				a_peer_state.pending_msg_events.push(events::MessageSendEvent::BroadcastChannelUpdate {
-					msg: update
-				});
+
+			// Attempt to get the a_peer_state_mutex for the peer we disconnected on.
+			let a_peer_state_mutex_opt = per_peer_state.get(peer_node_id).map(|v| v);
+
+			// If the particular peer is not present. Select any random peer from the ones we are connected on.
+			let a_peer_state_mutex_opt = a_peer_state_mutex_opt.or_else(|| per_peer_state.iter().next().map(|(_, v)| v));
+
+			match a_peer_state_mutex_opt {
+				Some(a_peer_state_mutex) => {
+					let mut a_peer_state = a_peer_state_mutex.lock().unwrap();
+					a_peer_state.pending_msg_events.push(brodcast_message_evt);
+				}
+				// If we are connected to no peer.
+				None => {
+					let mut pending_broadcast_messages = self.pending_broadcast_messages.lock().unwrap();
+					pending_broadcast_messages.push(brodcast_message_evt);
+					log_info!(self.logger, "Not able to broadcast channel_update of force-closed channel right now.
+						Will try rebroadcasting later.");
+				}
 			}
 		}
 
@@ -4915,6 +4936,22 @@ where
 
 			{
 				let per_peer_state = self.per_peer_state.read().unwrap();
+
+				{
+					// Get pending messages to be broadcasted.
+					let broadcast_evts = self.pending_broadcast_messages.lock().unwrap();
+
+					// If we have some pending message to broadcast, and we are connected to peers.
+					if broadcast_evts.len() > 0 && per_peer_state.len() > 0 {
+						let a_peer_state_mutex = per_peer_state.values().next().unwrap();
+						let mut a_peer_state = a_peer_state_mutex.lock().unwrap();
+
+						a_peer_state.pending_msg_events.extend(broadcast_evts.iter().cloned());
+
+						self.pending_broadcast_messages.lock().unwrap().clear();
+					}
+				}
+
 				for (counterparty_node_id, peer_state_mutex) in per_peer_state.iter() {
 					let mut peer_state_lock = peer_state_mutex.lock().unwrap();
 					let peer_state = &mut *peer_state_lock;
@@ -10810,6 +10847,8 @@ where
 
 			pending_offers_messages: Mutex::new(Vec::new()),
 
+			pending_broadcast_messages: Mutex::new(Vec::new()),
+
 			entropy_source: args.entropy_source,
 			node_signer: args.node_signer,
 			signer_provider: args.signer_provider,