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 upload_rejects_local_eof_before_the_observed_file_size() {
    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(None)),
        close_seen: Arc::new(Mutex::new(Some(close_seen_sender))),
        observed_packets: Arc::clone(&observed_packets),
        remote_file_size: 0,
        eof_on_read: false,
        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("shrinking-source.bin");
    tokio::fs::write(&local_path, vec![b'x'; (REMOTE_FILE_SIZE * 2) as usize])
        .await
        .unwrap();
    let callback_path = local_path.clone();
    let options = TransferOptions::default().with_progress_callback(move |transferred, _, _| {
        if transferred >= REMOTE_FILE_SIZE {
            std::fs::OpenOptions::new()
                .write(true)
                .open(&callback_path)
                .and_then(|file| file.set_len(transferred))
                .expect("truncate upload source after its initial size was observed");
        }
    });
    let connection_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(connection_options)
        .await
        .expect("connect to upload fixture");
    let session = SftpSession::open(&mut connection)
        .await
        .expect("initialize upload fixture session");

    let result = SftpTransfer::new(&session)
        .upload(&local_path, "/remote/shrinking-source.bin", &options)
        .await;
    assert!(matches!(
        result,
        Err(TransferError::LocalIo { source, .. })
            if source.kind() == std::io::ErrorKind::UnexpectedEof
    ));
    timeout(Duration::from_secs(5), close_seen_receiver)
        .await
        .expect("SFTP client did not close the handle after local EOF")
        .expect("CLOSE signal was dropped");

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

#[tokio::test]
async fn upload_resumes_without_truncating_the_existing_remote_prefix() {
    let observed_packets = Arc::new(Mutex::new(Vec::new()));
    let mut server = TestSshServer {
        read_started: Arc::new(Mutex::new(None)),
        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: 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("upload.bin");
    tokio::fs::write(&local_path, vec![b'x'; REMOTE_FILE_SIZE as usize + 3])
        .await
        .unwrap();
    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 upload fixture");
    let session = SftpSession::open(&mut connection)
        .await
        .expect("initialize upload fixture session");
    let progress = SftpTransfer::new(&session)
        .upload(
            &local_path,
            "/remote/upload.bin",
            &TransferOptions::default(),
        )
        .await
        .expect("resume upload without truncating the remote prefix");

    assert_eq!(progress.bytes_transferred, REMOTE_FILE_SIZE + 3);
    let packets = observed_packets.lock().await;
    let open_flags = packets.iter().find_map(|packet| match packet {
        SftpPacket::Open { flags, .. } => Some(*flags),
        _ => None,
    });
    assert!(
        open_flags.is_some_and(|flags| flags & SSH_FXF_TRUNC == 0),
        "resumed upload must not request remote truncation: {packets:?}"
    );
    let write_offsets = packets
        .iter()
        .filter_map(|packet| match packet {
            SftpPacket::Write { offset, .. } => Some(*offset),
            _ => None,
        })
        .collect::<Vec<_>>();
    assert_eq!(write_offsets, vec![REMOTE_FILE_SIZE]);
    drop(packets);

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

#[tokio::test]
async fn upload_reports_remote_close_failure() {
    let directory = tempfile::tempdir().unwrap();
    let local_path = directory.path().join("upload-close-failure.bin");
    tokio::fs::write(&local_path, b"upload payload")
        .await
        .unwrap();
    let (connection, session, _, server_task) = connect_test_sftp_server(0, SSH_FX_FAILURE).await;

    let result = SftpTransfer::new(&session)
        .upload(
            &local_path,
            "/remote/upload.bin",
            &TransferOptions::default(),
        )
        .await;
    assert!(matches!(
        result,
        Err(TransferError::RemoteOperation { operation, .. })
            if operation == "close after upload"
    ));

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

#[tokio::test]
async fn upload_restarts_when_remote_file_is_larger_than_source() {
    let directory = tempfile::tempdir().unwrap();
    let local_path = directory.path().join("short-source.bin");
    tokio::fs::write(&local_path, b"short source")
        .await
        .unwrap();
    let (connection, session, observed_packets, server_task) =
        connect_test_sftp_server(100, SSH_FX_OK).await;

    SftpTransfer::new(&session)
        .upload(
            &local_path,
            "/remote/longer.bin",
            &TransferOptions::default(),
        )
        .await
        .expect("oversized remote file should be replaced from offset zero");

    let packets = observed_packets.lock().await;
    let open_flags = packets.iter().find_map(|packet| match packet {
        SftpPacket::Open { flags, .. } => Some(*flags),
        _ => None,
    });
    assert!(open_flags.is_some_and(|flags| flags & SSH_FXF_TRUNC != 0));
    let write_offsets = packets
        .iter()
        .filter_map(|packet| match packet {
            SftpPacket::Write { offset, .. } => Some(*offset),
            _ => None,
        })
        .collect::<Vec<_>>();
    assert_eq!(write_offsets, vec![0]);
    drop(packets);

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

#[tokio::test]
async fn upload_rejects_resume_offset_beyond_local_file() {
    let directory = tempfile::tempdir().unwrap();
    let local_path = directory.path().join("short-source.bin");
    tokio::fs::write(&local_path, b"short source")
        .await
        .unwrap();
    let (connection, session, observed_packets, server_task) =
        connect_test_sftp_server(0, SSH_FX_OK).await;

    let result = SftpTransfer::new(&session)
        .upload(
            &local_path,
            "/remote/resume.bin",
            &TransferOptions::default().with_resume(100),
        )
        .await;
    assert!(matches!(
        result,
        Err(TransferError::LocalIo { source, .. })
            if source.kind() == std::io::ErrorKind::InvalidInput
    ));
    assert!(observed_packets.lock().await.is_empty());

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