aria2-protocol 0.3.10

Multi-protocol networking stack for aria2-rust: HTTP/HTTPS client, FTP/SFTP, full BitTorrent (DHT/PEX/MSE), and Metalink V3/V4 parser
Documentation
use super::*;

#[tokio::test]
async fn cancellation_closes_an_active_sftp_download() {
    let (read_started_sender, read_started_receiver) = oneshot::channel();
    let (close_seen_sender, close_seen_receiver) = oneshot::channel();
    let read_started = Arc::new(Mutex::new(Some(read_started_sender)));
    let close_seen = Arc::new(Mutex::new(Some(close_seen_sender)));
    let observed_packets = Arc::new(Mutex::new(Vec::new()));

    let listener = TcpListener::bind(("127.0.0.1", 0)).await.unwrap();
    let port = listener.local_addr().unwrap().port();
    let mut server = TestSshServer {
        read_started: Arc::clone(&read_started),
        close_seen: Arc::clone(&close_seen),
        observed_packets: Arc::clone(&observed_packets),
        remote_file_size: REMOTE_FILE_SIZE,
        eof_on_read: false,
        stall_on_stat: false,
        close_status_code: SSH_FX_OK,
    };
    let mut rng = TestRng;
    let mut config = server::Config::default();
    config.keys.push(
        russh::keys::PrivateKey::random(&mut rng, russh::keys::ssh_key::Algorithm::Ed25519)
            .unwrap(),
    );
    config.auth_rejection_time_initial = Some(Duration::from_millis(1));
    let config = Arc::new(config);

    let server_task = tokio::spawn(async move {
        let (socket, peer_addr) = listener.accept().await.unwrap();
        let handler = server.new_client(Some(peer_addr));
        let running = server::run_stream(config, socket, handler).await.unwrap();
        let _ = running.await;
    });

    let cancellation = CancellationToken::new();
    let client_cancellation = cancellation.clone();
    let local_path = std::path::PathBuf::from("target")
        .join(format!("sftp-cancellation-{}.bin", std::process::id()));
    tokio::fs::create_dir_all("target")
        .await
        .expect("failed to create the Cargo test output directory");
    let options = SshOptions::new("127.0.0.1", "test-user")
        .with_port(port)
        .with_password("test-password")
        .with_host_key_mode(HostKeyCheckingMode::Disable)
        .with_timeouts(Duration::from_secs(5), Duration::from_secs(5));

    let client_local_path = local_path.clone();
    let client_task = tokio::spawn(async move {
        let mut connection = SshConnection::connect(options)
            .await
            .expect("failed to connect to in-process SFTP server");
        let session = SftpSession::open(&mut connection)
            .await
            .expect("failed to initialize the in-process SFTP session");
        SftpTransfer::new(&session)
            .download_with_cancellation(
                "/remote/cancellation.bin",
                &client_local_path,
                &TransferOptions::default(),
                &client_cancellation,
            )
            .await
    });

    timeout(Duration::from_secs(5), read_started_receiver)
        .await
        .expect("SFTP server did not reach the active READ")
        .expect("SFTP server readiness signal was dropped");
    cancellation.cancel();

    let result = timeout(Duration::from_secs(5), client_task)
        .await
        .expect("cancellable SFTP download did not finish")
        .expect("cancellable SFTP client task panicked");
    assert!(matches!(result, Err(TransferError::Cancelled)));

    timeout(Duration::from_secs(5), close_seen_receiver)
        .await
        .expect("SFTP client did not close the remote handle")
        .expect("SFTP close signal was dropped");

    let _ = tokio::fs::remove_file(&local_path).await;
    server_task.abort();
    let _ = server_task.await;
}

#[tokio::test]
async fn cancelled_in_flight_request_poison_session_before_next_exchange() {
    let (request_started_sender, request_started_receiver) = oneshot::channel();
    let observed_packets = Arc::new(Mutex::new(Vec::new()));
    let mut server = TestSshServer {
        read_started: Arc::new(Mutex::new(Some(request_started_sender))),
        close_seen: Arc::new(Mutex::new(None)),
        observed_packets: Arc::clone(&observed_packets),
        remote_file_size: REMOTE_FILE_SIZE,
        eof_on_read: false,
        stall_on_stat: true,
        close_status_code: SSH_FX_OK,
    };
    let listener = TcpListener::bind(("127.0.0.1", 0)).await.unwrap();
    let port = listener.local_addr().unwrap().port();
    let mut rng = TestRng;
    let mut config = server::Config::default();
    config.keys.push(
        russh::keys::PrivateKey::random(&mut rng, russh::keys::ssh_key::Algorithm::Ed25519)
            .unwrap(),
    );
    config.auth_rejection_time_initial = Some(Duration::from_millis(1));
    let config = Arc::new(config);
    let server_task = tokio::spawn(async move {
        let (socket, peer_addr) = listener.accept().await.unwrap();
        let handler = server.new_client(Some(peer_addr));
        let running = server::run_stream(config, socket, handler).await.unwrap();
        let _ = running.await;
    });

    let options = SshOptions::new("127.0.0.1", "test-user")
        .with_port(port)
        .with_password("test-password")
        .with_host_key_mode(HostKeyCheckingMode::Disable)
        .with_timeouts(Duration::from_secs(5), Duration::from_secs(5));
    let mut connection = SshConnection::connect(options)
        .await
        .expect("connect to stalled SFTP request fixture");
    let session = SftpSession::open(&mut connection)
        .await
        .expect("initialize stalled SFTP request fixture");
    let request_session = session.clone();
    let request = tokio::spawn(async move {
        crate::sftp::file_ops::SftpFileOps::new(&request_session)
            .stat("/stalled")
            .await
    });

    timeout(Duration::from_secs(5), request_started_receiver)
        .await
        .expect("server did not receive the SFTP request")
        .expect("server request signal was dropped");
    request.abort();
    assert!(request.await.unwrap_err().is_cancelled());

    let second_result = crate::sftp::file_ops::SftpFileOps::new(&session)
        .stat("/must-not-be-sent")
        .await;
    assert!(matches!(
        second_result,
        Err(crate::sftp::file_ops::FileOpError::Session {
            source: SftpSessionError::SessionPoisoned,
            ..
        })
    ));
    assert_eq!(
        observed_packets.lock().await.as_slice(),
        &[SftpPacket::Stat {
            request_id: 1,
            path: "/stalled".into(),
        }]
    );

    connection
        .disconnect()
        .await
        .expect("disconnect poisoned SFTP connection");
    server_task.abort();
    let _ = server_task.await;
}

#[tokio::test]
async fn download_rejects_eof_before_the_remote_file_size() {
    let (read_started_sender, read_started_receiver) = oneshot::channel();
    let (close_seen_sender, close_seen_receiver) = oneshot::channel();
    let observed_packets = Arc::new(Mutex::new(Vec::new()));
    let mut server = TestSshServer {
        read_started: Arc::new(Mutex::new(Some(read_started_sender))),
        close_seen: Arc::new(Mutex::new(Some(close_seen_sender))),
        observed_packets: Arc::clone(&observed_packets),
        remote_file_size: REMOTE_FILE_SIZE,
        eof_on_read: true,
        stall_on_stat: false,
        close_status_code: SSH_FX_OK,
    };
    let listener = TcpListener::bind(("127.0.0.1", 0)).await.unwrap();
    let port = listener.local_addr().unwrap().port();
    let mut rng = TestRng;
    let mut config = server::Config::default();
    config.keys.push(
        russh::keys::PrivateKey::random(&mut rng, russh::keys::ssh_key::Algorithm::Ed25519)
            .unwrap(),
    );
    config.auth_rejection_time_initial = Some(Duration::from_millis(1));
    let config = Arc::new(config);
    let server_task = tokio::spawn(async move {
        let (socket, peer_addr) = listener.accept().await.unwrap();
        let handler = server.new_client(Some(peer_addr));
        let running = server::run_stream(config, socket, handler).await.unwrap();
        let _ = running.await;
    });

    let directory = tempfile::tempdir().unwrap();
    let local_path = directory.path().join("early-eof.bin");
    let options = SshOptions::new("127.0.0.1", "test-user")
        .with_port(port)
        .with_password("test-password")
        .with_host_key_mode(HostKeyCheckingMode::Disable)
        .with_timeouts(Duration::from_secs(5), Duration::from_secs(5));
    let mut connection = SshConnection::connect(options)
        .await
        .expect("connect to EOF fixture");
    let session = SftpSession::open(&mut connection)
        .await
        .expect("initialize EOF fixture session");

    let result = SftpTransfer::new(&session)
        .download(
            "/remote/early-eof.bin",
            &local_path,
            &TransferOptions::default(),
        )
        .await;
    assert!(matches!(
        result,
        Err(TransferError::RemoteOperation {
            source: crate::sftp::file_ops::FileOpError::Other { message },
            ..
        }) if message.contains("unexpected EOF")
    ));
    timeout(Duration::from_secs(5), read_started_receiver)
        .await
        .expect("SFTP server did not receive READ")
        .expect("READ signal was dropped");
    timeout(Duration::from_secs(5), close_seen_receiver)
        .await
        .expect("SFTP client did not close the handle after early EOF")
        .expect("CLOSE signal was dropped");

    server_task.abort();
    let _ = server_task.await;
}

#[tokio::test]
async fn download_keeps_complete_payload_when_remote_close_fails() {
    let directory = tempfile::tempdir().unwrap();
    let local_path = directory.path().join("complete-download.bin");
    let payload = b"partial-data";
    let (connection, session, _, server_task) =
        connect_test_sftp_server(payload.len() as u64, SSH_FX_FAILURE).await;

    SftpTransfer::new(&session)
        .download(
            "/remote/complete.bin",
            &local_path,
            &TransferOptions::default(),
        )
        .await
        .expect("remote handle cleanup failure must not discard complete download");
    assert_eq!(tokio::fs::read(&local_path).await.unwrap(), payload);

    drop(session);
    let _ = connection.disconnect().await;
    server_task.abort();
    let _ = server_task.await;
}