use log::{info, warn};
use std::net::TcpListener;
use std::time::Duration;
use thiserror::Error;
#[derive(Error, Debug)]
pub enum PortSnifferError {
#[error("Port {0} out of valid range (0-65535)")]
PortOutOfRange(u16),
#[error("No available port: {0}")]
NoAvailablePort(String),
}
#[derive(Debug, Clone)]
pub struct PortSnifferResult {
pub success: bool,
pub port: u16,
pub logs: Vec<String>,
}
pub struct PortSniffer;
impl PortSniffer {
pub fn is_port_in_use(port: u16) -> bool {
TcpListener::bind(("0.0.0.0", port)).is_err()
}
pub fn find_available_port(
start_port: u16,
enable_detection: bool,
max_attempts: u16,
) -> Result<PortSnifferResult, PortSnifferError> {
let mut logs = Vec::new();
logs.push(format!(
"Starting port detection, start port: {}",
start_port
));
if !enable_detection {
return Ok(Self::resolve_fixed_port(start_port, logs));
}
Self::scan_ports(start_port, max_attempts, logs)
}
fn resolve_fixed_port(start_port: u16, mut logs: Vec<String>) -> PortSnifferResult {
if Self::is_port_in_use(start_port) {
logs.push(format!(
"Port {} is in use and auto-sniffing is not enabled",
start_port
));
warn!(
"Port {} is in use and auto-sniffing is not enabled",
start_port
);
return PortSnifferResult {
success: true,
port: start_port,
logs,
};
}
PortSnifferResult {
success: true,
port: start_port,
logs,
}
}
fn scan_ports(
start_port: u16,
max_attempts: u16,
mut logs: Vec<String>,
) -> Result<PortSnifferResult, PortSnifferError> {
let mut current_port = start_port;
let mut attempts = 0;
while attempts < max_attempts {
if !Self::is_port_in_use(current_port) {
logs.push(format!("Found available port: {}", current_port));
info!("Found available port: {}", current_port);
return Ok(PortSnifferResult {
success: true,
port: current_port,
logs,
});
}
attempts += 1;
logs.push(format!("Port {} is in use", current_port));
if attempts < max_attempts {
warn!(
"Port {} is in use, trying next port... ({}/{})",
current_port, attempts, max_attempts
);
}
if current_port == 65535 {
return Err(PortSnifferError::PortOutOfRange(current_port));
}
current_port += 1;
std::thread::sleep(Duration::from_millis(100));
}
Err(PortSnifferError::NoAvailablePort(format!(
"No available port found after {} attempts (range {}-{})",
max_attempts,
start_port,
current_port - 1
)))
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::TcpListener;
#[test]
fn test_is_port_in_use() {
let listener = TcpListener::bind("0.0.0.0:0").unwrap();
let port = listener.local_addr().unwrap().port();
assert!(PortSniffer::is_port_in_use(port));
}
#[test]
fn test_find_available_port_no_conflict() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
drop(listener);
let result = PortSniffer::find_available_port(port, true, 50).unwrap();
assert_eq!(result.port, port);
assert!(result.success);
}
#[test]
fn test_find_available_port_with_conflict() {
let listener = TcpListener::bind("0.0.0.0:0").unwrap();
let port = listener.local_addr().unwrap().port();
let result = PortSniffer::find_available_port(port, true, 50).unwrap();
assert!(result.port > port);
assert!(result.success);
assert!(result.logs.iter().any(|log| log.contains("in use")));
}
#[test]
fn test_disable_detection() {
let listener = TcpListener::bind("0.0.0.0:0").unwrap();
let port = listener.local_addr().unwrap().port();
let result = PortSniffer::find_available_port(port, false, 50).unwrap();
assert_eq!(result.port, port);
}
#[test]
fn test_is_port_in_use_returns_false_for_free_port() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
drop(listener);
assert!(
!PortSniffer::is_port_in_use(port),
"port {} should be free after drop",
port
);
}
#[test]
fn test_find_available_port_logs_start_message() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
drop(listener);
let result = PortSniffer::find_available_port(port, true, 5).unwrap();
assert!(
result
.logs
.iter()
.any(|log| log.contains("Starting port detection")
&& log.contains(&port.to_string())),
"logs should contain start message with port, got: {:?}",
result.logs
);
}
#[test]
fn test_find_available_port_logs_found_message() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
drop(listener);
let result = PortSniffer::find_available_port(port, true, 5).unwrap();
assert!(
result
.logs
.iter()
.any(|log| log.contains("Found available port")),
"logs should contain found message, got: {:?}",
result.logs
);
}
#[test]
fn test_find_available_port_disabled_detection_logs_in_use() {
let listener = TcpListener::bind("0.0.0.0:0").unwrap();
let port = listener.local_addr().unwrap().port();
let result = PortSniffer::find_available_port(port, false, 5).unwrap();
assert!(
result
.logs
.iter()
.any(|log| log.contains("in use") && log.contains("auto-sniffing")),
"logs should indicate port in use and detection disabled, got: {:?}",
result.logs
);
}
#[test]
fn test_find_available_port_disabled_detection_no_log_when_free() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
drop(listener);
let result = PortSniffer::find_available_port(port, false, 5).unwrap();
assert!(
!result.logs.iter().any(|log| log.contains("in use")),
"should not log in-use when port is free, got: {:?}",
result.logs
);
}
#[test]
fn test_find_available_port_success_is_true() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
drop(listener);
let result = PortSniffer::find_available_port(port, true, 10).unwrap();
assert!(result.success, "success should be true when port found");
}
#[test]
fn test_find_available_port_disabled_detection_success_is_true() {
let listener = TcpListener::bind("0.0.0.0:0").unwrap();
let port = listener.local_addr().unwrap().port();
let result = PortSniffer::find_available_port(port, false, 5).unwrap();
assert!(
result.success,
"success should be true even when port is in use with detection disabled"
);
assert_eq!(result.port, port);
}
#[test]
fn test_find_available_port_with_conflict_increments_port() {
let listener = TcpListener::bind("0.0.0.0:0").unwrap();
let port = listener.local_addr().unwrap().port();
let result = PortSniffer::find_available_port(port, true, 50).unwrap();
assert!(
result.port > port,
"should find a port greater than occupied start port"
);
assert!(result.logs.iter().any(|log| log.contains("in use")));
}
#[test]
fn test_find_available_port_zero_attempts_returns_error() {
let result = PortSniffer::find_available_port(8080, true, 0);
assert!(result.is_err());
match result {
Err(PortSnifferError::NoAvailablePort(msg)) => {
assert!(
msg.contains("8080"),
"error message should contain start port, got: {}",
msg
);
assert!(
msg.contains("0"),
"error message should contain attempts count, got: {}",
msg
);
}
other => panic!("expected NoAvailablePort, got {:?}", other),
}
}
#[test]
fn test_find_available_port_one_attempt_with_conflict_returns_error() {
let listener = TcpListener::bind("0.0.0.0:0").unwrap();
let port = listener.local_addr().unwrap().port();
let result = PortSniffer::find_available_port(port, true, 1);
assert!(
result.is_err(),
"should return error when only 1 attempt and port is busy"
);
assert!(
matches!(result, Err(PortSnifferError::NoAvailablePort(_))),
"expected NoAvailablePort, got {:?}",
result
);
}
#[test]
fn test_find_available_port_at_65535_boundary_with_conflict() {
let listener = match TcpListener::bind("0.0.0.0:65535") {
Ok(l) => l,
Err(_) => {
return;
}
};
let result = PortSniffer::find_available_port(65535, true, 5);
assert!(result.is_err());
match result {
Err(PortSnifferError::PortOutOfRange(port)) => {
assert_eq!(port, 65535);
}
other => panic!("expected PortOutOfRange(65535), got {:?}", other),
}
drop(listener);
}
#[test]
fn test_port_sniffer_error_port_out_of_range_display() {
let err = PortSnifferError::PortOutOfRange(65535u16);
let msg = err.to_string();
assert!(msg.contains("65535"), "msg: {}", msg);
assert!(msg.contains("out of valid range"), "msg: {}", msg);
}
#[test]
fn test_port_sniffer_error_no_available_port_display() {
let err = PortSnifferError::NoAvailablePort("no port found in range".to_string());
let msg = err.to_string();
assert!(msg.contains("No available port"), "msg: {}", msg);
assert!(msg.contains("no port found in range"), "msg: {}", msg);
}
#[test]
fn test_port_sniffer_result_clone() {
let result = PortSnifferResult {
success: true,
port: 8080,
logs: vec!["log1".to_string(), "log2".to_string()],
};
let cloned = result.clone();
assert_eq!(cloned.success, result.success);
assert_eq!(cloned.port, result.port);
assert_eq!(cloned.logs, result.logs);
}
#[test]
fn test_port_sniffer_result_debug() {
let result = PortSnifferResult {
success: false,
port: 9000,
logs: vec!["debug-log".to_string()],
};
let debug_str = format!("{:?}", result);
assert!(
debug_str.contains("PortSnifferResult"),
"debug: {}",
debug_str
);
assert!(debug_str.contains("9000"), "debug: {}", debug_str);
assert!(debug_str.contains("debug-log"), "debug: {}", debug_str);
}
#[test]
fn test_port_sniffer_result_construction() {
let logs = vec!["开始端口检测".to_string(), "找到可用端口".to_string()];
let result = PortSnifferResult {
success: true,
port: 3000,
logs: logs.clone(),
};
assert!(result.success);
assert_eq!(result.port, 3000);
assert_eq!(result.logs, logs);
assert_eq!(result.logs.len(), 2);
}
#[test]
fn test_find_available_port_returns_logs_non_empty() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
drop(listener);
let result = PortSniffer::find_available_port(port, true, 5).unwrap();
assert!(!result.logs.is_empty(), "logs should not be empty");
assert!(
result.logs.len() >= 2,
"should have at least start and found logs"
);
}
}