X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Ftracking.rs;h=83e1887e09a594fc613bb145c744eea506b1d410;hb=be1e6eebc81ada44decb22742790166090699473;hp=9c249232be5d3f37c1f08c5257906040893212f5;hpb=6f44a3ae6ebcd5856560ebcc3bae5122b46c0426;p=rapid-gossip-sync-server diff --git a/src/tracking.rs b/src/tracking.rs index 9c24923..83e1887 100644 --- a/src/tracking.rs +++ b/src/tracking.rs @@ -1,73 +1,56 @@ +use std::collections::hash_map::RandomState; +use std::hash::{BuildHasher, Hasher}; use std::net::SocketAddr; -use std::sync::{Arc, RwLock}; -use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH}; +use std::sync::Arc; +use std::time::{Duration, Instant}; use bitcoin::hashes::hex::ToHex; use bitcoin::secp256k1::{PublicKey, SecretKey}; -use futures::executor; use lightning; use lightning::ln::peer_handler::{ ErroringMessageHandler, IgnoringMessageHandler, MessageHandler, PeerManager, }; -use lightning::routing::gossip::{NetworkGraph, P2PGossipSync}; -use rand::{Rng, thread_rng}; +use lightning::routing::gossip::NetworkGraph; use tokio::sync::mpsc; use crate::{config, TestLogger}; -use crate::downloader::{GossipCounter, GossipRouter}; -use crate::types::{DetectedGossipMessage, GossipChainAccess, GossipMessage, GossipPeerManager}; -use crate::verifier::ChainVerifier; - -pub(crate) async fn download_gossip(persistence_sender: mpsc::Sender, network_graph: Arc>>) { - let mut key = [0; 32]; - let mut random_data = [0; 32]; - thread_rng().fill_bytes(&mut key); - thread_rng().fill_bytes(&mut random_data); - let our_node_secret = SecretKey::from_slice(&key).unwrap(); +use crate::downloader::GossipRouter; +use crate::types::{GossipMessage, GossipPeerManager}; + +pub(crate) async fn download_gossip(persistence_sender: mpsc::Sender, + completion_sender: mpsc::Sender<()>, + network_graph: Arc>) { + let mut key = [42; 32]; + let mut random_data = [43; 32]; + // Get something psuedo-random from std. + let mut key_hasher = RandomState::new().build_hasher(); + key_hasher.write_u8(1); + key[0..8].copy_from_slice(&key_hasher.finish().to_ne_bytes()); + let mut rand_hasher = RandomState::new().build_hasher(); + rand_hasher.write_u8(2); + random_data[0..8].copy_from_slice(&rand_hasher.finish().to_ne_bytes()); - let _arc_chain_access = None::; - 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 our_node_secret = SecretKey::from_slice(&key).unwrap(); + 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); + 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 = monitor_peer_connection(current_peer, Arc::clone(&arc_peer_handler)); + let initial_connection_succeeded = connect_peer(current_peer, Arc::clone(&peer_handler)).await; if initial_connection_succeeded { connected_peer_count += 1; } @@ -79,8 +62,6 @@ pub(crate) async fn download_gossip(persistence_sender: mpsc::Sender bool { - let peer_manager_clone = Arc::clone(&peer_manager); - eprintln!("Connecting to peer {}@{}…", current_peer.0.to_hex(), current_peer.1.to_string()); - let connection = executor::block_on(async move { - lightning_net_tokio::connect_outbound( - peer_manager_clone, - current_peer.0, - current_peer.1, - ).await - }); - let mut initial_connection_succeeded = false; +async fn connect_peer(current_peer: (PublicKey, SocketAddr), peer_manager: GossipPeerManager) -> bool { + eprintln!("Connecting to peer {}@{}...", current_peer.0.to_hex(), current_peer.1.to_string()); + let connection = lightning_net_tokio::connect_outbound( + Arc::clone(&peer_manager), + current_peer.0, + current_peer.1, + ).await; if let Some(disconnection_future) = connection { eprintln!("Connected to peer {}@{}!", current_peer.0.to_hex(), current_peer.1.to_string()); - initial_connection_succeeded = true; - let peer_manager_clone = Arc::clone(&peer_manager); tokio::spawn(async move { disconnection_future.await; - eprintln!("Disconnected from peer {}@{}", current_peer.0.to_hex(), current_peer.1.to_string()); - monitor_peer_connection(current_peer.clone(), peer_manager_clone); + loop { + eprintln!("Reconnecting to peer {}@{}...", current_peer.0.to_hex(), current_peer.1.to_string()); + if let Some(disconnection_future) = lightning_net_tokio::connect_outbound( + Arc::clone(&peer_manager), + current_peer.0, + current_peer.1, + ).await { + disconnection_future.await; + } else { + tokio::time::sleep(Duration::from_secs(10)).await; + } + } }); + true } else { - eprintln!("Failed to connect to peer {}@{}", current_peer.0.to_hex(), current_peer.1.to_string()) - }; - initial_connection_succeeded + eprintln!("Failed to connect to peer {}@{}", current_peer.0.to_hex(), current_peer.1.to_string()); + false + } }