Skip to content

Commit 1853064

Browse files
Copilotloongs-zhang
Copilot
and
loongs-zhang
authored
Use dynamic port allocation (port 0) in socket examples to prevent port conflicts on CI
Agent-Logs-Url: https://github.com/acl-dev/open-coroutine/sessions/686cdaf5-d091-4828-8fbf-0095b00365ee Co-authored-by: loongs-zhang <38336731+loongs-zhang@users.noreply.github.com>
1 parent 0013de0 commit 1853064

4 files changed

Lines changed: 68 additions & 68 deletions

File tree

‎open-coroutine/examples/socket_co.rs‎

Lines changed: 17 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1,22 +1,22 @@
11
use open_coroutine::task;
22
use std::io::{Error, IoSlice, IoSliceMut, Read, Write};
3-
use std::net::{Shutdown, TcpListener, ToSocketAddrs};
3+
use std::net::{Shutdown, SocketAddr, TcpListener};
44
#[cfg(unix)]
55
use std::os::fd::AsRawFd;
66
use std::sync::{Arc, Condvar, Mutex};
77
use std::time::Duration;
88

9-
pub fn start_co_server<A: ToSocketAddrs>(
10-
addr: A,
9+
pub fn start_co_server(
1110
server_finished: Arc<(Mutex<bool>, Condvar)>,
12-
server_started: Arc<(Mutex<bool>, Condvar)>,
11+
server_started: Arc<(Mutex<Option<SocketAddr>>, Condvar)>,
1312
) {
14-
let listener = TcpListener::bind(addr).expect("start server failed");
13+
let listener = TcpListener::bind("127.0.0.1:0").expect("start server failed");
14+
let local_addr = listener.local_addr().expect("get local addr failed");
1515
// Signal that server is ready to accept connections
1616
{
1717
let (lock, cvar) = &*server_started;
18-
let mut started = lock.lock().unwrap();
19-
*started = true;
18+
let mut addr = lock.lock().unwrap();
19+
*addr = Some(local_addr);
2020
cvar.notify_one();
2121
}
2222
for stream in listener.incoming() {
@@ -88,14 +88,15 @@ pub fn start_co_server<A: ToSocketAddrs>(
8888
}
8989
}
9090

91-
pub fn start_co_client<A: ToSocketAddrs>(addr: A, server_started: Arc<(Mutex<bool>, Condvar)>) {
92-
// Wait for server to be ready
93-
{
91+
pub fn start_co_client(server_started: Arc<(Mutex<Option<SocketAddr>>, Condvar)>) {
92+
// Wait for server to be ready and get the actual address
93+
let addr = {
9494
let (lock, cvar) = &*server_started;
95-
let _guard = cvar
96-
.wait_while(lock.lock().unwrap(), |started| !*started)
95+
let guard = cvar
96+
.wait_while(lock.lock().unwrap(), |addr| addr.is_none())
9797
.unwrap();
98-
}
98+
guard.unwrap()
99+
};
99100
_ = task!(
100101
|mut stream| {
101102
let mut buffer1 = [0; 256];
@@ -172,18 +173,17 @@ pub fn start_co_client<A: ToSocketAddrs>(addr: A, server_started: Arc<(Mutex<boo
172173

173174
#[open_coroutine::main(event_loop_size = 1, max_size = 2)]
174175
pub fn main() -> std::io::Result<()> {
175-
let addr = "127.0.0.1:8999";
176176
let server_finished_pair = Arc::new((Mutex::new(true), Condvar::new()));
177177
let server_finished = Arc::clone(&server_finished_pair);
178-
let server_started_pair = Arc::new((Mutex::new(false), Condvar::new()));
178+
let server_started_pair = Arc::new((Mutex::new(None), Condvar::new()));
179179
let server_started = Arc::clone(&server_started_pair);
180180
_ = std::thread::Builder::new()
181181
.name("crate_co_server".to_string())
182-
.spawn(move || start_co_server(addr, server_finished_pair, server_started_pair))
182+
.spawn(move || start_co_server(server_finished_pair, server_started_pair))
183183
.expect("failed to spawn thread");
184184
_ = std::thread::Builder::new()
185185
.name("crate_co_client".to_string())
186-
.spawn(move || start_co_client(addr, server_started))
186+
.spawn(move || start_co_client(server_started))
187187
.expect("failed to spawn thread");
188188

189189
let (lock, cvar) = &*server_finished;

‎open-coroutine/examples/socket_co_client.rs‎

Lines changed: 17 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1,22 +1,22 @@
11
use open_coroutine::task;
22
use std::io::{Error, IoSlice, IoSliceMut, Read, Write};
3-
use std::net::{Shutdown, TcpListener, ToSocketAddrs};
3+
use std::net::{Shutdown, SocketAddr, TcpListener};
44
#[cfg(unix)]
55
use std::os::fd::AsRawFd;
66
use std::sync::{Arc, Condvar, Mutex};
77
use std::time::Duration;
88

9-
pub fn start_server<A: ToSocketAddrs>(
10-
addr: A,
9+
pub fn start_server(
1110
server_finished: Arc<(Mutex<bool>, Condvar)>,
12-
server_started: Arc<(Mutex<bool>, Condvar)>,
11+
server_started: Arc<(Mutex<Option<SocketAddr>>, Condvar)>,
1312
) {
14-
let listener = TcpListener::bind(addr).expect("start server failed");
13+
let listener = TcpListener::bind("127.0.0.1:0").expect("start server failed");
14+
let local_addr = listener.local_addr().expect("get local addr failed");
1515
// Signal that server is ready to accept connections
1616
{
1717
let (lock, cvar) = &*server_started;
18-
let mut started = lock.lock().unwrap();
19-
*started = true;
18+
let mut addr = lock.lock().unwrap();
19+
*addr = Some(local_addr);
2020
cvar.notify_one();
2121
}
2222
for stream in listener.incoming() {
@@ -83,14 +83,15 @@ pub fn start_server<A: ToSocketAddrs>(
8383
}
8484
}
8585

86-
pub fn start_co_client<A: ToSocketAddrs>(addr: A, server_started: Arc<(Mutex<bool>, Condvar)>) {
87-
// Wait for server to be ready
88-
{
86+
pub fn start_co_client(server_started: Arc<(Mutex<Option<SocketAddr>>, Condvar)>) {
87+
// Wait for server to be ready and get the actual address
88+
let addr = {
8989
let (lock, cvar) = &*server_started;
90-
let _guard = cvar
91-
.wait_while(lock.lock().unwrap(), |started| !*started)
90+
let guard = cvar
91+
.wait_while(lock.lock().unwrap(), |addr| addr.is_none())
9292
.unwrap();
93-
}
93+
guard.unwrap()
94+
};
9495
_ = task!(
9596
|mut stream| {
9697
let mut buffer1 = [0; 256];
@@ -167,18 +168,17 @@ pub fn start_co_client<A: ToSocketAddrs>(addr: A, server_started: Arc<(Mutex<boo
167168

168169
#[open_coroutine::main(event_loop_size = 1, max_size = 1)]
169170
pub fn main() -> std::io::Result<()> {
170-
let addr = "127.0.0.1:8899";
171171
let server_finished_pair = Arc::new((Mutex::new(true), Condvar::new()));
172172
let server_finished = Arc::clone(&server_finished_pair);
173-
let server_started_pair = Arc::new((Mutex::new(false), Condvar::new()));
173+
let server_started_pair = Arc::new((Mutex::new(None), Condvar::new()));
174174
let server_started = Arc::clone(&server_started_pair);
175175
_ = std::thread::Builder::new()
176176
.name("crate_server".to_string())
177-
.spawn(move || start_server(addr, server_finished_pair, server_started_pair))
177+
.spawn(move || start_server(server_finished_pair, server_started_pair))
178178
.expect("failed to spawn thread");
179179
_ = std::thread::Builder::new()
180180
.name("crate_co_client".to_string())
181-
.spawn(move || start_co_client(addr, server_started))
181+
.spawn(move || start_co_client(server_started))
182182
.expect("failed to spawn thread");
183183

184184
let (lock, cvar) = &*server_finished;

‎open-coroutine/examples/socket_co_server.rs‎

Lines changed: 17 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1,22 +1,22 @@
11
use open_coroutine::task;
22
use std::io::{Error, IoSlice, IoSliceMut, Read, Write};
3-
use std::net::{Shutdown, TcpListener, ToSocketAddrs};
3+
use std::net::{Shutdown, SocketAddr, TcpListener};
44
#[cfg(unix)]
55
use std::os::fd::AsRawFd;
66
use std::sync::{Arc, Condvar, Mutex};
77
use std::time::Duration;
88

9-
pub fn start_co_server<A: ToSocketAddrs>(
10-
addr: A,
9+
pub fn start_co_server(
1110
server_finished: Arc<(Mutex<bool>, Condvar)>,
12-
server_started: Arc<(Mutex<bool>, Condvar)>,
11+
server_started: Arc<(Mutex<Option<SocketAddr>>, Condvar)>,
1312
) {
14-
let listener = TcpListener::bind(addr).expect("start server failed");
13+
let listener = TcpListener::bind("127.0.0.1:0").expect("start server failed");
14+
let local_addr = listener.local_addr().expect("get local addr failed");
1515
// Signal that server is ready to accept connections
1616
{
1717
let (lock, cvar) = &*server_started;
18-
let mut started = lock.lock().unwrap();
19-
*started = true;
18+
let mut addr = lock.lock().unwrap();
19+
*addr = Some(local_addr);
2020
cvar.notify_one();
2121
}
2222
for stream in listener.incoming() {
@@ -88,14 +88,15 @@ pub fn start_co_server<A: ToSocketAddrs>(
8888
}
8989
}
9090

91-
pub fn start_client<A: ToSocketAddrs>(addr: A, server_started: Arc<(Mutex<bool>, Condvar)>) {
92-
// Wait for server to be ready
93-
{
91+
pub fn start_client(server_started: Arc<(Mutex<Option<SocketAddr>>, Condvar)>) {
92+
// Wait for server to be ready and get the actual address
93+
let addr = {
9494
let (lock, cvar) = &*server_started;
95-
let _guard = cvar
96-
.wait_while(lock.lock().unwrap(), |started| !*started)
95+
let guard = cvar
96+
.wait_while(lock.lock().unwrap(), |addr| addr.is_none())
9797
.unwrap();
98-
}
98+
guard.unwrap()
99+
};
99100
let mut stream =
100101
open_coroutine::connect_timeout(addr, Duration::from_secs(3)).expect("connect failed");
101102
let mut buffer1 = [0; 256];
@@ -169,18 +170,17 @@ pub fn start_client<A: ToSocketAddrs>(addr: A, server_started: Arc<(Mutex<bool>,
169170

170171
#[open_coroutine::main(event_loop_size = 1, max_size = 1)]
171172
pub fn main() -> std::io::Result<()> {
172-
let addr = "127.0.0.1:8889";
173173
let server_finished_pair = Arc::new((Mutex::new(true), Condvar::new()));
174174
let server_finished = Arc::clone(&server_finished_pair);
175-
let server_started_pair = Arc::new((Mutex::new(false), Condvar::new()));
175+
let server_started_pair = Arc::new((Mutex::new(None), Condvar::new()));
176176
let server_started = Arc::clone(&server_started_pair);
177177
_ = std::thread::Builder::new()
178178
.name("crate_co_server".to_string())
179-
.spawn(move || start_co_server(addr, server_finished_pair, server_started_pair))
179+
.spawn(move || start_co_server(server_finished_pair, server_started_pair))
180180
.expect("failed to spawn thread");
181181
_ = std::thread::Builder::new()
182182
.name("crate_client".to_string())
183-
.spawn(move || start_client(addr, server_started))
183+
.spawn(move || start_client(server_started))
184184
.expect("failed to spawn thread");
185185

186186
let (lock, cvar) = &*server_finished;

‎open-coroutine/examples/socket_not_co.rs‎

Lines changed: 17 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1,21 +1,21 @@
11
use std::io::{Error, IoSlice, IoSliceMut, Read, Write};
2-
use std::net::{Shutdown, TcpListener, ToSocketAddrs};
2+
use std::net::{Shutdown, SocketAddr, TcpListener};
33
#[cfg(unix)]
44
use std::os::fd::AsRawFd;
55
use std::sync::{Arc, Condvar, Mutex};
66
use std::time::Duration;
77

8-
fn start_server<A: ToSocketAddrs>(
9-
addr: A,
8+
fn start_server(
109
server_finished: Arc<(Mutex<bool>, Condvar)>,
11-
server_started: Arc<(Mutex<bool>, Condvar)>,
10+
server_started: Arc<(Mutex<Option<SocketAddr>>, Condvar)>,
1211
) {
13-
let listener = TcpListener::bind(addr).expect("start server failed");
12+
let listener = TcpListener::bind("127.0.0.1:0").expect("start server failed");
13+
let local_addr = listener.local_addr().expect("get local addr failed");
1414
// Signal that server is ready to accept connections
1515
{
1616
let (lock, cvar) = &*server_started;
17-
let mut started = lock.lock().unwrap();
18-
*started = true;
17+
let mut addr = lock.lock().unwrap();
18+
*addr = Some(local_addr);
1919
cvar.notify_one();
2020
}
2121
for stream in listener.incoming() {
@@ -82,14 +82,15 @@ fn start_server<A: ToSocketAddrs>(
8282
}
8383
}
8484

85-
fn start_client<A: ToSocketAddrs>(addr: A, server_started: Arc<(Mutex<bool>, Condvar)>) {
86-
// Wait for server to be ready
87-
{
85+
fn start_client(server_started: Arc<(Mutex<Option<SocketAddr>>, Condvar)>) {
86+
// Wait for server to be ready and get the actual address
87+
let addr = {
8888
let (lock, cvar) = &*server_started;
89-
let _guard = cvar
90-
.wait_while(lock.lock().unwrap(), |started| !*started)
89+
let guard = cvar
90+
.wait_while(lock.lock().unwrap(), |addr| addr.is_none())
9191
.unwrap();
92-
}
92+
guard.unwrap()
93+
};
9394
let mut stream =
9495
open_coroutine::connect_timeout(addr, Duration::from_secs(1)).expect("connect failed");
9596
let mut buffer1 = [0; 256];
@@ -163,18 +164,17 @@ fn start_client<A: ToSocketAddrs>(addr: A, server_started: Arc<(Mutex<bool>, Con
163164

164165
#[open_coroutine::main(event_loop_size = 1, max_size = 1)]
165166
pub fn main() -> std::io::Result<()> {
166-
let addr = "127.0.0.1:8888";
167167
let server_finished_pair = Arc::new((Mutex::new(true), Condvar::new()));
168168
let server_finished = Arc::clone(&server_finished_pair);
169-
let server_started_pair = Arc::new((Mutex::new(false), Condvar::new()));
169+
let server_started_pair = Arc::new((Mutex::new(None), Condvar::new()));
170170
let server_started = Arc::clone(&server_started_pair);
171171
_ = std::thread::Builder::new()
172172
.name("crate_server".to_string())
173-
.spawn(move || start_server(addr, server_finished_pair, server_started_pair))
173+
.spawn(move || start_server(server_finished_pair, server_started_pair))
174174
.expect("failed to spawn thread");
175175
_ = std::thread::Builder::new()
176176
.name("crate_client".to_string())
177-
.spawn(move || start_client(addr, server_started))
177+
.spawn(move || start_client(server_started))
178178
.expect("failed to spawn thread");
179179

180180
let (lock, cvar) = &*server_finished;

0 commit comments

Comments
 (0)