chore: initial sanitized public snapshot
This commit is contained in:
Aria2 Rust Pro Contributors
@@ -0,0 +1,930 @@
|
||||
use std::{
|
||||
collections::VecDeque,
|
||||
ffi::OsString,
|
||||
fs,
|
||||
io::{BufRead, BufReader, Read, Write},
|
||||
net::{TcpListener, TcpStream},
|
||||
process::{Child, Command, ExitStatus, Stdio},
|
||||
sync::{
|
||||
Arc, Mutex,
|
||||
atomic::{AtomicUsize, Ordering},
|
||||
},
|
||||
thread,
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
|
||||
use aria2_rust_pro_core::RuntimeConfig;
|
||||
use aria2_rust_pro_protocol::{
|
||||
Downloader, FixtureHttpDownloader, FtpConfigModel, FtpRequestModel, FtpResponseModel,
|
||||
HttpResponseHeaders, HttpResponseModel, HttpVersion, Protocol, ReqwestHttpConnector,
|
||||
ResponseBody, SftpConfigModel, SftpRequestModel, SftpResponseModel,
|
||||
transport::{TransportError, TransportErrorKind},
|
||||
};
|
||||
use aria2_rust_pro_rpc::{InProcessRpcDispatcher, JsonRpcRequest, RpcMethod, RpcValue};
|
||||
|
||||
use super::http_runtime::partition_indexed_work_evenly;
|
||||
use super::{
|
||||
CliError, CliTransferSource, CommandSurface, Invocation, RuntimeMode, StartupProfile,
|
||||
TransferSelection, build_ftp_transfer_parts, build_http_transfer_task, classify_transfer,
|
||||
command_surface, derive_http_session, derive_runtime_config, execute,
|
||||
execute_http_transfer_with_retry, execute_runtime, execute_runtime_with_context,
|
||||
execute_runtime_with_downloader, execute_segment_transfers, load_config_report, merged_profile,
|
||||
parse_args, parse_cli, parse_protocol, planned_segment_span, profile_option_map, render_help,
|
||||
render_version,
|
||||
};
|
||||
|
||||
fn percent_encode_uri_component(value: &str) -> String {
|
||||
let mut encoded = String::with_capacity(value.len());
|
||||
for byte in value.bytes() {
|
||||
if matches!(byte, b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~') {
|
||||
encoded.push(char::from(byte));
|
||||
} else {
|
||||
encoded.push('%');
|
||||
std::fmt::Write::write_fmt(&mut encoded, format_args!("{byte:02X}"))
|
||||
.expect("writing percent-encoded byte into string must succeed");
|
||||
}
|
||||
}
|
||||
encoded
|
||||
}
|
||||
|
||||
fn start_live_bt_tracker_fixture() -> (String, thread::JoinHandle<()>) {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").expect("local listener should bind");
|
||||
let addr = listener.local_addr().expect("local addr should exist");
|
||||
let handle = thread::spawn(move || {
|
||||
for _ in 0..2 {
|
||||
let (mut stream, _) = listener.accept().expect("tracker client should connect");
|
||||
let mut request = [0_u8; 2048];
|
||||
let read = stream.read(&mut request).expect("request should read");
|
||||
let request_slice = request
|
||||
.get(..read)
|
||||
.expect("read length must stay within request buffer");
|
||||
let request_text = String::from_utf8_lossy(request_slice);
|
||||
let (payload, path) = if request_text.starts_with("GET /announce?") {
|
||||
(
|
||||
b"d8:intervali600e10:tracker id12:cli-live-0015:peers6:\x7f\x00\x00\x01\x1a\xe1e"
|
||||
.to_vec(),
|
||||
"/announce",
|
||||
)
|
||||
} else {
|
||||
(
|
||||
b"d8:completei4e10:downloadedi9e10:incompletei2ee".to_vec(),
|
||||
"/scrape",
|
||||
)
|
||||
};
|
||||
assert!(request_text.contains(path));
|
||||
let response = format!(
|
||||
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nContent-Type: text/plain\r\n\r\n",
|
||||
payload.len()
|
||||
);
|
||||
stream
|
||||
.write_all(response.as_bytes())
|
||||
.expect("headers should write");
|
||||
stream.write_all(&payload).expect("payload should write");
|
||||
}
|
||||
});
|
||||
(format!("http://{addr}/announce"), handle)
|
||||
}
|
||||
|
||||
fn build_single_file_torrent_bytes(
|
||||
announce_url: &str,
|
||||
file_name: &str,
|
||||
total_length: u64,
|
||||
piece_length: u64,
|
||||
) -> Vec<u8> {
|
||||
fn bencode_bytes(value: &[u8]) -> Vec<u8> {
|
||||
let mut encoded = format!("{}:", value.len()).into_bytes();
|
||||
encoded.extend_from_slice(value);
|
||||
encoded
|
||||
}
|
||||
|
||||
fn bencode_int(value: u64) -> Vec<u8> {
|
||||
format!("i{value}e").into_bytes()
|
||||
}
|
||||
|
||||
let mut torrent = Vec::new();
|
||||
torrent.extend_from_slice(b"d8:announce");
|
||||
torrent.extend_from_slice(&bencode_bytes(announce_url.as_bytes()));
|
||||
torrent.extend_from_slice(b"4:infod6:length");
|
||||
torrent.extend_from_slice(&bencode_int(total_length));
|
||||
torrent.extend_from_slice(b"4:name");
|
||||
torrent.extend_from_slice(&bencode_bytes(file_name.as_bytes()));
|
||||
torrent.extend_from_slice(b"12:piece length");
|
||||
torrent.extend_from_slice(&bencode_int(piece_length));
|
||||
torrent.extend_from_slice(b"6:pieces20:");
|
||||
torrent.extend_from_slice(&[0_u8; 20]);
|
||||
torrent.extend_from_slice(b"ee");
|
||||
torrent
|
||||
}
|
||||
#[test]
|
||||
fn execute_runtime_with_local_metalink_fixture_expands_multiple_files_and_uses_implied_output_names()
|
||||
{
|
||||
let mut downloader = FixtureHttpDownloader::new();
|
||||
downloader.register("http://example.com/alpha.bin", b"abc");
|
||||
downloader.register("http://example.com/beta.bin", b"hello");
|
||||
|
||||
let temp_dir = std::env::temp_dir().join("aria2-rust-pro-cli-metalink-multifile-test");
|
||||
let _ = fs::create_dir_all(&temp_dir);
|
||||
let download_dir = temp_dir.join("downloads");
|
||||
let metalink_path = temp_dir.join("fixture.meta4");
|
||||
let config_path = temp_dir.join("aria2.conf");
|
||||
fs::write(
|
||||
&metalink_path,
|
||||
r#"<?xml version="1.0" encoding="utf-8"?>
|
||||
<metalink version="4.0">
|
||||
<file name="alpha.bin">
|
||||
<hash type="md5">900150983cd24fb0d6963f7d28e17f72</hash>
|
||||
<url priority="1">http://example.com/alpha.bin</url>
|
||||
</file>
|
||||
<file name="beta.bin">
|
||||
<url priority="1">http://example.com/beta.bin</url>
|
||||
</file>
|
||||
</metalink>"#,
|
||||
)
|
||||
.expect("metalink file should write");
|
||||
fs::write(&config_path, format!("dir={}\n", download_dir.display()))
|
||||
.expect("config should write");
|
||||
|
||||
let report = execute_runtime_with_downloader(
|
||||
Invocation::Run {
|
||||
config_path: Some(config_path),
|
||||
uris: vec![metalink_path.to_string_lossy().into_owned()],
|
||||
},
|
||||
&downloader,
|
||||
)
|
||||
.expect("runtime should execute with expanded metalink fixture");
|
||||
|
||||
assert_eq!(report.accepted_uri_count, 2);
|
||||
assert_eq!(report.first_status.as_deref(), Some("complete"));
|
||||
assert_eq!(report.first_total_length, Some(3));
|
||||
assert_eq!(report.first_completed_length, Some(3));
|
||||
assert_eq!(report.transfer_kinds, vec![TransferSelection::Metalink]);
|
||||
assert_eq!(report.completed_download_count, 2);
|
||||
assert_eq!(
|
||||
fs::read(download_dir.join("alpha.bin")).expect("alpha output should exist"),
|
||||
b"abc"
|
||||
);
|
||||
assert_eq!(
|
||||
fs::read(download_dir.join("beta.bin")).expect("beta output should exist"),
|
||||
b"hello"
|
||||
);
|
||||
|
||||
let _ = fs::remove_dir_all(temp_dir);
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
struct SequencedHttpDownloader {
|
||||
responses: Arc<Mutex<Vec<Result<HttpResponseModel, TransportError>>>>,
|
||||
requests: Arc<Mutex<Vec<aria2_rust_pro_protocol::HttpTransferTaskModel>>>,
|
||||
}
|
||||
|
||||
struct LocalFtpTestServer {
|
||||
control_port: u16,
|
||||
join: Option<thread::JoinHandle<()>>,
|
||||
}
|
||||
|
||||
impl LocalFtpTestServer {
|
||||
fn spawn(payload: Vec<u8>) -> Self {
|
||||
let control_listener =
|
||||
TcpListener::bind("127.0.0.1:0").expect("control listener should bind");
|
||||
let control_port = control_listener
|
||||
.local_addr()
|
||||
.expect("control addr should exist")
|
||||
.port();
|
||||
let data_listener = TcpListener::bind("127.0.0.1:0").expect("data listener should bind");
|
||||
let data_addr = data_listener.local_addr().expect("data addr should exist");
|
||||
let join = thread::spawn(move || {
|
||||
let (mut control_stream, _) = control_listener
|
||||
.accept()
|
||||
.expect("control connection should arrive");
|
||||
control_stream
|
||||
.write_all(b"220 local ftp ready\r\n")
|
||||
.expect("welcome should write");
|
||||
let mut control_reader =
|
||||
BufReader::new(control_stream.try_clone().expect("clone should work"));
|
||||
loop {
|
||||
let mut line = String::new();
|
||||
let read = control_reader
|
||||
.read_line(&mut line)
|
||||
.expect("control line should read");
|
||||
if read == 0 {
|
||||
break;
|
||||
}
|
||||
if line.starts_with("USER ") {
|
||||
control_stream
|
||||
.write_all(b"331 password required\r\n")
|
||||
.expect("USER response should write");
|
||||
} else if line.starts_with("PASS ") {
|
||||
control_stream
|
||||
.write_all(b"230 login ok\r\n")
|
||||
.expect("PASS response should write");
|
||||
} else if line.starts_with("TYPE ") {
|
||||
control_stream
|
||||
.write_all(b"200 type ok\r\n")
|
||||
.expect("TYPE response should write");
|
||||
} else if line.starts_with("PASV") {
|
||||
let port_hi = data_addr.port().div_euclid(256);
|
||||
let port_lo = data_addr.port().rem_euclid(256);
|
||||
let response =
|
||||
format!("227 Entering Passive Mode (127,0,0,1,{port_hi},{port_lo})\r\n");
|
||||
control_stream
|
||||
.write_all(response.as_bytes())
|
||||
.expect("PASV response should write");
|
||||
} else if line.starts_with("RETR ") {
|
||||
control_stream
|
||||
.write_all(b"150 opening data\r\n")
|
||||
.expect("RETR prelim response should write");
|
||||
let (mut data_stream, _) = data_listener
|
||||
.accept()
|
||||
.expect("data connection should arrive");
|
||||
data_stream
|
||||
.write_all(&payload)
|
||||
.expect("payload should write");
|
||||
drop(data_stream);
|
||||
control_stream
|
||||
.write_all(b"226 transfer complete\r\n")
|
||||
.expect("RETR completion should write");
|
||||
} else if line.starts_with("QUIT") {
|
||||
control_stream
|
||||
.write_all(b"221 bye\r\n")
|
||||
.expect("QUIT response should write");
|
||||
break;
|
||||
} else {
|
||||
control_stream
|
||||
.write_all(b"500 unsupported\r\n")
|
||||
.expect("fallback response should write");
|
||||
}
|
||||
}
|
||||
});
|
||||
Self {
|
||||
control_port,
|
||||
join: Some(join),
|
||||
}
|
||||
}
|
||||
|
||||
fn control_port(&self) -> u16 {
|
||||
self.control_port
|
||||
}
|
||||
|
||||
fn join(mut self) {
|
||||
if let Some(join) = self.join.take() {
|
||||
join.join().expect("ftp server thread should join");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct LiveFtpSmokeDownloader;
|
||||
struct LiveSftpSmokeDownloader;
|
||||
|
||||
#[derive(Debug)]
|
||||
struct LocalSftpDockerServer {
|
||||
container_name: String,
|
||||
port: u16,
|
||||
payload_len: usize,
|
||||
}
|
||||
|
||||
impl LocalSftpDockerServer {
|
||||
const DOCKER_EXEC_TIMEOUT: Duration = Duration::from_secs(5);
|
||||
const DOCKER_RM_TIMEOUT: Duration = Duration::from_secs(5);
|
||||
const DOCKER_RUN_TIMEOUT: Duration = Duration::from_secs(30);
|
||||
|
||||
fn spawn() -> Option<Self> {
|
||||
let docker = Command::new("docker")
|
||||
.arg("--version")
|
||||
.stdout(Stdio::null())
|
||||
.stderr(Stdio::null())
|
||||
.status()
|
||||
.ok()?;
|
||||
if !docker.success() {
|
||||
return None;
|
||||
}
|
||||
let port = Self::pick_port();
|
||||
let container_name = format!("aria2-rust-pro-sftp-smoke-{port}");
|
||||
let payload = "hello-from-live-sftp\n";
|
||||
let payload_len = payload.len();
|
||||
let port_binding = format!("{port}:22");
|
||||
let run = Self::docker_status_with_timeout(
|
||||
&[
|
||||
"run",
|
||||
"--rm",
|
||||
"-d",
|
||||
"--name",
|
||||
&container_name,
|
||||
"-p",
|
||||
&port_binding,
|
||||
"atmoz/sftp:debian",
|
||||
"foo:pass:1001::upload",
|
||||
],
|
||||
Self::DOCKER_RUN_TIMEOUT,
|
||||
)?;
|
||||
if !run.success() {
|
||||
return None;
|
||||
}
|
||||
for _ in 0..20 {
|
||||
if Self::docker_status_with_timeout(
|
||||
&[
|
||||
"exec",
|
||||
&container_name,
|
||||
"sh",
|
||||
"-lc",
|
||||
"echo 'hello-from-live-sftp' > /home/foo/upload/hello.txt",
|
||||
],
|
||||
Self::DOCKER_EXEC_TIMEOUT,
|
||||
)
|
||||
.is_some_and(|status| status.success())
|
||||
{
|
||||
if Self::wait_until_ready(port) {
|
||||
return Some(Self {
|
||||
container_name,
|
||||
port,
|
||||
payload_len,
|
||||
});
|
||||
}
|
||||
break;
|
||||
}
|
||||
thread::sleep(Duration::from_millis(250));
|
||||
}
|
||||
let _ = Self::docker_status_with_timeout(
|
||||
&["rm", "-f", &container_name],
|
||||
Self::DOCKER_RM_TIMEOUT,
|
||||
);
|
||||
None
|
||||
}
|
||||
|
||||
fn pick_port() -> u16 {
|
||||
TcpListener::bind("127.0.0.1:0")
|
||||
.expect("test should pick local port")
|
||||
.local_addr()
|
||||
.expect("local addr should exist")
|
||||
.port()
|
||||
}
|
||||
|
||||
fn host_port(&self) -> u16 {
|
||||
self.port
|
||||
}
|
||||
|
||||
fn payload_len(&self) -> usize {
|
||||
self.payload_len
|
||||
}
|
||||
|
||||
fn wait_until_ready(port: u16) -> bool {
|
||||
for _ in 0..40 {
|
||||
if let Ok(stream) = TcpStream::connect(("127.0.0.1", port)) {
|
||||
let _ = stream.set_read_timeout(Some(Duration::from_secs(2)));
|
||||
let _ = stream.set_write_timeout(Some(Duration::from_secs(2)));
|
||||
if let Ok(mut session) = ssh2::Session::new() {
|
||||
session.set_tcp_stream(stream);
|
||||
if session.handshake().is_ok()
|
||||
&& session.userauth_password("foo", "pass").is_ok()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
thread::sleep(Duration::from_millis(250));
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
fn docker_status_with_timeout(args: &[&str], timeout: Duration) -> Option<ExitStatus> {
|
||||
let mut child = Command::new("docker")
|
||||
.args(args)
|
||||
.stdout(Stdio::null())
|
||||
.stderr(Stdio::null())
|
||||
.spawn()
|
||||
.ok()?;
|
||||
Self::wait_child_with_timeout(&mut child, timeout)
|
||||
}
|
||||
|
||||
fn wait_child_with_timeout(child: &mut Child, timeout: Duration) -> Option<ExitStatus> {
|
||||
let started_at = Instant::now();
|
||||
loop {
|
||||
if let Some(status) = child.try_wait().ok()? {
|
||||
return Some(status);
|
||||
}
|
||||
if started_at.elapsed() >= timeout {
|
||||
let _ = child.kill();
|
||||
let _ = child.wait();
|
||||
return None;
|
||||
}
|
||||
thread::sleep(Duration::from_millis(100));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for LocalSftpDockerServer {
|
||||
fn drop(&mut self) {
|
||||
let _ = Self::docker_status_with_timeout(
|
||||
&["rm", "-f", &self.container_name],
|
||||
Self::DOCKER_RM_TIMEOUT,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
impl LiveFtpSmokeDownloader {
|
||||
#[expect(
|
||||
clippy::result_large_err,
|
||||
reason = "test-only live FTP smoke helpers bubble full transport context for assertions"
|
||||
)]
|
||||
fn read_response_line(reader: &mut BufReader<TcpStream>) -> Result<String, TransportError> {
|
||||
let mut line = String::new();
|
||||
reader
|
||||
.read_line(&mut line)
|
||||
.map_err(|error| TransportError {
|
||||
kind: TransportErrorKind::Io,
|
||||
message: format!("failed to read ftp response: {error}"),
|
||||
source: Some(error.to_string()),
|
||||
context: None,
|
||||
})?;
|
||||
Ok(line)
|
||||
}
|
||||
|
||||
#[expect(
|
||||
clippy::result_large_err,
|
||||
reason = "test-only live FTP smoke helpers bubble full transport context for assertions"
|
||||
)]
|
||||
fn expect_code(
|
||||
reader: &mut BufReader<TcpStream>,
|
||||
expected: u16,
|
||||
) -> Result<String, TransportError> {
|
||||
let line = Self::read_response_line(reader)?;
|
||||
let code = line
|
||||
.get(0..3)
|
||||
.and_then(|digits| digits.parse::<u16>().ok())
|
||||
.ok_or_else(|| TransportError {
|
||||
kind: TransportErrorKind::ProtocolViolation,
|
||||
message: format!("invalid ftp response line: {line:?}"),
|
||||
source: None,
|
||||
context: None,
|
||||
})?;
|
||||
if code != expected {
|
||||
return Err(TransportError {
|
||||
kind: TransportErrorKind::ProtocolViolation,
|
||||
message: format!("expected ftp code {expected}, got {code}: {line}"),
|
||||
source: None,
|
||||
context: None,
|
||||
});
|
||||
}
|
||||
Ok(line)
|
||||
}
|
||||
|
||||
#[expect(
|
||||
clippy::result_large_err,
|
||||
reason = "test-only live FTP smoke helpers bubble full transport context for assertions"
|
||||
)]
|
||||
fn write_command(stream: &mut TcpStream, command: &str) -> Result<(), TransportError> {
|
||||
stream
|
||||
.write_all(command.as_bytes())
|
||||
.map_err(|error| TransportError {
|
||||
kind: TransportErrorKind::Io,
|
||||
message: format!("failed to write ftp command {command:?}: {error}"),
|
||||
source: Some(error.to_string()),
|
||||
context: None,
|
||||
})
|
||||
}
|
||||
|
||||
#[expect(
|
||||
clippy::result_large_err,
|
||||
reason = "test-only live FTP smoke helpers bubble full transport context for assertions"
|
||||
)]
|
||||
fn parse_pasv_addr(line: &str) -> Result<(String, u16), TransportError> {
|
||||
let (_, after_open) = line.split_once('(').ok_or_else(|| TransportError {
|
||||
kind: TransportErrorKind::ProtocolViolation,
|
||||
message: format!("missing PASV tuple in response: {line}"),
|
||||
source: None,
|
||||
context: None,
|
||||
})?;
|
||||
let (tuple_text, _) = after_open.split_once(')').ok_or_else(|| TransportError {
|
||||
kind: TransportErrorKind::ProtocolViolation,
|
||||
message: format!("unterminated PASV tuple in response: {line}"),
|
||||
source: None,
|
||||
context: None,
|
||||
})?;
|
||||
let parts = tuple_text
|
||||
.split(',')
|
||||
.map(str::trim)
|
||||
.map(str::parse::<u16>)
|
||||
.collect::<Result<Vec<_>, _>>()
|
||||
.map_err(|error| TransportError {
|
||||
kind: TransportErrorKind::ProtocolViolation,
|
||||
message: format!("invalid PASV tuple in response: {line}: {error}"),
|
||||
source: Some(error.to_string()),
|
||||
context: None,
|
||||
})?;
|
||||
let [a, b, c, d, hi, lo]: [u16; 6] =
|
||||
parts.try_into().map_err(|parts: Vec<u16>| TransportError {
|
||||
kind: TransportErrorKind::ProtocolViolation,
|
||||
message: format!("expected 6 PASV tuple parts, got {}: {line}", parts.len()),
|
||||
source: None,
|
||||
context: None,
|
||||
})?;
|
||||
let host = format!("{a}.{b}.{c}.{d}");
|
||||
let port = hi
|
||||
.checked_mul(256)
|
||||
.and_then(|value| value.checked_add(lo))
|
||||
.ok_or_else(|| TransportError {
|
||||
kind: TransportErrorKind::ProtocolViolation,
|
||||
message: format!("invalid PASV port tuple in response: {line}"),
|
||||
source: None,
|
||||
context: None,
|
||||
})?;
|
||||
Ok((host, port))
|
||||
}
|
||||
}
|
||||
|
||||
impl Downloader for LiveFtpSmokeDownloader {
|
||||
fn start_http_transfer(
|
||||
&self,
|
||||
_task: &aria2_rust_pro_protocol::HttpTransferTaskModel,
|
||||
) -> Result<HttpResponseModel, TransportError> {
|
||||
Err(TransportError {
|
||||
kind: TransportErrorKind::UnsupportedScheme,
|
||||
message: "http unused in live ftp smoke".to_owned(),
|
||||
source: None,
|
||||
context: None,
|
||||
})
|
||||
}
|
||||
|
||||
fn start_ftp_transfer(
|
||||
&self,
|
||||
config: &FtpConfigModel,
|
||||
request: &FtpRequestModel,
|
||||
) -> Result<FtpResponseModel, TransportError> {
|
||||
let mut control_stream =
|
||||
TcpStream::connect((config.host.as_str(), config.port)).map_err(|error| {
|
||||
TransportError {
|
||||
kind: TransportErrorKind::NotConnected,
|
||||
message: format!("failed to connect to live ftp smoke server: {error}"),
|
||||
source: Some(error.to_string()),
|
||||
context: None,
|
||||
}
|
||||
})?;
|
||||
control_stream
|
||||
.set_read_timeout(Some(Duration::from_secs(5)))
|
||||
.expect("read timeout should set");
|
||||
control_stream
|
||||
.set_write_timeout(Some(Duration::from_secs(5)))
|
||||
.expect("write timeout should set");
|
||||
let mut control_reader =
|
||||
BufReader::new(control_stream.try_clone().expect("clone should work"));
|
||||
|
||||
let _ = Self::expect_code(&mut control_reader, 220)?;
|
||||
Self::write_command(
|
||||
&mut control_stream,
|
||||
&format!(
|
||||
"USER {}\r\n",
|
||||
config.username.as_deref().unwrap_or("anonymous")
|
||||
),
|
||||
)?;
|
||||
let _ = Self::expect_code(&mut control_reader, 331)?;
|
||||
Self::write_command(
|
||||
&mut control_stream,
|
||||
&format!("PASS {}\r\n", config.password.as_deref().unwrap_or("")),
|
||||
)?;
|
||||
let _ = Self::expect_code(&mut control_reader, 230)?;
|
||||
Self::write_command(&mut control_stream, "TYPE I\r\n")?;
|
||||
let _ = Self::expect_code(&mut control_reader, 200)?;
|
||||
Self::write_command(&mut control_stream, "PASV\r\n")?;
|
||||
let pasv = Self::expect_code(&mut control_reader, 227)?;
|
||||
let (data_host, data_port) = Self::parse_pasv_addr(&pasv)?;
|
||||
let mut data_stream =
|
||||
TcpStream::connect((data_host.as_str(), data_port)).map_err(|error| {
|
||||
TransportError {
|
||||
kind: TransportErrorKind::NotConnected,
|
||||
message: format!("failed to connect ftp data socket: {error}"),
|
||||
source: Some(error.to_string()),
|
||||
context: None,
|
||||
}
|
||||
})?;
|
||||
let retr_path = request.path.as_deref().unwrap_or("/file.bin");
|
||||
Self::write_command(&mut control_stream, &format!("RETR {retr_path}\r\n"))?;
|
||||
let _ = Self::expect_code(&mut control_reader, 150)?;
|
||||
let mut payload = Vec::new();
|
||||
data_stream
|
||||
.read_to_end(&mut payload)
|
||||
.map_err(|error| TransportError {
|
||||
kind: TransportErrorKind::Io,
|
||||
message: format!("failed to read ftp data payload: {error}"),
|
||||
source: Some(error.to_string()),
|
||||
context: None,
|
||||
})?;
|
||||
let completion = Self::expect_code(&mut control_reader, 226)?;
|
||||
let _ = Self::write_command(&mut control_stream, "QUIT\r\n");
|
||||
|
||||
Ok(FtpResponseModel {
|
||||
code: 226,
|
||||
message: completion.trim().to_owned(),
|
||||
data: Some(payload),
|
||||
path: request.path.clone(),
|
||||
transferable: true,
|
||||
})
|
||||
}
|
||||
|
||||
fn start_sftp_transfer(
|
||||
&self,
|
||||
_config: &SftpConfigModel,
|
||||
_request: &SftpRequestModel,
|
||||
) -> Result<SftpResponseModel, TransportError> {
|
||||
Err(TransportError {
|
||||
kind: TransportErrorKind::UnsupportedScheme,
|
||||
message: "sftp unused in live ftp smoke".to_owned(),
|
||||
source: None,
|
||||
context: None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Downloader for LiveSftpSmokeDownloader {
|
||||
fn start_http_transfer(
|
||||
&self,
|
||||
_task: &aria2_rust_pro_protocol::HttpTransferTaskModel,
|
||||
) -> Result<HttpResponseModel, TransportError> {
|
||||
Err(TransportError {
|
||||
kind: TransportErrorKind::UnsupportedScheme,
|
||||
message: "http unused in live sftp smoke".to_owned(),
|
||||
source: None,
|
||||
context: None,
|
||||
})
|
||||
}
|
||||
|
||||
fn start_ftp_transfer(
|
||||
&self,
|
||||
_config: &FtpConfigModel,
|
||||
_request: &FtpRequestModel,
|
||||
) -> Result<FtpResponseModel, TransportError> {
|
||||
Err(TransportError {
|
||||
kind: TransportErrorKind::UnsupportedScheme,
|
||||
message: "ftp unused in live sftp smoke".to_owned(),
|
||||
source: None,
|
||||
context: None,
|
||||
})
|
||||
}
|
||||
|
||||
fn start_sftp_transfer(
|
||||
&self,
|
||||
config: &SftpConfigModel,
|
||||
request: &SftpRequestModel,
|
||||
) -> Result<SftpResponseModel, TransportError> {
|
||||
let tcp = TcpStream::connect((config.host.as_str(), config.port)).map_err(|error| {
|
||||
TransportError {
|
||||
kind: TransportErrorKind::NotConnected,
|
||||
message: format!("failed to connect live sftp smoke server: {error}"),
|
||||
source: Some(error.to_string()),
|
||||
context: None,
|
||||
}
|
||||
})?;
|
||||
tcp.set_read_timeout(Some(Duration::from_secs(8))).ok();
|
||||
tcp.set_write_timeout(Some(Duration::from_secs(8))).ok();
|
||||
|
||||
let mut session = ssh2::Session::new().map_err(|error| TransportError {
|
||||
kind: TransportErrorKind::ProtocolViolation,
|
||||
message: format!("failed to build ssh2 session: {error}"),
|
||||
source: Some(error.to_string()),
|
||||
context: None,
|
||||
})?;
|
||||
session.set_tcp_stream(tcp);
|
||||
session.handshake().map_err(|error| TransportError {
|
||||
kind: TransportErrorKind::ProtocolViolation,
|
||||
message: format!("ssh handshake failed: {error}"),
|
||||
source: Some(error.to_string()),
|
||||
context: None,
|
||||
})?;
|
||||
let user = config.username.as_deref().unwrap_or("foo");
|
||||
let pass = config.password.as_deref().unwrap_or("pass");
|
||||
session
|
||||
.userauth_password(user, pass)
|
||||
.map_err(|error| TransportError {
|
||||
kind: TransportErrorKind::ProtocolViolation,
|
||||
message: format!("ssh auth failed: {error}"),
|
||||
source: Some(error.to_string()),
|
||||
context: None,
|
||||
})?;
|
||||
let sftp = session.sftp().map_err(|error| TransportError {
|
||||
kind: TransportErrorKind::ProtocolViolation,
|
||||
message: format!("failed to start sftp subsystem: {error}"),
|
||||
source: Some(error.to_string()),
|
||||
context: None,
|
||||
})?;
|
||||
let path = request.path.as_deref().unwrap_or("/upload/hello.txt");
|
||||
let mut remote_file = sftp.open(path).map_err(|error| TransportError {
|
||||
kind: TransportErrorKind::Io,
|
||||
message: format!("failed to open remote path {path}: {error}"),
|
||||
source: Some(error.to_string()),
|
||||
context: None,
|
||||
})?;
|
||||
let mut payload = Vec::new();
|
||||
remote_file
|
||||
.read_to_end(&mut payload)
|
||||
.map_err(|error| TransportError {
|
||||
kind: TransportErrorKind::Io,
|
||||
message: format!("failed to read remote payload: {error}"),
|
||||
source: Some(error.to_string()),
|
||||
context: None,
|
||||
})?;
|
||||
|
||||
Ok(SftpResponseModel {
|
||||
ok: true,
|
||||
message: "sftp read ok".to_owned(),
|
||||
payload: Some(payload),
|
||||
path: request.path.clone(),
|
||||
transferable: true,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl SequencedHttpDownloader {
|
||||
fn new(responses: Vec<Result<HttpResponseModel, TransportError>>) -> Self {
|
||||
Self {
|
||||
responses: Arc::new(Mutex::new(responses)),
|
||||
requests: Arc::new(Mutex::new(Vec::new())),
|
||||
}
|
||||
}
|
||||
|
||||
fn recorded_requests(&self) -> Vec<aria2_rust_pro_protocol::HttpTransferTaskModel> {
|
||||
self.requests.lock().expect("lock should work").clone()
|
||||
}
|
||||
}
|
||||
|
||||
impl Downloader for SequencedHttpDownloader {
|
||||
fn start_http_transfer(
|
||||
&self,
|
||||
task: &aria2_rust_pro_protocol::HttpTransferTaskModel,
|
||||
) -> Result<HttpResponseModel, TransportError> {
|
||||
self.requests
|
||||
.lock()
|
||||
.expect("lock should work")
|
||||
.push(task.clone());
|
||||
let mut guard = self.responses.lock().expect("lock should work");
|
||||
if guard.is_empty() {
|
||||
return Err(TransportError {
|
||||
kind: TransportErrorKind::Io,
|
||||
message: "no scripted HTTP response remaining".to_owned(),
|
||||
source: None,
|
||||
context: None,
|
||||
});
|
||||
}
|
||||
guard.remove(0)
|
||||
}
|
||||
|
||||
fn start_ftp_transfer(
|
||||
&self,
|
||||
_config: &FtpConfigModel,
|
||||
_request: &FtpRequestModel,
|
||||
) -> Result<FtpResponseModel, TransportError> {
|
||||
Err(TransportError {
|
||||
kind: TransportErrorKind::UnsupportedScheme,
|
||||
message: "unused in test".to_owned(),
|
||||
source: None,
|
||||
context: None,
|
||||
})
|
||||
}
|
||||
|
||||
fn start_sftp_transfer(
|
||||
&self,
|
||||
_config: &SftpConfigModel,
|
||||
_request: &SftpRequestModel,
|
||||
) -> Result<SftpResponseModel, TransportError> {
|
||||
Err(TransportError {
|
||||
kind: TransportErrorKind::UnsupportedScheme,
|
||||
message: "unused in test".to_owned(),
|
||||
source: None,
|
||||
context: None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
struct ConcurrentProbeDownloader {
|
||||
bootstrap: HttpResponseModel,
|
||||
bootstrap_delay: Duration,
|
||||
ranged_responses: Arc<Mutex<VecDeque<(u64, HttpResponseModel)>>>,
|
||||
requests: Arc<Mutex<Vec<aria2_rust_pro_protocol::HttpTransferTaskModel>>>,
|
||||
active_calls: Arc<AtomicUsize>,
|
||||
max_concurrent_calls: Arc<AtomicUsize>,
|
||||
ranged_delay: Duration,
|
||||
}
|
||||
|
||||
impl ConcurrentProbeDownloader {
|
||||
fn new(
|
||||
bootstrap: HttpResponseModel,
|
||||
ranged_responses: Vec<(u64, HttpResponseModel)>,
|
||||
ranged_delay: Duration,
|
||||
) -> Self {
|
||||
Self {
|
||||
bootstrap,
|
||||
bootstrap_delay: Duration::ZERO,
|
||||
ranged_responses: Arc::new(Mutex::new(VecDeque::from(ranged_responses))),
|
||||
requests: Arc::new(Mutex::new(Vec::new())),
|
||||
active_calls: Arc::new(AtomicUsize::new(0)),
|
||||
max_concurrent_calls: Arc::new(AtomicUsize::new(0)),
|
||||
ranged_delay,
|
||||
}
|
||||
}
|
||||
|
||||
fn with_bootstrap_delay(
|
||||
bootstrap: HttpResponseModel,
|
||||
bootstrap_delay: Duration,
|
||||
ranged_responses: Vec<(u64, HttpResponseModel)>,
|
||||
ranged_delay: Duration,
|
||||
) -> Self {
|
||||
Self {
|
||||
bootstrap,
|
||||
bootstrap_delay,
|
||||
ranged_responses: Arc::new(Mutex::new(VecDeque::from(ranged_responses))),
|
||||
requests: Arc::new(Mutex::new(Vec::new())),
|
||||
active_calls: Arc::new(AtomicUsize::new(0)),
|
||||
max_concurrent_calls: Arc::new(AtomicUsize::new(0)),
|
||||
ranged_delay,
|
||||
}
|
||||
}
|
||||
|
||||
fn recorded_requests(&self) -> Vec<aria2_rust_pro_protocol::HttpTransferTaskModel> {
|
||||
self.requests.lock().expect("lock should work").clone()
|
||||
}
|
||||
|
||||
fn max_concurrent_calls(&self) -> usize {
|
||||
self.max_concurrent_calls.load(Ordering::SeqCst)
|
||||
}
|
||||
|
||||
fn note_active_call(&self) {
|
||||
let current = self
|
||||
.active_calls
|
||||
.fetch_add(1, Ordering::SeqCst)
|
||||
.saturating_add(1);
|
||||
let _ =
|
||||
self.max_concurrent_calls
|
||||
.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |seen| {
|
||||
(current > seen).then_some(current)
|
||||
});
|
||||
}
|
||||
|
||||
fn finish_active_call(&self) {
|
||||
self.active_calls.fetch_sub(1, Ordering::SeqCst);
|
||||
}
|
||||
}
|
||||
|
||||
impl Downloader for ConcurrentProbeDownloader {
|
||||
fn start_http_transfer(
|
||||
&self,
|
||||
task: &aria2_rust_pro_protocol::HttpTransferTaskModel,
|
||||
) -> Result<HttpResponseModel, TransportError> {
|
||||
self.requests
|
||||
.lock()
|
||||
.expect("lock should work")
|
||||
.push(task.clone());
|
||||
self.note_active_call();
|
||||
|
||||
let response = task.request.range.as_ref().map_or_else(
|
||||
|| {
|
||||
if !self.bootstrap_delay.is_zero() {
|
||||
thread::sleep(self.bootstrap_delay);
|
||||
}
|
||||
Ok(self.bootstrap.clone())
|
||||
},
|
||||
|range| {
|
||||
thread::sleep(self.ranged_delay);
|
||||
let mut queued = self.ranged_responses.lock().expect("lock should work");
|
||||
let index = queued
|
||||
.iter()
|
||||
.position(|(start, _)| *start == range.start)
|
||||
.expect("matching ranged response should exist");
|
||||
Ok(queued
|
||||
.remove(index)
|
||||
.expect("queued ranged response should exist")
|
||||
.1)
|
||||
},
|
||||
);
|
||||
|
||||
self.finish_active_call();
|
||||
response
|
||||
}
|
||||
|
||||
fn start_ftp_transfer(
|
||||
&self,
|
||||
_config: &FtpConfigModel,
|
||||
_request: &FtpRequestModel,
|
||||
) -> Result<FtpResponseModel, TransportError> {
|
||||
Err(TransportError {
|
||||
kind: TransportErrorKind::UnsupportedScheme,
|
||||
message: "probe downloader does not implement ftp".to_owned(),
|
||||
source: None,
|
||||
context: None,
|
||||
})
|
||||
}
|
||||
|
||||
fn start_sftp_transfer(
|
||||
&self,
|
||||
_config: &SftpConfigModel,
|
||||
_request: &SftpRequestModel,
|
||||
) -> Result<SftpResponseModel, TransportError> {
|
||||
Err(TransportError {
|
||||
kind: TransportErrorKind::UnsupportedScheme,
|
||||
message: "probe downloader does not implement sftp".to_owned(),
|
||||
source: None,
|
||||
context: None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
mod command_surface;
|
||||
mod integration_surface;
|
||||
mod runtime_execution;
|
||||
Reference in New Issue
Block a user