@@ -171,15 +171,15 @@ fn _check_usize_is_32_or_64() {
171
171
/// lifetimes). Other times you can afford a reference, which is more efficient, in which case
172
172
/// SimpleRefPeerManager is the more appropriate type. Defining these type aliases prevents
173
173
/// issues such as overly long function definitions.
174
- pub type SimpleArcPeerManager < SD , M , T , F , L > = Arc < PeerManager < SD , SimpleArcChannelManager < M , T , F , L > > > ;
174
+ pub type SimpleArcPeerManager < SD , M , T , F , L > = Arc < PeerManager < SD , SimpleArcChannelManager < M , T , F , L > , Arc < L > > > ;
175
175
176
176
/// SimpleRefPeerManager is a type alias for a PeerManager reference, and is the reference
177
177
/// counterpart to the SimpleArcPeerManager type alias. Use this type by default when you don't
178
178
/// need a PeerManager with a static lifetime. You'll need a static lifetime in cases such as
179
179
/// usage of lightning-net-tokio (since tokio::spawn requires parameters with static lifetimes).
180
180
/// But if this is not necessary, using a reference is more efficient. Defining these type aliases
181
181
/// helps with issues such as long function definitions.
182
- pub type SimpleRefPeerManager < ' a , ' b , ' c , ' d , ' e , SD , M , T , F , L > = PeerManager < SD , SimpleRefChannelManager < ' a , ' b , ' c , ' d , ' e , M , T , F , L > > ;
182
+ pub type SimpleRefPeerManager < ' a , ' b , ' c , ' d , ' e , SD , M , T , F , L > = PeerManager < SD , SimpleRefChannelManager < ' a , ' b , ' c , ' d , ' e , M , T , F , L > , & ' e L > ;
183
183
184
184
/// A PeerManager manages a set of peers, described by their SocketDescriptor and marshalls socket
185
185
/// events into messages which it passes on to its MessageHandlers.
@@ -189,7 +189,7 @@ pub type SimpleRefPeerManager<'a, 'b, 'c, 'd, 'e, SD, M, T, F, L> = PeerManager<
189
189
/// essentially you should default to using a SimpleRefPeerManager, and use a
190
190
/// SimpleArcPeerManager when you require a PeerManager with a static lifetime, such as when
191
191
/// you're using lightning-net-tokio.
192
- pub struct PeerManager < Descriptor : SocketDescriptor , CM : Deref > where CM :: Target : msgs:: ChannelMessageHandler {
192
+ pub struct PeerManager < Descriptor : SocketDescriptor , CM : Deref , L : Deref > where CM :: Target : msgs:: ChannelMessageHandler , L :: Target : Logger {
193
193
message_handler : MessageHandler < CM > ,
194
194
peers : Mutex < PeerHolder < Descriptor > > ,
195
195
our_node_secret : SecretKey ,
@@ -200,7 +200,7 @@ pub struct PeerManager<Descriptor: SocketDescriptor, CM: Deref> where CM::Target
200
200
peer_counter_low : AtomicUsize ,
201
201
peer_counter_high : AtomicUsize ,
202
202
203
- logger : Arc < Logger > ,
203
+ logger : L ,
204
204
}
205
205
206
206
macro_rules! encode_msg {
@@ -213,22 +213,22 @@ macro_rules! encode_msg {
213
213
214
214
/// Manages and reacts to connection events. You probably want to use file descriptors as PeerIds.
215
215
/// PeerIds may repeat, but only after socket_disconnected() has been called.
216
- impl < Descriptor : SocketDescriptor , CM : Deref > PeerManager < Descriptor , CM > where CM :: Target : msgs:: ChannelMessageHandler {
216
+ impl < Descriptor : SocketDescriptor , CM : Deref , L : Deref > PeerManager < Descriptor , CM , L > where CM :: Target : msgs:: ChannelMessageHandler , L :: Target : Logger {
217
217
/// Constructs a new PeerManager with the given message handlers and node_id secret key
218
218
/// ephemeral_random_data is used to derive per-connection ephemeral keys and must be
219
219
/// cryptographically secure random bytes.
220
- pub fn new ( message_handler : MessageHandler < CM > , our_node_secret : SecretKey , ephemeral_random_data : & [ u8 ; 32 ] , logger : Arc < Logger > ) -> PeerManager < Descriptor , CM > {
220
+ pub fn new ( message_handler : MessageHandler < CM > , our_node_secret : SecretKey , ephemeral_random_data : & [ u8 ; 32 ] , logger : L ) -> PeerManager < Descriptor , CM , L > {
221
221
let mut ephemeral_key_midstate = Sha256 :: engine ( ) ;
222
222
ephemeral_key_midstate. input ( ephemeral_random_data) ;
223
223
224
224
PeerManager {
225
- message_handler : message_handler ,
225
+ message_handler,
226
226
peers : Mutex :: new ( PeerHolder {
227
227
peers : HashMap :: new ( ) ,
228
228
peers_needing_send : HashSet :: new ( ) ,
229
229
node_id_to_descriptor : HashMap :: new ( )
230
230
} ) ,
231
- our_node_secret : our_node_secret ,
231
+ our_node_secret,
232
232
ephemeral_key_midstate,
233
233
peer_counter_low : AtomicUsize :: new ( 0 ) ,
234
234
peer_counter_high : AtomicUsize :: new ( 0 ) ,
@@ -1167,7 +1167,6 @@ mod tests {
1167
1167
use ln:: features:: ChannelFeatures ;
1168
1168
use util:: events;
1169
1169
use util:: test_utils;
1170
- use util:: logger:: Logger ;
1171
1170
1172
1171
use bitcoin:: secp256k1:: Secp256k1 ;
1173
1172
use bitcoin:: secp256k1:: key:: { SecretKey , PublicKey } ;
@@ -1205,20 +1204,30 @@ mod tests {
1205
1204
fn disconnect_socket ( & mut self ) { }
1206
1205
}
1207
1206
1208
- fn create_chan_handlers ( peer_count : usize ) -> Vec < test_utils:: TestChannelMessageHandler > {
1209
- let mut chan_handlers = Vec :: new ( ) ;
1207
+ struct PeerManagerCfg {
1208
+ chan_handler : test_utils:: TestChannelMessageHandler ,
1209
+ logger : test_utils:: TestLogger ,
1210
+ }
1211
+
1212
+ fn create_peermgr_cfgs ( peer_count : usize ) -> Vec < PeerManagerCfg > {
1213
+ let mut cfgs = Vec :: new ( ) ;
1210
1214
for _ in 0 ..peer_count {
1211
1215
let chan_handler = test_utils:: TestChannelMessageHandler :: new ( ) ;
1212
- chan_handlers. push ( chan_handler) ;
1216
+ let logger = test_utils:: TestLogger :: new ( ) ;
1217
+ cfgs. push (
1218
+ PeerManagerCfg {
1219
+ chan_handler,
1220
+ logger,
1221
+ }
1222
+ ) ;
1213
1223
}
1214
1224
1215
- chan_handlers
1225
+ cfgs
1216
1226
}
1217
1227
1218
- fn create_network < ' a > ( peer_count : usize , chan_handlers : & ' a Vec < test_utils :: TestChannelMessageHandler > , routing_handlers : Option < & ' a Vec < Arc < msgs:: RoutingMessageHandler > > > ) -> Vec < PeerManager < FileDescriptor , & ' a test_utils:: TestChannelMessageHandler > > {
1228
+ fn create_network < ' a > ( peer_count : usize , cfgs : & ' a Vec < PeerManagerCfg > , routing_handlers : Option < & ' a Vec < Arc < msgs:: RoutingMessageHandler > > > ) -> Vec < PeerManager < FileDescriptor , & ' a test_utils:: TestChannelMessageHandler , & ' a test_utils :: TestLogger > > {
1219
1229
let mut peers = Vec :: new ( ) ;
1220
1230
let mut rng = thread_rng ( ) ;
1221
- let logger : Arc < Logger > = Arc :: new ( test_utils:: TestLogger :: new ( ) ) ;
1222
1231
let mut ephemeral_bytes = [ 0 ; 32 ] ;
1223
1232
rng. fill_bytes ( & mut ephemeral_bytes) ;
1224
1233
@@ -1231,15 +1240,15 @@ mod tests {
1231
1240
rng. fill_bytes ( & mut key_slice) ;
1232
1241
SecretKey :: from_slice ( & key_slice) . unwrap ( )
1233
1242
} ;
1234
- let msg_handler = MessageHandler { chan_handler : & chan_handlers [ i] , route_handler : router } ;
1235
- let peer = PeerManager :: new ( msg_handler, node_id, & ephemeral_bytes, Arc :: clone ( & logger) ) ;
1243
+ let msg_handler = MessageHandler { chan_handler : & cfgs [ i] . chan_handler , route_handler : router } ;
1244
+ let peer = PeerManager :: new ( msg_handler, node_id, & ephemeral_bytes, & cfgs [ i ] . logger ) ;
1236
1245
peers. push ( peer) ;
1237
1246
}
1238
1247
1239
1248
peers
1240
1249
}
1241
1250
1242
- fn establish_connection < ' a > ( peer_a : & PeerManager < FileDescriptor , & ' a test_utils:: TestChannelMessageHandler > , peer_b : & PeerManager < FileDescriptor , & ' a test_utils:: TestChannelMessageHandler > ) -> ( FileDescriptor , FileDescriptor ) {
1251
+ fn establish_connection < ' a > ( peer_a : & PeerManager < FileDescriptor , & ' a test_utils:: TestChannelMessageHandler , & ' a test_utils :: TestLogger > , peer_b : & PeerManager < FileDescriptor , & ' a test_utils:: TestChannelMessageHandler , & ' a test_utils :: TestLogger > ) -> ( FileDescriptor , FileDescriptor ) {
1243
1252
let secp_ctx = Secp256k1 :: new ( ) ;
1244
1253
let a_id = PublicKey :: from_secret_key ( & secp_ctx, & peer_a. our_node_secret ) ;
1245
1254
let mut fd_a = FileDescriptor { fd : 1 , outbound_data : Arc :: new ( Mutex :: new ( Vec :: new ( ) ) ) } ;
@@ -1252,7 +1261,7 @@ mod tests {
1252
1261
( fd_a. clone ( ) , fd_b. clone ( ) )
1253
1262
}
1254
1263
1255
- fn establish_connection_and_read_events < ' a > ( peer_a : & PeerManager < FileDescriptor , & ' a test_utils:: TestChannelMessageHandler > , peer_b : & PeerManager < FileDescriptor , & ' a test_utils:: TestChannelMessageHandler > ) -> ( FileDescriptor , FileDescriptor ) {
1264
+ fn establish_connection_and_read_events < ' a > ( peer_a : & PeerManager < FileDescriptor , & ' a test_utils:: TestChannelMessageHandler , & ' a test_utils :: TestLogger > , peer_b : & PeerManager < FileDescriptor , & ' a test_utils:: TestChannelMessageHandler , & ' a test_utils :: TestLogger > ) -> ( FileDescriptor , FileDescriptor ) {
1256
1265
let ( mut fd_a, mut fd_b) = establish_connection ( peer_a, peer_b) ;
1257
1266
assert_eq ! ( peer_b. read_event( & mut fd_b, & fd_a. outbound_data. lock( ) . unwrap( ) . split_off( 0 ) ) . unwrap( ) , false ) ;
1258
1267
assert_eq ! ( peer_a. read_event( & mut fd_a, & fd_b. outbound_data. lock( ) . unwrap( ) . split_off( 0 ) ) . unwrap( ) , false ) ;
@@ -1263,9 +1272,9 @@ mod tests {
1263
1272
fn test_disconnect_peer ( ) {
1264
1273
// Simple test which builds a network of PeerManager, connects and brings them to NoiseState::Finished and
1265
1274
// push a DisconnectPeer event to remove the node flagged by id
1266
- let chan_handlers = create_chan_handlers ( 2 ) ;
1275
+ let cfgs = create_peermgr_cfgs ( 2 ) ;
1267
1276
let chan_handler = test_utils:: TestChannelMessageHandler :: new ( ) ;
1268
- let mut peers = create_network ( 2 , & chan_handlers , None ) ;
1277
+ let mut peers = create_network ( 2 , & cfgs , None ) ;
1269
1278
establish_connection ( & peers[ 0 ] , & peers[ 1 ] ) ;
1270
1279
assert_eq ! ( peers[ 0 ] . peers. lock( ) . unwrap( ) . peers. len( ) , 1 ) ;
1271
1280
@@ -1286,8 +1295,8 @@ mod tests {
1286
1295
#[ test]
1287
1296
fn test_timer_tick_occurred ( ) {
1288
1297
// Create peers, a vector of two peer managers, perform initial set up and check that peers[0] has one Peer.
1289
- let chan_handlers = create_chan_handlers ( 2 ) ;
1290
- let peers = create_network ( 2 , & chan_handlers , None ) ;
1298
+ let cfgs = create_peermgr_cfgs ( 2 ) ;
1299
+ let peers = create_network ( 2 , & cfgs , None ) ;
1291
1300
establish_connection ( & peers[ 0 ] , & peers[ 1 ] ) ;
1292
1301
assert_eq ! ( peers[ 0 ] . peers. lock( ) . unwrap( ) . peers. len( ) , 1 ) ;
1293
1302
@@ -1404,15 +1413,15 @@ mod tests {
1404
1413
#[ test]
1405
1414
fn test_do_attempt_write_data ( ) {
1406
1415
// Create 2 peers with custom TestRoutingMessageHandlers and connect them.
1407
- let chan_handlers = create_chan_handlers ( 2 ) ;
1416
+ let cfgs = create_peermgr_cfgs ( 2 ) ;
1408
1417
let mut routing_handlers: Vec < Arc < msgs:: RoutingMessageHandler > > = Vec :: new ( ) ;
1409
1418
let mut routing_handlers_concrete: Vec < Arc < TestRoutingMessageHandler > > = Vec :: new ( ) ;
1410
1419
for _ in 0 ..2 {
1411
1420
let routing_handler = Arc :: new ( TestRoutingMessageHandler :: new ( ) ) ;
1412
1421
routing_handlers. push ( routing_handler. clone ( ) ) ;
1413
1422
routing_handlers_concrete. push ( routing_handler. clone ( ) ) ;
1414
1423
}
1415
- let peers = create_network ( 2 , & chan_handlers , Some ( & routing_handlers) ) ;
1424
+ let peers = create_network ( 2 , & cfgs , Some ( & routing_handlers) ) ;
1416
1425
1417
1426
// By calling establish_connect, we trigger do_attempt_write_data between
1418
1427
// the peers. Previously this function would mistakenly enter an infinite loop
@@ -1438,12 +1447,12 @@ mod tests {
1438
1447
fn limit_initial_routing_sync_requests ( ) {
1439
1448
// Inbound peer 0 requests initial_routing_sync, but outbound peer 1 does not.
1440
1449
{
1441
- let chan_handlers = create_chan_handlers ( 2 ) ;
1450
+ let cfgs = create_peermgr_cfgs ( 2 ) ;
1442
1451
let routing_handlers: Vec < Arc < msgs:: RoutingMessageHandler > > = vec ! [
1443
1452
Arc :: new( test_utils:: TestRoutingMessageHandler :: new( ) . set_request_full_sync( ) ) ,
1444
1453
Arc :: new( test_utils:: TestRoutingMessageHandler :: new( ) ) ,
1445
1454
] ;
1446
- let peers = create_network ( 2 , & chan_handlers , Some ( & routing_handlers) ) ;
1455
+ let peers = create_network ( 2 , & cfgs , Some ( & routing_handlers) ) ;
1447
1456
let ( fd_0_to_1, fd_1_to_0) = establish_connection_and_read_events ( & peers[ 0 ] , & peers[ 1 ] ) ;
1448
1457
1449
1458
let peer_0 = peers[ 0 ] . peers . lock ( ) . unwrap ( ) ;
@@ -1458,12 +1467,12 @@ mod tests {
1458
1467
1459
1468
// Outbound peer 1 requests initial_routing_sync, but inbound peer 0 does not.
1460
1469
{
1461
- let chan_handlers = create_chan_handlers ( 2 ) ;
1470
+ let cfgs = create_peermgr_cfgs ( 2 ) ;
1462
1471
let routing_handlers: Vec < Arc < msgs:: RoutingMessageHandler > > = vec ! [
1463
1472
Arc :: new( test_utils:: TestRoutingMessageHandler :: new( ) ) ,
1464
1473
Arc :: new( test_utils:: TestRoutingMessageHandler :: new( ) . set_request_full_sync( ) ) ,
1465
1474
] ;
1466
- let peers = create_network ( 2 , & chan_handlers , Some ( & routing_handlers) ) ;
1475
+ let peers = create_network ( 2 , & cfgs , Some ( & routing_handlers) ) ;
1467
1476
let ( fd_0_to_1, fd_1_to_0) = establish_connection_and_read_events ( & peers[ 0 ] , & peers[ 1 ] ) ;
1468
1477
1469
1478
let peer_0 = peers[ 0 ] . peers . lock ( ) . unwrap ( ) ;
0 commit comments