p2p: rename backend_timeouts to backend_config

Author: ImplOfAnImpl

dns-server/src/main.rs

@@ -85,7 +85,7 @@ async fn run(options: DnsServerRunOptions) -> anyhow::Result<Never> {
         sync_stalling_timeout: Default::default(),
         peer_manager_config: Default::default(),
         protocol_config: Default::default(),
-        backend_timeouts: Default::default(),
+        backend_config: Default::default(),
         custom_disconnection_reason_for_banning: Default::default(),
     });
 

node-lib/src/config_files/p2p.rs

@@ -186,7 +186,7 @@ impl From<P2pConfigFile> for P2pConfig {
 
                 min_peer_software_version,
             },
-            backend_timeouts: BackendTimeoutsConfig {
+            backend_config: BackendConfig {
                 outbound_connection_timeout: outbound_connection_timeout
                     .map(|t| Duration::from_secs(t.into()))
                     .into(),

p2p/backend-test-suite/src/block_announcement.rs

@@ -193,7 +193,7 @@ where
         sync_stalling_timeout: Default::default(),
         peer_manager_config: Default::default(),
         protocol_config: Default::default(),
-        backend_timeouts: Default::default(),
+        backend_config: Default::default(),
         custom_disconnection_reason_for_banning: Default::default(),
     });
     let shutdown = Arc::new(SeqCstAtomicBool::new(false));

p2p/src/config.rs

@@ -121,8 +121,8 @@ pub struct P2pConfig {
     /// Various limits related to the protocol; these should only be overridden in tests.
     pub protocol_config: ProtocolConfig,
 
-    /// Various timeouts used by the backend.
-    pub backend_timeouts: BackendTimeoutsConfig,
+    /// Various settings specific to the backend.
+    pub backend_config: BackendConfig,
 
     /// If set, this text will be sent to banned peers as part of the DisconnectionReason.
     pub custom_disconnection_reason_for_banning: Option<String>,
@@ -134,13 +134,13 @@ impl P2pConfig {
     /// It is calculated as the max clock diff setting plus handshake timeout to allow for
     /// imprecisions caused by the network latency.
     pub fn effective_max_clock_diff(&self) -> Duration {
-        *self.max_clock_diff + *self.backend_timeouts.peer_handshake_timeout
+        *self.max_clock_diff + *self.backend_config.peer_handshake_timeout
     }
 }
 
-/// Part of P2pConfig containing various timeouts used by the backend.
+/// Part of P2pConfig containing various settings specific to the backend.
 #[derive(Default, Debug, Clone)]
-pub struct BackendTimeoutsConfig {
+pub struct BackendConfig {
     /// The outbound connection timeout value.
     pub outbound_connection_timeout: OutboundConnectionTimeout,
 

p2p/src/lib.rs

@@ -344,7 +344,7 @@ pub fn make_p2p<S: PeerDbStorage + 'static>(
             //
             // For more details, see `Peer::handshake` and `P2pConfig`.
             assert_eq!(
-                *p2p_config.backend_timeouts.peer_handshake_timeout,
+                *p2p_config.backend_config.peer_handshake_timeout,
                 Duration::from_secs(10),
                 "Handshake timeout changed"
             );

p2p/src/net/default_backend/backend.rs

@@ -732,7 +732,7 @@ where
                 local_services_override,
             } => {
                 let connection_fut = timeout(
-                    *self.p2p_config.backend_timeouts.outbound_connection_timeout,
+                    *self.p2p_config.backend_config.outbound_connection_timeout,
                     self.transport.connect(address.socket_addr()),
                 );
 

p2p/src/net/default_backend/peer/handshake_handler.rs

@@ -328,7 +328,7 @@ impl HandshakeHandler {
         socket_writer: &mut MessageWriter<S, Message>,
     ) -> crate::Result<CommonProtocolVersion> {
         // handshake with remote peer and send peer's info to backend
-        let handshake_timeout = *self.p2p_config.backend_timeouts.peer_handshake_timeout;
+        let handshake_timeout = *self.p2p_config.backend_config.peer_handshake_timeout;
         let handshake_res = timeout(
             handshake_timeout,
             self.handshake_impl(peer_event_sender, socket_reader, socket_writer),

p2p/src/net/default_backend/peer/mod.rs

@@ -356,7 +356,7 @@ where
             match send_result {
                 Ok(()) => {
                     let disconnect_result = tokio::time::timeout(
-                        *p2p_config.backend_timeouts.disconnection_timeout,
+                        *p2p_config.backend_config.disconnection_timeout,
                         async {
                             match writer_event_receiver.recv().await {
                                 Some(WriterEvent::WriterClosed(result)) => {
@@ -483,7 +483,7 @@ async fn writer_loop<S: PeerStream>(
                 }
 
                 tokio::time::timeout(
-                    *p2p_config.backend_timeouts.socket_write_timeout,
+                    *p2p_config.backend_config.socket_write_timeout,
                     socket_writer.send(*message),
                 )
                 .await

p2p/src/peer_manager/tests/addr_list_response_caching.rs

@@ -264,7 +264,7 @@ fn make_p2p_config() -> P2pConfig {
         user_agent: mintlayer_core_user_agent(),
         sync_stalling_timeout: Default::default(),
         peer_manager_config: Default::default(),
-        backend_timeouts: Default::default(),
+        backend_config: Default::default(),
         custom_disconnection_reason_for_banning: Default::default(),
     }
 }

p2p/src/peer_manager/tests/addresses.rs

@@ -735,7 +735,7 @@ async fn dont_use_dns_seed_if_connections_exist(#[case] seed: Seed) {
         sync_stalling_timeout: Default::default(),
         peer_manager_config: Default::default(),
         protocol_config: Default::default(),
-        backend_timeouts: Default::default(),
+        backend_config: Default::default(),
         custom_disconnection_reason_for_banning: Default::default(),
     });
     let (cmd_sender, mut cmd_receiver) = tokio::sync::mpsc::unbounded_channel();