From: Matt Corallo <git@bluematt.me>
Date: Mon, 22 Aug 2022 03:17:09 +0000 (+0000)
Subject: Substantially reduce boilerplate and Arcs in download_gossip
X-Git-Url: http://git.bitcoin.ninja/?a=commitdiff_plain;h=ebbd62f41d8150b31167c1f5a60efc080f2b2961;p=rapid-gossip-sync-server

Substantially reduce boilerplate and Arcs in download_gossip
---

diff --git a/src/downloader.rs b/src/downloader.rs
index 691a9e6..72e55c5 100644
--- a/src/downloader.rs
+++ b/src/downloader.rs
@@ -7,8 +7,9 @@ use lightning::util::events::{MessageSendEvent, MessageSendEventsProvider};
 use tokio::sync::mpsc;
 use tokio::sync::mpsc::error::TrySendError;
 
-use crate::{GossipChainAccess, TestLogger};
-use crate::types::GossipMessage;
+use crate::TestLogger;
+use crate::types::{GossipMessage, GossipChainAccess};
+use crate::verifier::ChainVerifier;
 
 pub(crate) struct GossipCounter {
 	pub(crate) channel_announcements: u64,
@@ -29,9 +30,20 @@ impl GossipCounter {
 }
 
 pub(crate) struct GossipRouter {
-	pub(crate) native_router: Arc<P2PGossipSync<Arc<NetworkGraph<Arc<TestLogger>>>, GossipChainAccess, Arc<TestLogger>>>,
+	native_router: P2PGossipSync<Arc<NetworkGraph<Arc<TestLogger>>>, GossipChainAccess, Arc<TestLogger>>,
 	pub(crate) counter: RwLock<GossipCounter>,
-	pub(crate) sender: mpsc::Sender<GossipMessage>,
+	sender: mpsc::Sender<GossipMessage>,
+}
+
+impl GossipRouter {
+	pub(crate) fn new(network_graph: Arc<NetworkGraph<Arc<TestLogger>>>, sender: mpsc::Sender<GossipMessage>) -> Self {
+		Self {
+			native_router: P2PGossipSync::new(network_graph, Some(Arc::new(ChainVerifier::new())),
+				Arc::new(TestLogger::new())),
+			counter: RwLock::new(GossipCounter::new()),
+			sender
+		}
+	}
 }
 
 impl MessageSendEventsProvider for GossipRouter {
diff --git a/src/lib.rs b/src/lib.rs
index c8fb6a7..e9ca343 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -27,7 +27,7 @@ use crate::lookup::DeltaSet;
 use crate::persistence::GossipPersister;
 use crate::serialization::UpdateSerializationMechanism;
 use crate::snapshot::Snapshotter;
-use crate::types::{GossipChainAccess, TestLogger};
+use crate::types::TestLogger;
 
 mod downloader;
 mod types;
diff --git a/src/snapshot.rs b/src/snapshot.rs
index 93be840..ab664ca 100644
--- a/src/snapshot.rs
+++ b/src/snapshot.rs
@@ -117,7 +117,6 @@ impl Snapshotter {
 			fs::rename(&pending_snapshot_directory, &finalized_snapshot_directory).expect("Failed to finalize snapshot directory.");
 			fs::rename(&pending_symlink_directory, &finalized_symlink_directory).expect("Failed to finalize symlink directory.");
 
-
 			let remainder = timestamp_seen % round_day_seconds;
 			let time_until_next_day = round_day_seconds - remainder;
 
diff --git a/src/tracking.rs b/src/tracking.rs
index b9dab98..af24055 100644
--- a/src/tracking.rs
+++ b/src/tracking.rs
@@ -1,5 +1,5 @@
 use std::net::SocketAddr;
-use std::sync::{Arc, RwLock};
+use std::sync::Arc;
 use std::time::{Duration, Instant};
 
 use bitcoin::hashes::hex::ToHex;
@@ -8,14 +8,13 @@ use lightning;
 use lightning::ln::peer_handler::{
 	ErroringMessageHandler, IgnoringMessageHandler, MessageHandler, PeerManager,
 };
-use lightning::routing::gossip::{NetworkGraph, P2PGossipSync};
+use lightning::routing::gossip::NetworkGraph;
 use rand::{Rng, thread_rng};
 use tokio::sync::mpsc;
 
 use crate::{config, TestLogger};
-use crate::downloader::{GossipCounter, GossipRouter};
-use crate::types::{GossipChainAccess, GossipMessage, GossipPeerManager};
-use crate::verifier::ChainVerifier;
+use crate::downloader::GossipRouter;
+use crate::types::{GossipMessage, GossipPeerManager};
 
 pub(crate) async fn download_gossip(persistence_sender: mpsc::Sender<GossipMessage>, network_graph: Arc<NetworkGraph<Arc<TestLogger>>>) {
 	let mut key = [0; 32];
@@ -24,49 +23,26 @@ pub(crate) async fn download_gossip(persistence_sender: mpsc::Sender<GossipMessa
 	thread_rng().fill_bytes(&mut random_data);
 	let our_node_secret = SecretKey::from_slice(&key).unwrap();
 
-	let _arc_chain_access = None::<GossipChainAccess>;
-	let arc_chain_access = Some(Arc::new(ChainVerifier::new()));
-	let ignorer = IgnoringMessageHandler {};
-	let arc_ignorer = Arc::new(ignorer);
-
-	let errorer = ErroringMessageHandler::new();
-	let arc_errorer = Arc::new(errorer);
-
-	let logger = TestLogger::new();
-	let arc_logger = Arc::new(logger);
-
-	let router = P2PGossipSync::new(
-		network_graph.clone(),
-		arc_chain_access,
-		Arc::clone(&arc_logger),
-	);
-	let arc_router = Arc::new(router);
-	let wrapped_router = GossipRouter {
-		native_router: arc_router,
-		counter: RwLock::new(GossipCounter::new()),
-		sender: persistence_sender.clone(),
-	};
-	let arc_wrapped_router = Arc::new(wrapped_router);
+	let router = Arc::new(GossipRouter::new(network_graph, persistence_sender.clone()));
 
 	let message_handler = MessageHandler {
-		chan_handler: arc_errorer,
-		route_handler: arc_wrapped_router.clone(),
+		chan_handler: ErroringMessageHandler::new(),
+		route_handler: Arc::clone(&router),
 	};
-	let peer_handler = PeerManager::new(
+	let peer_handler = Arc::new(PeerManager::new(
 		message_handler,
 		our_node_secret,
 		&random_data,
-		Arc::clone(&arc_logger),
-		arc_ignorer,
-	);
-	let arc_peer_handler = Arc::new(peer_handler);
+		Arc::new(TestLogger::new()),
+		IgnoringMessageHandler {},
+	));
 
-	println!("Connecting to Lightning peers…");
+	println!("Connecting to Lightning peers...");
 	let peers = config::ln_peers();
 	let mut connected_peer_count = 0;
 
 	for current_peer in peers {
-		let initial_connection_succeeded = connect_peer(current_peer, Arc::clone(&arc_peer_handler)).await;
+		let initial_connection_succeeded = connect_peer(current_peer, Arc::clone(&peer_handler)).await;
 		if initial_connection_succeeded {
 			connected_peer_count += 1;
 		}
@@ -78,8 +54,6 @@ pub(crate) async fn download_gossip(persistence_sender: mpsc::Sender<GossipMessa
 
 	println!("Connected to {} Lightning peers!", connected_peer_count);
 
-	let local_router = arc_wrapped_router.clone();
-	let local_persistence_sender = persistence_sender.clone();
 	tokio::spawn(async move {
 		let mut previous_announcement_count = 0u64;
 		let mut previous_update_count = 0u64;
@@ -94,10 +68,8 @@ pub(crate) async fn download_gossip(persistence_sender: mpsc::Sender<GossipMessa
 			let sleep = tokio::time::sleep(Duration::from_secs(5));
 			sleep.await;
 
-			let router_clone = Arc::clone(&local_router);
-
 			{
-				let counter = router_clone.counter.read().unwrap();
+				let counter = router.counter.read().unwrap();
 				let total_message_count = counter.channel_announcements + counter.channel_updates;
 				let new_message_count = total_message_count - previous_announcement_count - previous_update_count;
 
@@ -142,7 +114,7 @@ pub(crate) async fn download_gossip(persistence_sender: mpsc::Sender<GossipMessa
 
 			if needs_to_notify_persister {
 				needs_to_notify_persister = false;
-				local_persistence_sender.send(GossipMessage::InitialSyncComplete).await.unwrap();
+				persistence_sender.send(GossipMessage::InitialSyncComplete).await.unwrap();
 			}
 		}
 	});
diff --git a/src/types.rs b/src/types.rs
index 7b66921..824896d 100644
--- a/src/types.rs
+++ b/src/types.rs
@@ -8,7 +8,7 @@ use crate::downloader::GossipRouter;
 use crate::verifier::ChainVerifier;
 
 pub(crate) type GossipChainAccess = Arc<ChainVerifier>;
-pub(crate) type GossipPeerManager = Arc<PeerManager<lightning_net_tokio::SocketDescriptor, Arc<ErroringMessageHandler>, Arc<GossipRouter>, Arc<TestLogger>, Arc<IgnoringMessageHandler>>>;
+pub(crate) type GossipPeerManager = Arc<PeerManager<lightning_net_tokio::SocketDescriptor, ErroringMessageHandler, Arc<GossipRouter>, Arc<TestLogger>, IgnoringMessageHandler>>;
 
 #[derive(Debug)]
 pub(crate) enum GossipMessage {