Skip to content

Commit 697fc8c

Browse files
ramfoxramfox
authored
chore: add patch for iroh dependencies (#51)
This PR updates the following dependencies to use their main branches: - `iroh` from `https://github.com/n0-computer/iroh.git` - `iroh-base` from `https://github.com/n0-computer/iroh.git`
1 parent d2d90c6 commit 697fc8c

File tree

3 files changed

+58
-54
lines changed

3 files changed

+58
-54
lines changed

‎Cargo.toml‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -37,3 +37,7 @@ data-encoding = "2.9.0"
3737
[features]
3838
# generate headers
3939
headers = ["safer-ffi/headers"]
40+
41+
[patch.crates-io]
42+
iroh = { git = "https://github.com/n0-computer/iroh.git", branch = "main" }
43+
iroh-base = { git = "https://github.com/n0-computer/iroh.git", branch = "main" }

‎deny.toml‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -40,4 +40,4 @@ hash = 3171872035
4040
path = "LICENSE"
4141

4242
[sources]
43-
allow-git = []
43+
allow-git = ["https://github.com/n0-computer/iroh.git"]

‎src/endpoint.rs‎

Lines changed: 53 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -1051,11 +1051,11 @@ mod tests {
10511051
let alpn0: vec::Vec<u8> = b"/hello/world/1234".to_vec().into();
10521052
let alpn1: vec::Vec<u8> = b"/ha/coo/12".to_vec().into();
10531053

1054-
endpoint_config_add_alpn(&mut config, alpn0.as_ref().into());
1054+
endpoint_config_add_alpn(&mut config, alpn0.as_ref());
10551055
assert_eq!(config.alpn_protocols[0].as_ref(), alpn0.as_ref());
10561056
assert_eq!(config.alpn_protocols[0].as_ref().len(), 17);
10571057

1058-
endpoint_config_add_alpn(&mut config, alpn1.as_ref().into());
1058+
endpoint_config_add_alpn(&mut config, alpn1.as_ref());
10591059
assert_eq!(config.alpn_protocols[1].as_ref(), alpn1.as_ref());
10601060
assert_eq!(config.alpn_protocols[1].as_ref().len(), 10);
10611061
}
@@ -1065,19 +1065,19 @@ mod tests {
10651065
let alpn: vec::Vec<u8> = b"/cool/alpn/1".to_vec().into();
10661066
// create config
10671067
let mut config_server = endpoint_config_default();
1068-
endpoint_config_add_alpn(&mut config_server, alpn.as_ref().into());
1068+
endpoint_config_add_alpn(&mut config_server, alpn.as_ref());
10691069

10701070
let mut config_client = endpoint_config_default();
1071-
endpoint_config_add_alpn(&mut config_client, alpn.as_ref().into());
1071+
endpoint_config_add_alpn(&mut config_client, alpn.as_ref());
10721072

10731073
let (s, r) = std::sync::mpsc::channel();
10741074

10751075
// setup server
10761076
let alpn_s = alpn.clone();
10771077
let server_thread = std::thread::spawn(move || {
10781078
// create iroh endpoint and bind
1079-
let mut ep = endpoint_default();
1080-
let bind_res = endpoint_bind(&config_server, None, None, &mut ep);
1079+
let ep = endpoint_default();
1080+
let bind_res = endpoint_bind(&config_server, None, None, &ep);
10811081
assert_eq!(bind_res, EndpointResult::Ok);
10821082

10831083
let mut node_addr = node_addr_default();
@@ -1088,8 +1088,8 @@ mod tests {
10881088

10891089
// accept connection
10901090
println!("[s] endpoint accept");
1091-
let mut conn = connection_default();
1092-
let accept_res = endpoint_accept(&ep, alpn_s.as_ref(), &mut conn);
1091+
let conn = connection_default();
1092+
let accept_res = endpoint_accept(&ep, alpn_s.as_ref(), &conn);
10931093
assert_eq!(accept_res, EndpointResult::Ok);
10941094

10951095
println!("[s] connection accept uni");
@@ -1114,17 +1114,17 @@ mod tests {
11141114
// setup client
11151115
let client_thread = std::thread::spawn(move || {
11161116
// create iroh endpoint and bind
1117-
let mut ep = endpoint_default();
1118-
let bind_res = endpoint_bind(&config_client, None, None, &mut ep);
1117+
let ep = endpoint_default();
1118+
let bind_res = endpoint_bind(&config_client, None, None, &ep);
11191119
assert_eq!(bind_res, EndpointResult::Ok);
11201120

11211121
// wait for addr from server
11221122
let node_addr = r.recv().unwrap();
11231123

11241124
println!("[c] dialing");
11251125
// connect to server
1126-
let mut conn = connection_default();
1127-
let connect_res = endpoint_connect(&ep, alpn.as_ref(), node_addr, &mut conn);
1126+
let conn = connection_default();
1127+
let connect_res = endpoint_connect(&ep, alpn.as_ref(), node_addr, &conn);
11281128
assert_eq!(connect_res, EndpointResult::Ok);
11291129

11301130
println!("[c] connection open uni");
@@ -1152,19 +1152,19 @@ mod tests {
11521152
let alpn: vec::Vec<u8> = b"/cool/alpn/1".to_vec().into();
11531153
// create config
11541154
let mut config_server = endpoint_config_default();
1155-
endpoint_config_add_alpn(&mut config_server, alpn.as_ref().into());
1155+
endpoint_config_add_alpn(&mut config_server, alpn.as_ref());
11561156

11571157
let mut config_client = endpoint_config_default();
1158-
endpoint_config_add_alpn(&mut config_client, alpn.as_ref().into());
1158+
endpoint_config_add_alpn(&mut config_client, alpn.as_ref());
11591159

11601160
let (s, r) = std::sync::mpsc::channel();
11611161

11621162
// setup server
11631163
let alpn_s = alpn.clone();
11641164
let server_thread = std::thread::spawn(move || {
11651165
// create iroh endpoint and bind
1166-
let mut ep = endpoint_default();
1167-
let bind_res = endpoint_bind(&config_server, None, None, &mut ep);
1166+
let ep = endpoint_default();
1167+
let bind_res = endpoint_bind(&config_server, None, None, &ep);
11681168
assert_eq!(bind_res, EndpointResult::Ok);
11691169

11701170
let mut node_addr = node_addr_default();
@@ -1175,8 +1175,8 @@ mod tests {
11751175

11761176
// accept connection
11771177
println!("[s] accepting conn");
1178-
let mut conn = connection_default();
1179-
let accept_res = endpoint_accept(&ep, alpn_s.as_ref(), &mut conn);
1178+
let conn = connection_default();
1179+
let accept_res = endpoint_accept(&ep, alpn_s.as_ref(), &conn);
11801180
println!("[s] accept_res: {accept_res:?}");
11811181
assert_eq!(accept_res, EndpointResult::Ok);
11821182

@@ -1199,17 +1199,17 @@ mod tests {
11991199
// setup client
12001200
let client_thread = std::thread::spawn(move || {
12011201
// create iroh endpoint and bind
1202-
let mut ep = endpoint_default();
1203-
let bind_res = endpoint_bind(&config_client, None, None, &mut ep);
1202+
let ep = endpoint_default();
1203+
let bind_res = endpoint_bind(&config_client, None, None, &ep);
12041204
assert_eq!(bind_res, EndpointResult::Ok);
12051205

12061206
// wait for addr from server
12071207
let node_addr = r.recv().unwrap();
12081208

12091209
println!("[c] dialing");
12101210
// connect to server
1211-
let mut conn = connection_default();
1212-
let connect_res = endpoint_connect(&ep, alpn.as_ref(), node_addr, &mut conn);
1211+
let conn = connection_default();
1212+
let connect_res = endpoint_connect(&ep, alpn.as_ref(), node_addr, &conn);
12131213
assert_eq!(connect_res, EndpointResult::Ok);
12141214

12151215
println!("[c] accepting uni");
@@ -1238,10 +1238,10 @@ mod tests {
12381238
let alpn: vec::Vec<u8> = b"/cool/alpn/1".to_vec().into();
12391239
// create config
12401240
let mut config_server = endpoint_config_default();
1241-
endpoint_config_add_alpn(&mut config_server, alpn.as_ref().into());
1241+
endpoint_config_add_alpn(&mut config_server, alpn.as_ref());
12421242

12431243
let mut config_client = endpoint_config_default();
1244-
endpoint_config_add_alpn(&mut config_client, alpn.as_ref().into());
1244+
endpoint_config_add_alpn(&mut config_client, alpn.as_ref());
12451245

12461246
let (s, r) = std::sync::mpsc::channel();
12471247
let (server_s, server_r) = std::sync::mpsc::channel();
@@ -1250,8 +1250,8 @@ mod tests {
12501250
let alpn_s = alpn.clone();
12511251
let server_thread = std::thread::spawn(move || {
12521252
// create iroh endpoint and bind
1253-
let mut ep = endpoint_default();
1254-
let bind_res = endpoint_bind(&config_server, None, None, &mut ep);
1253+
let ep = endpoint_default();
1254+
let bind_res = endpoint_bind(&config_server, None, None, &ep);
12551255
assert_eq!(bind_res, EndpointResult::Ok);
12561256

12571257
let mut node_addr = node_addr_default();
@@ -1262,8 +1262,8 @@ mod tests {
12621262

12631263
// accept connection
12641264
println!("[s] accepting conn");
1265-
let mut conn = connection_default();
1266-
let accept_res = endpoint_accept(&ep, alpn_s.as_ref(), &mut conn);
1265+
let conn = connection_default();
1266+
let accept_res = endpoint_accept(&ep, alpn_s.as_ref(), &conn);
12671267
assert_eq!(accept_res, EndpointResult::Ok);
12681268

12691269
println!("[s] reading");
@@ -1278,24 +1278,24 @@ mod tests {
12781278
// setup client
12791279
let client_thread = std::thread::spawn(move || {
12801280
// create iroh endpoint and bind
1281-
let mut ep = endpoint_default();
1282-
let bind_res = endpoint_bind(&config_client, None, None, &mut ep);
1281+
let ep = endpoint_default();
1282+
let bind_res = endpoint_bind(&config_client, None, None, &ep);
12831283
assert_eq!(bind_res, EndpointResult::Ok);
12841284

12851285
// wait for addr from server
12861286
let node_addr = r.recv().unwrap();
12871287

12881288
println!("[c] dialing");
12891289
// connect to server
1290-
let mut conn = connection_default();
1291-
let connect_res = endpoint_connect(&ep, alpn.as_ref(), node_addr, &mut conn);
1290+
let conn = connection_default();
1291+
let connect_res = endpoint_connect(&ep, alpn.as_ref(), node_addr, &conn);
12921292
assert_eq!(connect_res, EndpointResult::Ok);
12931293

12941294
println!("[c] sending");
12951295
let max_datagram = connection_max_datagram_size(&conn);
12961296
assert!(max_datagram > 0);
12971297
dbg!(max_datagram);
1298-
let send_res = connection_write_datagram(&mut conn, b"hello world"[..].into());
1298+
let send_res = connection_write_datagram(&conn, b"hello world"[..].into());
12991299
assert_eq!(send_res, EndpointResult::Ok);
13001300

13011301
// wait for the server to have received
@@ -1311,10 +1311,10 @@ mod tests {
13111311
let alpn: vec::Vec<u8> = b"/cool/alpn/1".to_vec().into();
13121312
// create config
13131313
let mut config_server = endpoint_config_default();
1314-
endpoint_config_add_alpn(&mut config_server, alpn.as_ref().into());
1314+
endpoint_config_add_alpn(&mut config_server, alpn.as_ref());
13151315

13161316
let mut config_client = endpoint_config_default();
1317-
endpoint_config_add_alpn(&mut config_client, alpn.as_ref().into());
1317+
endpoint_config_add_alpn(&mut config_client, alpn.as_ref());
13181318

13191319
let (s, r) = std::sync::mpsc::channel();
13201320
let (client_s, client_r) = std::sync::mpsc::channel();
@@ -1323,8 +1323,8 @@ mod tests {
13231323
let alpn_s = alpn.clone();
13241324
let server_thread = std::thread::spawn(move || {
13251325
// create iroh endpoint and bind
1326-
let mut ep = endpoint_default();
1327-
let bind_res = endpoint_bind(&config_server, None, None, &mut ep);
1326+
let ep = endpoint_default();
1327+
let bind_res = endpoint_bind(&config_server, None, None, &ep);
13281328
assert_eq!(bind_res, EndpointResult::Ok);
13291329

13301330
let mut node_addr = node_addr_default();
@@ -1335,8 +1335,8 @@ mod tests {
13351335

13361336
// accept connection
13371337
println!("[s] accepting conn");
1338-
let mut conn = connection_default();
1339-
let res = endpoint_accept(&ep, alpn_s.as_ref(), &mut conn);
1338+
let conn = connection_default();
1339+
let res = endpoint_accept(&ep, alpn_s.as_ref(), &conn);
13401340
assert_eq!(res, EndpointResult::Ok);
13411341

13421342
let mut send_stream = send_stream_default();
@@ -1366,17 +1366,17 @@ mod tests {
13661366
// setup client
13671367
let client_thread = std::thread::spawn(move || {
13681368
// create iroh endpoint and bind
1369-
let mut ep = endpoint_default();
1370-
let bind_res = endpoint_bind(&config_client, None, None, &mut ep);
1369+
let ep = endpoint_default();
1370+
let bind_res = endpoint_bind(&config_client, None, None, &ep);
13711371
assert_eq!(bind_res, EndpointResult::Ok);
13721372

13731373
// wait for addr from server
13741374
let node_addr = r.recv().unwrap();
13751375

13761376
println!("[c] dialing");
13771377
// connect to server
1378-
let mut conn = connection_default();
1379-
let connect_res = endpoint_connect(&ep, alpn.as_ref(), node_addr, &mut conn);
1378+
let conn = connection_default();
1379+
let connect_res = endpoint_connect(&ep, alpn.as_ref(), node_addr, &conn);
13801380
assert_eq!(connect_res, EndpointResult::Ok);
13811381

13821382
let mut send_stream = send_stream_default();
@@ -1414,12 +1414,12 @@ mod tests {
14141414

14151415
// create config
14161416
let mut config_server = endpoint_config_default();
1417-
endpoint_config_add_alpn(&mut config_server, alpn1.as_ref().into());
1418-
endpoint_config_add_alpn(&mut config_server, alpn2.as_ref().into());
1417+
endpoint_config_add_alpn(&mut config_server, alpn1.as_ref());
1418+
endpoint_config_add_alpn(&mut config_server, alpn2.as_ref());
14191419

14201420
let mut config_client = endpoint_config_default();
1421-
endpoint_config_add_alpn(&mut config_client, alpn1.as_ref().into());
1422-
endpoint_config_add_alpn(&mut config_client, alpn2.as_ref().into());
1421+
endpoint_config_add_alpn(&mut config_client, alpn1.as_ref());
1422+
endpoint_config_add_alpn(&mut config_client, alpn2.as_ref());
14231423

14241424
let (s, r) = std::sync::mpsc::channel();
14251425
let (client1_s, client1_r) = std::sync::mpsc::channel();
@@ -1452,17 +1452,17 @@ mod tests {
14521452
handles.push(std::thread::spawn(move || {
14531453
// accept connection
14541454
println!("[s][{i}] accepting conn");
1455-
let mut conn = connection_default();
1455+
let conn = connection_default();
14561456
let mut alpn = vec::Vec::EMPTY;
1457-
let res = endpoint_accept_any(&ep, &mut alpn, &mut conn);
1457+
let res = endpoint_accept_any(&ep, &mut alpn, &conn);
14581458
assert_eq!(res, EndpointResult::Ok);
14591459

14601460
let (j, client_r) = if alpn.as_ref() == alpn1_s.as_ref() {
14611461
(0, clients.lock().unwrap().remove(0))
14621462
} else if alpn.as_ref() == alpn2_s.as_ref() {
14631463
(1, clients.lock().unwrap().pop().unwrap())
14641464
} else {
1465-
panic!("unexpectd alpn: {:?}", alpn);
1465+
panic!("unexpectd alpn: {alpn:?}");
14661466
};
14671467

14681468
let mut send_stream = send_stream_default();
@@ -1526,9 +1526,9 @@ mod tests {
15261526

15271527
println!("[c][{i}] dialing");
15281528
// connect to server
1529-
let mut conn = connection_default();
1529+
let conn = connection_default();
15301530
let alpn = if i == 0 { alpn1 } else { alpn2 };
1531-
let connect_res = endpoint_connect(&ep, alpn.as_ref(), node_addr, &mut conn);
1531+
let connect_res = endpoint_connect(&ep, alpn.as_ref(), node_addr, &conn);
15321532
assert_eq!(connect_res, EndpointResult::Ok);
15331533

15341534
let mut send_stream = send_stream_default();
@@ -1623,7 +1623,7 @@ mod tests {
16231623
assert_eq!(res, EndpointResult::Ok);
16241624

16251625
if alpn.as_ref() != alpn_s.as_ref() {
1626-
panic!("unexpectd alpn: {:?}", alpn);
1626+
panic!("unexpectd alpn: {alpn:?}");
16271627
};
16281628

16291629
let mut send_stream = send_stream_default();

0 commit comments

Comments
 (0)