Switch Logger from Arc to Deref.

diff --git a/src/downloader.rs b/src/downloader.rs
index 0c672e36446c25d05d6dcf48905f67a47feb7d35..34a5c66b3ba22d95ce2d648ebe1ff5f086813cb9 100644 (file)
--- a/src/downloader.rs
+++ b/src/downloader.rs
@@ -1,3 +1,4 @@
+use std::ops::Deref;
 use std::sync::{Arc, RwLock};
 
 use bitcoin::secp256k1::PublicKey;
@@ -30,16 +31,16 @@ impl GossipCounter {
        }
 }
 
-pub(crate) struct GossipRouter<L: Logger + Send + Sync + 'static> {
-       native_router: P2PGossipSync<Arc<NetworkGraph<Arc<L>>>, GossipChainAccess<L>, Arc<L>>,
+pub(crate) struct GossipRouter<L: Deref + Clone + Send + Sync + 'static> where L::Target: Logger {
+       native_router: P2PGossipSync<Arc<NetworkGraph<L>>, GossipChainAccess<L>, L>,
        pub(crate) counter: RwLock<GossipCounter>,
        sender: mpsc::Sender<GossipMessage>,
        verifier: Arc<ChainVerifier<L>>,
-       outbound_gossiper: Arc<P2PGossipSync<Arc<NetworkGraph<Arc<L>>>, GossipChainAccess<L>, Arc<L>>>,
+       outbound_gossiper: Arc<P2PGossipSync<Arc<NetworkGraph<L>>, GossipChainAccess<L>, L>>,
 }
 
-impl<L: Logger + Send + Sync> GossipRouter<L> {
-       pub(crate) fn new(network_graph: Arc<NetworkGraph<Arc<L>>>, sender: mpsc::Sender<GossipMessage>, logger: Arc<L>) -> Self {
+impl<L: Deref + Clone + Send + Sync> GossipRouter<L> where L::Target: Logger {
+       pub(crate) fn new(network_graph: Arc<NetworkGraph<L>>, sender: mpsc::Sender<GossipMessage>, logger: L) -> Self {
                let outbound_gossiper = Arc::new(P2PGossipSync::new(Arc::clone(&network_graph), None, logger.clone()));
                let verifier = Arc::new(ChainVerifier::new(Arc::clone(&network_graph), Arc::clone(&outbound_gossiper)));
                Self {
@@ -83,7 +84,7 @@ impl<L: Logger + Send + Sync> GossipRouter<L> {
        }
 }
 
-impl<L: Logger + Send + Sync> MessageSendEventsProvider for GossipRouter<L> {
+impl<L: Deref + Clone + Send + Sync> MessageSendEventsProvider for GossipRouter<L> where L::Target: Logger {
        fn get_and_clear_pending_msg_events(&self) -> Vec<MessageSendEvent> {
                let gossip_evs = self.outbound_gossiper.get_and_clear_pending_msg_events();
                for ev in gossip_evs {
@@ -102,7 +103,7 @@ impl<L: Logger + Send + Sync> MessageSendEventsProvider for GossipRouter<L> {
        }
 }
 
-impl<L: Logger + Send + Sync> RoutingMessageHandler for GossipRouter<L> {
+impl<L: Deref + Clone + Send + Sync> RoutingMessageHandler for GossipRouter<L> where L::Target: Logger {
        fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError> {
                self.native_router.handle_node_announcement(msg)
        }

diff --git a/src/lib.rs b/src/lib.rs
index 363d4aeb9e94ddb2c8a1baddad45027eb2ac7129..803c077bebcb6b68e74d636b631871228afb779d 100644 (file)
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -12,6 +12,7 @@ extern crate core;
 use std::collections::{HashMap, HashSet};
 use std::fs::File;
 use std::io::BufReader;
+use std::ops::Deref;
 use std::sync::Arc;
 
 use lightning::routing::gossip::{NetworkGraph, NodeId};
@@ -43,9 +44,9 @@ pub mod types;
 /// The fourth byte is the protocol version in case our format gets updated.
 const GOSSIP_PREFIX: [u8; 4] = [76, 68, 75, 1];
 
-pub struct RapidSyncProcessor<L: Logger> {
-       network_graph: Arc<NetworkGraph<Arc<L>>>,
-       logger: Arc<L>
+pub struct RapidSyncProcessor<L: Deref> where L::Target: Logger {
+       network_graph: Arc<NetworkGraph<L>>,
+       logger: L
 }
 
 pub struct SerializedResponse {
@@ -57,8 +58,8 @@ pub struct SerializedResponse {
        pub update_count_incremental: u32,
 }
 
-impl<L: Logger + Send + Sync + 'static> RapidSyncProcessor<L> {
-       pub fn new(logger: Arc<L>) -> Self {
+impl<L: Deref + Clone + Send + Sync + 'static> RapidSyncProcessor<L> where L::Target: Logger {
+       pub fn new(logger: L) -> Self {
                let network = config::network();
                let network_graph = if let Ok(file) = File::open(&config::network_graph_cache_path()) {
                        println!("Initializing from cached network graph…");
@@ -90,7 +91,7 @@ impl<L: Logger + Send + Sync + 'static> RapidSyncProcessor<L> {
 
                        println!("Starting gossip download");
                        tokio::spawn(tracking::download_gossip(persistence_sender, sync_completion_sender,
-                               Arc::clone(&self.network_graph), Arc::clone(&self.logger)));
+                               Arc::clone(&self.network_graph), self.logger.clone()));
                        println!("Starting gossip db persistence listener");
                        tokio::spawn(async move { persister.persist_gossip().await; });
                } else {
@@ -129,7 +130,7 @@ fn serialize_empty_blob(current_timestamp: u64) -> Vec<u8> {
        let chain_hash = genesis_block.block_hash();
        chain_hash.write(&mut blob).unwrap();
 
-       let blob_timestamp = Snapshotter::<RGSSLogger>::round_down_to_nearest_multiple(current_timestamp, config::SNAPSHOT_CALCULATION_INTERVAL as u64) as u32;
+       let blob_timestamp = Snapshotter::<Arc<RGSSLogger>>::round_down_to_nearest_multiple(current_timestamp, config::SNAPSHOT_CALCULATION_INTERVAL as u64) as u32;
        blob_timestamp.write(&mut blob).unwrap();
 
        0u32.write(&mut blob).unwrap(); // node count
@@ -139,7 +140,7 @@ fn serialize_empty_blob(current_timestamp: u64) -> Vec<u8> {
        blob
 }
 
-async fn serialize_delta<L: Logger>(network_graph: Arc<NetworkGraph<Arc<L>>>, last_sync_timestamp: u32) -> SerializedResponse {
+async fn serialize_delta<L: Deref>(network_graph: Arc<NetworkGraph<L>>, last_sync_timestamp: u32) -> SerializedResponse where L::Target: Logger {
        let (client, connection) = lookup::connect_to_db().await;
 
        network_graph.remove_stale_channels_and_tracking();

diff --git a/src/lookup.rs b/src/lookup.rs
index 79fb84e8d599ca4d993fc8ab4bb955cb3cf2648b..9e561992c4ded8b264d4133e89b077e140198f21 100644 (file)
--- a/src/lookup.rs
+++ b/src/lookup.rs
@@ -1,6 +1,6 @@
 use std::collections::{BTreeMap, HashSet};
 use std::io::Cursor;
-use std::ops::Add;
+use std::ops::{Add, Deref};
 use std::sync::Arc;
 use std::time::{Duration, Instant, SystemTime};
 
@@ -76,7 +76,7 @@ pub(super) async fn connect_to_db() -> (Client, Connection<Socket, NoTlsStream>)
 /// whether they had been seen before.
 /// Also include all announcements for which the first update was announced
 /// after `last_sync_timestamp`
-pub(super) async fn fetch_channel_announcements<L: Logger>(delta_set: &mut DeltaSet, network_graph: Arc<NetworkGraph<Arc<L>>>, client: &Client, last_sync_timestamp: u32) {
+pub(super) async fn fetch_channel_announcements<L: Deref>(delta_set: &mut DeltaSet, network_graph: Arc<NetworkGraph<L>>, client: &Client, last_sync_timestamp: u32) where L::Target: Logger {
        println!("Obtaining channel ids from network graph");
        let last_sync_timestamp_object = SystemTime::UNIX_EPOCH.add(Duration::from_secs(last_sync_timestamp as u64));
        let channel_ids = {

diff --git a/src/persistence.rs b/src/persistence.rs
index 22abf0216d8575692a1e3e7f9b7d4ce66844df66..e2d9eb0dd170ab44b0849cf5e9af80f97e16d781 100644 (file)
--- a/src/persistence.rs
+++ b/src/persistence.rs
@@ -1,5 +1,6 @@
 use std::fs::OpenOptions;
 use std::io::{BufWriter, Write};
+use std::ops::Deref;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 use lightning::routing::gossip::NetworkGraph;
@@ -13,13 +14,13 @@ use crate::types::GossipMessage;
 
 const POSTGRES_INSERT_TIMEOUT: Duration = Duration::from_secs(15);
 
-pub(crate) struct GossipPersister<L: Logger> {
+pub(crate) struct GossipPersister<L: Deref> where L::Target: Logger {
        gossip_persistence_receiver: mpsc::Receiver<GossipMessage>,
-       network_graph: Arc<NetworkGraph<Arc<L>>>,
+       network_graph: Arc<NetworkGraph<L>>,
 }
 
-impl<L: Logger> GossipPersister<L> {
-       pub fn new(network_graph: Arc<NetworkGraph<Arc<L>>>) -> (Self, mpsc::Sender<GossipMessage>) {
+impl<L: Deref> GossipPersister<L> where L::Target: Logger {
+       pub fn new(network_graph: Arc<NetworkGraph<L>>) -> (Self, mpsc::Sender<GossipMessage>) {
                let (gossip_persistence_sender, gossip_persistence_receiver) =
                        mpsc::channel::<GossipMessage>(100);
                (GossipPersister {

diff --git a/src/snapshot.rs b/src/snapshot.rs
index c81cc35327715ea865cd62c24c1723611315c26f..05cc63e3222c4181944a571572efa45fab6df4da 100644 (file)
--- a/src/snapshot.rs
+++ b/src/snapshot.rs
@@ -1,5 +1,6 @@
 use std::collections::HashMap;
 use std::fs;
+use std::ops::Deref;
 use std::os::unix::fs::symlink;
 use std::sync::Arc;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
@@ -10,12 +11,12 @@ use lightning::util::logger::Logger;
 use crate::config;
 use crate::config::cache_path;
 
-pub(crate) struct Snapshotter<L: Logger> {
-       network_graph: Arc<NetworkGraph<Arc<L>>>,
+pub(crate) struct Snapshotter<L: Deref> where L::Target: Logger {
+       network_graph: Arc<NetworkGraph<L>>,
 }
 
-impl<L: Logger> Snapshotter<L> {
-       pub fn new(network_graph: Arc<NetworkGraph<Arc<L>>>) -> Self {
+impl<L: Deref> Snapshotter<L> where L::Target: Logger {
+       pub fn new(network_graph: Arc<NetworkGraph<L>>) -> Self {
                Self { network_graph }
        }
 

diff --git a/src/tracking.rs b/src/tracking.rs
index 2935eb286780b8228d1d4f6123de370e71b3cbb1..99166afdfe5e7d18a88a8b7c837bc56609dbe601 100644 (file)
--- a/src/tracking.rs
+++ b/src/tracking.rs
@@ -1,6 +1,7 @@
 use std::collections::hash_map::RandomState;
 use std::hash::{BuildHasher, Hasher};
 use std::net::SocketAddr;
+use std::ops::Deref;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 
@@ -19,11 +20,11 @@ use crate::config;
 use crate::downloader::GossipRouter;
 use crate::types::{GossipMessage, GossipPeerManager};
 
-pub(crate) async fn download_gossip<L: Logger + Send + Sync + 'static>(persistence_sender: mpsc::Sender<GossipMessage>,
+pub(crate) async fn download_gossip<L: Deref + Clone + Send + Sync + 'static>(persistence_sender: mpsc::Sender<GossipMessage>,
                completion_sender: mpsc::Sender<()>,
-               network_graph: Arc<NetworkGraph<Arc<L>>>,
-               logger: Arc<L>
-) {
+               network_graph: Arc<NetworkGraph<L>>,
+               logger: L
+) where L::Target: Logger {
        let mut key = [42; 32];
        let mut random_data = [43; 32];
        // Get something psuedo-random from std.
@@ -145,7 +146,7 @@ pub(crate) async fn download_gossip<L: Logger + Send + Sync + 'static>(persisten
        });
 }
 
-async fn connect_peer<L: Logger + Send + Sync + 'static>(current_peer: (PublicKey, SocketAddr), peer_manager: GossipPeerManager<L>) -> bool {
+async fn connect_peer<L: Deref + Clone + Send + Sync + 'static>(current_peer: (PublicKey, SocketAddr), peer_manager: GossipPeerManager<L>) -> bool where L::Target: Logger {
        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),

diff --git a/src/types.rs b/src/types.rs
index b18cbe739180a8389f60add6b9d79b027775fa31..6fafbd3e340fb3507933889d6f47aef63f157ec2 100644 (file)
--- a/src/types.rs
+++ b/src/types.rs
@@ -9,7 +9,7 @@ use crate::downloader::GossipRouter;
 use crate::verifier::ChainVerifier;
 
 pub(crate) type GossipChainAccess<L> = Arc<ChainVerifier<L>>;
-pub(crate) type GossipPeerManager<L> = Arc<PeerManager<lightning_net_tokio::SocketDescriptor, ErroringMessageHandler, Arc<GossipRouter<L>>, IgnoringMessageHandler, Arc<L>, IgnoringMessageHandler, Arc<KeysManager>>>;
+pub(crate) type GossipPeerManager<L> = Arc<PeerManager<lightning_net_tokio::SocketDescriptor, ErroringMessageHandler, Arc<GossipRouter<L>>, IgnoringMessageHandler, L, IgnoringMessageHandler, Arc<KeysManager>>>;
 
 #[derive(Debug)]
 pub(crate) enum GossipMessage {

diff --git a/src/verifier.rs b/src/verifier.rs
index a88f2b701257ff998ffdfc09da983421d2f157c1..872a5010c8955b17a1f6114ab9c63ea57f8ad079 100644 (file)
--- a/src/verifier.rs
+++ b/src/verifier.rs
@@ -1,4 +1,5 @@
 use std::convert::TryInto;
+use std::ops::Deref;
 use std::sync::Arc;
 use std::sync::Mutex;
 
@@ -15,17 +16,17 @@ use lightning_block_sync::rest::RestClient;
 use crate::config;
 use crate::types::GossipPeerManager;
 
-pub(crate) struct ChainVerifier<L: Logger + Send + Sync + 'static> {
+pub(crate) struct ChainVerifier<L: Deref + Clone + Send + Sync + 'static> where L::Target: Logger {
        rest_client: Arc<RestClient>,
-       graph: Arc<NetworkGraph<Arc<L>>>,
-       outbound_gossiper: Arc<P2PGossipSync<Arc<NetworkGraph<Arc<L>>>, Arc<Self>, Arc<L>>>,
+       graph: Arc<NetworkGraph<L>>,
+       outbound_gossiper: Arc<P2PGossipSync<Arc<NetworkGraph<L>>, Arc<Self>, L>>,
        peer_handler: Mutex<Option<GossipPeerManager<L>>>,
 }
 
 struct RestBinaryResponse(Vec<u8>);
 
-impl<L: Logger + Send + Sync + 'static> ChainVerifier<L> {
-       pub(crate) fn new(graph: Arc<NetworkGraph<Arc<L>>>, outbound_gossiper: Arc<P2PGossipSync<Arc<NetworkGraph<Arc<L>>>, Arc<Self>, Arc<L>>>) -> Self {
+impl<L: Deref + Clone + Send + Sync + 'static> ChainVerifier<L> where L::Target: Logger {
+       pub(crate) fn new(graph: Arc<NetworkGraph<L>>, outbound_gossiper: Arc<P2PGossipSync<Arc<NetworkGraph<L>>, Arc<Self>, L>>) -> Self {
                ChainVerifier {
                        rest_client: Arc::new(RestClient::new(config::bitcoin_rest_endpoint()).unwrap()),
                        outbound_gossiper,
@@ -73,7 +74,7 @@ impl<L: Logger + Send + Sync + 'static> ChainVerifier<L> {
        }
 }
 
-impl<L: Logger + Send + Sync + 'static> UtxoLookup for ChainVerifier<L> {
+impl<L: Deref + Clone + Send + Sync + 'static> UtxoLookup for ChainVerifier<L> where L::Target: Logger {
        fn get_utxo(&self, _genesis_hash: &BlockHash, short_channel_id: u64) -> UtxoResult {
                let res = UtxoFuture::new();
                let fut = res.clone();