f cleanups jeff suggested

Author: TheBlueMatt

lightning/src/ln/channelmanager.rs

@@ -336,7 +336,7 @@ pub(super) struct ChannelHolder<Signer: Sign> {
 /// Events which we process internally, but which cannot be procsesed immediately at the
 /// generation site for some reason. They are handled in timer_chan_freshness_every_min, so may be
 /// processed with quite some time lag.
-enum BackgroundManagerEvent {
+enum BackgroundEvent {
 	/// Handle a ChannelMonitorUpdate which closes a channel, broadcasting its current latest holder
 	/// commitment transaction.
 	ClosingMonitorUpdate((OutPoint, ChannelMonitorUpdate)),
@@ -445,7 +445,7 @@ pub struct ChannelManager<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref,
 	per_peer_state: RwLock<HashMap<PublicKey, Mutex<PeerState>>>,
 
 	pending_events: Mutex<Vec<events::Event>>,
-	pending_background_events: Mutex<Vec<BackgroundManagerEvent>>,
+	pending_background_events: Mutex<Vec<BackgroundEvent>>,
 	/// Used when we have to take a BIG lock to make sure everything is self-consistent.
 	/// Essentially just when we're serializing ourselves out.
 	/// Taken first everywhere where we are making changes before any other locks.
@@ -1870,19 +1870,23 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 	/// BroadcastChannelUpdate events in timer_chan_freshness_every_min.
 	///
 	/// Expects the caller to have a total_consistency_lock read lock.
-	pub(crate) fn process_background_events(&self) {
+	fn process_background_events(&self) {
 		let mut background_events = Vec::new();
 		mem::swap(&mut *self.pending_background_events.lock().unwrap(), &mut background_events);
 		for event in background_events.drain(..) {
 			match event {
-				BackgroundManagerEvent::ClosingMonitorUpdate((funding_txo, update)) => {
+				BackgroundEvent::ClosingMonitorUpdate((funding_txo, update)) => {
 					// The channel has already been closed, so no use bothering to care about the
 					// monitor updating completing.
 					let _ = self.chain_monitor.update_channel(funding_txo, update);
 				},
 			}
 		}
 	}
+	#[cfg(any(test, feature = "_test_utils"))]
+	pub(crate) fn test_process_background_events(&self) {
+		self.process_background_events();
+	}
 
 	/// If a peer is disconnected we mark any channels with that peer as 'disabled'.
 	/// After some time, if channels are still disabled we need to broadcast a ChannelUpdate
@@ -3301,7 +3305,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 				if let ChannelMonitorUpdateStep::ChannelForceClosed { should_broadcast } = update.updates[0] {
 					assert!(should_broadcast);
 				} else { unreachable!(); }
-				self.pending_background_events.lock().unwrap().push(BackgroundManagerEvent::ClosingMonitorUpdate((funding_txo, update)));
+				self.pending_background_events.lock().unwrap().push(BackgroundEvent::ClosingMonitorUpdate((funding_txo, update)));
 			}
 			self.finish_force_close_channel(failure);
 		}
@@ -3368,7 +3372,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 				if let ChannelMonitorUpdateStep::ChannelForceClosed { should_broadcast } = update.updates[0] {
 					assert!(should_broadcast);
 				} else { unreachable!(); }
-				self.pending_background_events.lock().unwrap().push(BackgroundManagerEvent::ClosingMonitorUpdate((funding_txo, update)));
+				self.pending_background_events.lock().unwrap().push(BackgroundEvent::ClosingMonitorUpdate((funding_txo, update)));
 			}
 			self.finish_force_close_channel(failure);
 		}
@@ -3981,7 +3985,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> Writeable f
 		(background_events.len() as u64).write(writer)?;
 		for event in background_events.iter() {
 			match event {
-				BackgroundManagerEvent::ClosingMonitorUpdate((funding_txo, monitor_update)) => {
+				BackgroundEvent::ClosingMonitorUpdate((funding_txo, monitor_update)) => {
 					0u8.write(writer)?;
 					funding_txo.write(writer)?;
 					monitor_update.write(writer)?;
@@ -4214,10 +4218,10 @@ impl<'a, Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>
 		}
 
 		let background_event_count: u64 = Readable::read(reader)?;
-		let mut pending_background_events_read: Vec<BackgroundManagerEvent> = Vec::with_capacity(cmp::min(background_event_count as usize, MAX_ALLOC_SIZE/mem::size_of::<BackgroundManagerEvent>()));
+		let mut pending_background_events_read: Vec<BackgroundEvent> = Vec::with_capacity(cmp::min(background_event_count as usize, MAX_ALLOC_SIZE/mem::size_of::<BackgroundEvent>()));
 		for _ in 0..background_event_count {
 			match <u8 as Readable>::read(reader)? {
-				0 => pending_background_events_read.push(BackgroundManagerEvent::ClosingMonitorUpdate((Readable::read(reader)?, Readable::read(reader)?))),
+				0 => pending_background_events_read.push(BackgroundEvent::ClosingMonitorUpdate((Readable::read(reader)?, Readable::read(reader)?))),
 				_ => return Err(DecodeError::InvalidValue),
 			}
 		}

lightning/src/ln/functional_test_utils.rs

@@ -83,13 +83,13 @@ pub fn connect_block<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, block: &Block,
 	let txdata: Vec<_> = block.txdata.iter().enumerate().collect();
 	node.chain_monitor.chain_monitor.block_connected(&block.header, &txdata, height);
 	node.node.block_connected(&block.header, &txdata, height);
-	node.node.process_background_events();
+	node.node.test_process_background_events();
 }
 
 pub fn disconnect_block<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, header: &BlockHeader, height: u32) {
 	node.chain_monitor.chain_monitor.block_disconnected(header, height);
 	node.node.block_disconnected(header);
-	node.node.process_background_events();
+	node.node.test_process_background_events();
 }
 
 pub struct TestChanMonCfg {

lightning/src/ln/reorg_tests.rs

@@ -207,7 +207,7 @@ fn test_unconf_chan() {
 		nodes[0].node.block_disconnected(&headers.pop().unwrap());
 	}
 	check_closed_broadcast!(nodes[0], false);
-	nodes[0].node.process_background_events(); // Required to free the pending background monitor update
+	nodes[0].node.test_process_background_events(); // Required to free the pending background monitor update
 	check_added_monitors!(nodes[0], 1);
 	let channel_state = nodes[0].node.channel_state.lock().unwrap();
 	assert_eq!(channel_state.by_id.len(), 0);