Struct UploadClient 

pub struct UploadClient { /* private fields */ }

Upload client for Baidu NetDisk

Implementations

impl UploadClient

pub fn new(http_client: HttpClient, token_getter: Arc<dyn TokenGetter>) -> Self

Create a new UploadClient instance

Usually you don’t need to call this directly - use BaiduNetDiskClient::upload() instead.

pub fn http_client(&self) -> &HttpClient

Get a reference to the internal HTTP client

pub async fn precreate( &self, options: PrecreateOptions, ) -> NetDiskResult<PrecreateResponse>

Precreate an upload session

Initiates an upload session and checks which chunks (if any) already exist on the server. This is the first step of the multi-step upload process.

Examples found in repository

examples/upload_precreate.rs (line 82)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    if args.len() < 3 {
        println!("Usage: {} <local_file> <remote_path>", args[0]);
        println!("Example: {} test.txt /apps/test/test.txt", args[0]);
        return Ok(());
    }

    let local_file = &args[1];
    let remote_path = &args[2];

    println!("=== Baidu NetDisk Preupload Test ===");
    println!("Local file: {}", local_file);
    println!("Remote path: {}", remote_path);
    println!();

    let (file_size, block_list) = get_file_md5blocks(local_file, 4 * 1024 * 1024)?;
    let file_md5 = calculate_md5(local_file)?;

    println!("File size: {} bytes", file_size);
    println!("File MD5: {}", file_md5);
    println!("Block count: {}", block_list.len());
    println!("Block list: {:?}", block_list);
    println!();

    let options = PrecreateOptions::new(remote_path, file_size, block_list)
        .content_md5(&file_md5)
        .rtype(1);

    println!("Sending precreate request...");
    match client.upload().precreate(options).await {
        Ok(response) => {
            println!("Precreate success!");
            println!("  Upload ID: {}", response.uploadid);
            println!("  Path: {:?}", response.path);
            println!("  Return type: {}", response.return_type);
            println!("  Block list to upload: {:?}", response.block_list);
        }
        Err(e) => {
            println!("Precreate failed: {}", e);
        }
    }

    Ok(())
}

impl UploadClient

pub async fn locate_upload( &self, path: &str, uploadid: &str, ) -> NetDiskResult<LocateUploadResponse>

Locate upload domain

Gets the upload domain before uploading chunks. This is required before uploading file data.

According to Baidu NetDisk API documentation, the servers are sorted by proximity and speed. The first server is recommended as the default choice for optimal upload performance.

Example

use baidu_netdisk_sdk::BaiduNetDiskClient;

let client = BaiduNetDiskClient::builder().build()?;
client.load_token_from_env()?;

let response = client.upload()
    .locate_upload("/apps/appName/filename.jpg", "P1-MTAuMjI4LjQzLjMxOjE1OTU4NTg==")
    .await?;

// Get the first HTTPS server (recommended by Baidu for optimal performance)
if let Some(server) = response.get_first_https_server() {
    println!("Upload server: {}", server);
}

pub async fn upload_chunk( &self, options: UploadChunkOptions, server_url: Option<&str>, ) -> NetDiskResult<UploadChunkResponse>

Upload a single chunk

If server_url is not provided, the default server https://c3.pcs.baidu.com will be used.

pub async fn upload_chunks_parallel( &self, remote_path: &str, uploadid: &str, chunks: Vec<(u32, Vec<u8>)>, max_concurrency: usize, server_url: Option<&str>, ) -> NetDiskResult<Vec<(u32, String)>>

Upload multiple chunks in parallel

If server_url is not provided, the default server https://c3.pcs.baidu.com will be used.

pub async fn create_file( &self, options: CreateFileOptions, ) -> NetDiskResult<CreateFileResponse>

Create the final file on the server

This is the final step of the upload process, which merges all uploaded chunks into a single file.

impl UploadClient

pub async fn upload_file<P: AsRef<Path>>( &self, local_path: P, remote_path: &str, ) -> NetDiskResult<CreateFileResponse>

Upload a file from local path (simple API)

This is the simplest way to upload a file. It handles everything automatically:

• Opens and reads the file
• Calculates MD5 for each chunk
• Uploads missing chunks in parallel
• Creates the final file on the server

Example

use baidu_netdisk_sdk::BaiduNetDiskClient;

let client = BaiduNetDiskClient::builder().build()?;
client.load_token_from_env()?;

let response = client.upload()
    .upload_file("test.txt", "/remote/test.txt")
    .await?;

println!("Uploaded: {} ({} bytes)", response.path, response.size);

See Also

• UploadClient::upload_file_with_options for custom chunk size and concurrency
• UploadClient::upload_reader for streaming upload with custom readers
• UploadClient::upload_bytes for uploading data already in memory

Examples found in repository

examples/upload_file.rs (line 32)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    if args.len() < 3 {
        println!("Usage: {} <local_file> <remote_path>", args[0]);
        println!("Example: {} test.txt /apps/test/test.txt", args[0]);
        return Ok(());
    }

    let local_file = &args[1];
    let remote_path = &args[2];

    println!("=== Baidu NetDisk File Upload (Simple) ===");
    println!("Local file: {}", local_file);
    println!("Remote path: {}", remote_path);
    println!();

    let start_time = std::time::Instant::now();

    let response = client.upload().upload_file(local_file, remote_path).await?;

    println!("File uploaded successfully!");
    println!("  FS ID: {}", response.fs_id);
    println!("  Server filename: {:?}", response.server_filename);
    println!("  Path: {}", response.path);
    println!("  Size: {} bytes", response.size);
    println!("  Category: {}", response.category);
    println!("  MD5: {}", response.md5.unwrap_or_default());
    println!("  Upload time: {:?}", start_time.elapsed());

    Ok(())
}

pub async fn upload_file_with_options<P: AsRef<Path>>( &self, local_path: P, remote_path: &str, options: SimpleUploadOptions, ) -> NetDiskResult<CreateFileResponse>

Upload a file from local path with custom options

Use this method to customize upload behavior:

• chunk_size: Size of each chunk (default: 4MB)
• max_concurrency: Maximum parallel uploads (default: 10)
• r#type: File type hint (default: 1)

Example

use baidu_netdisk_sdk::{BaiduNetDiskClient, upload::SimpleUploadOptions};

let client = BaiduNetDiskClient::builder().build()?;
client.load_token_from_env()?;

let options = SimpleUploadOptions::default()
    .chunk_size(8 * 1024 * 1024)  // 8MB chunks
    .max_concurrency(20);         // 20 parallel uploads

let response = client.upload()
    .upload_file_with_options("large_video.mp4", "/remote/video.mp4", options)
    .await?;

println!("Uploaded: {}", response.path);

Examples found in repository

examples/upload_file_options.rs (line 56)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    if args.len() < 3 {
        println!(
            "Usage: {} <local_file> <remote_path> [chunk_size] [concurrency]",
            args[0]
        );
        println!("Example: {} test.mp4 /upload/video.mp4 8388608 20", args[0]);
        println!("  - chunk_size: bytes per chunk (default: 4194304 = 4MB)");
        println!("  - concurrency: parallel uploads (default: 10)");
        return Ok(());
    }

    let local_file = &args[1];
    let remote_path = &args[2];

    let chunk_size: usize = args
        .get(3)
        .and_then(|s| s.parse().ok())
        .unwrap_or(4 * 1024 * 1024);
    let concurrency: usize = args.get(4).and_then(|s| s.parse().ok()).unwrap_or(10);

    let options = SimpleUploadOptions::default()
        .chunk_size(chunk_size)
        .max_concurrency(concurrency);

    println!("=== Baidu NetDisk File Upload (Custom Options) ===");
    println!("Local file: {}", local_file);
    println!("Remote path: {}", remote_path);
    println!(
        "Chunk size: {} bytes ({:.2} MB)",
        chunk_size,
        chunk_size as f64 / 1024.0 / 1024.0
    );
    println!("Concurrency: {}", concurrency);
    println!();

    let start_time = std::time::Instant::now();

    let response = client
        .upload()
        .upload_file_with_options(local_file, remote_path, options)
        .await?;

    println!("File uploaded successfully!");
    println!("  FS ID: {}", response.fs_id);
    println!("  Path: {}", response.path);
    println!("  Size: {} bytes", response.size);
    println!("  Category: {}", response.category);
    println!("  MD5: {}", response.md5.unwrap_or_default());
    println!("  Upload time: {:?}", start_time.elapsed());

    Ok(())
}

pub async fn upload_reader<R: Read + Seek>( &self, reader: &mut R, file_size: u64, remote_path: &str, ) -> NetDiskResult<CreateFileResponse>

Upload from a Reader with seek support (streaming API)

This is a lower-level API that accepts any Read + Seek reader. Useful for:

• Custom file wrapping (e.g., encrypted files)
• Upload from memory-mapped files
• Testing with custom readers

Example

use baidu_netdisk_sdk::BaiduNetDiskClient;
use std::io::BufReader;

let client = BaiduNetDiskClient::builder().build()?;
client.load_token_from_env()?;

let file = std::fs::File::open("test.txt")?;
let metadata = file.metadata()?;
let file_size = metadata.len();

let reader = BufReader::new(file);
let mut reader = reader;  // mutable for rewind

let response = client.upload()
    .upload_reader(&mut reader, file_size, "/remote/test.txt")
    .await?;

println!("Uploaded: {}", response.path);

Memory Usage

Memory is bounded by batch size (max_concurrency * 2 * chunk_size), approximately 80MB by default, regardless of file size.

Examples found in repository

examples/upload_reader.rs (line 48)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    let local_file = if args.len() >= 2 {
        &args[1]
    } else {
        println!("Usage: {} <local_file> [remote_path]", args[0]);
        println!("Example: {} test.txt /upload/test.txt", args[0]);
        return Ok(());
    };

    let remote_path = if args.len() >= 3 {
        &args[2]
    } else {
        "/upload/test_reader.txt"
    };

    println!("=== Baidu NetDisk Reader Upload ===");
    println!("Local file: {}", local_file);
    println!("Remote path: {}", remote_path);
    println!();

    let file = std::fs::File::open(local_file)?;
    let metadata = file.metadata()?;
    let file_size = metadata.len();

    println!("File size: {} bytes", file_size);

    let mut reader = BufReader::new(file);

    let start_time = std::time::Instant::now();

    let response = client
        .upload()
        .upload_reader(&mut reader, file_size, remote_path)
        .await?;

    println!("File uploaded successfully!");
    println!("  FS ID: {}", response.fs_id);
    println!("  Server filename: {:?}", response.server_filename);
    println!("  Path: {}", response.path);
    println!("  Size: {} bytes", response.size);
    println!("  Category: {}", response.category);
    println!("  MD5: {}", response.md5.unwrap_or_default());
    println!("  Upload time: {:?}", start_time.elapsed());

    Ok(())
}

pub async fn upload_reader_with_options<R: Read + Seek>( &self, reader: &mut R, file_size: u64, remote_path: &str, options: SimpleUploadOptions, ) -> NetDiskResult<CreateFileResponse>

Upload from a Reader with custom options

Example

use baidu_netdisk_sdk::{BaiduNetDiskClient, upload::SimpleUploadOptions};

let client = BaiduNetDiskClient::builder().build()?;
client.load_token_from_env()?;

let options = SimpleUploadOptions::default()
    .chunk_size(8 * 1024 * 1024)
    .max_concurrency(20);

let file = std::fs::File::open("test.txt")?;
let metadata = file.metadata()?;
let file_size = metadata.len();

let mut reader = std::io::BufReader::new(file);
let response = client.upload()
    .upload_reader_with_options(&mut reader, file_size, "/remote/test.txt", options)
    .await?;

println!("Uploaded: {}", response.path);

pub async fn upload_bytes( &self, data: &[u8], remote_path: &str, ) -> NetDiskResult<CreateFileResponse>

Upload bytes from memory (simple API)

Use this method when you already have the data in memory. For large data, consider using UploadClient::upload_file or UploadClient::upload_reader instead to avoid loading the entire data into memory.

Example

use baidu_netdisk_sdk::BaiduNetDiskClient;

let client = BaiduNetDiskClient::builder().build()?;
client.load_token_from_env()?;

let data = b"Hello, World!";
let response = client.upload()
    .upload_bytes(data, "/remote/hello.txt")
    .await?;

println!("Uploaded: {}", response.path);

Memory Note

The entire data slice will be held in memory during upload. For large files, use UploadClient::upload_file which streams from disk.

Examples found in repository

examples/upload_bytes.rs (line 31)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    let remote_path = if args.len() >= 2 {
        &args[1]
    } else {
        "/upload/hello_bytes.txt"
    };

    println!("=== Baidu NetDisk Bytes Upload (Simple) ===");
    println!("Remote path: {}", remote_path);
    println!();

    let test_data = b"Hello from upload_bytes! This is a simple byte array upload test.";
    println!("Uploading {} bytes of data...", test_data.len());

    let start_time = std::time::Instant::now();

    let response = client.upload().upload_bytes(test_data, remote_path).await?;

    println!("Bytes uploaded successfully!");
    println!("  FS ID: {}", response.fs_id);
    println!("  Server filename: {:?}", response.server_filename);
    println!("  Path: {}", response.path);
    println!("  Size: {} bytes", response.size);
    println!("  Category: {}", response.category);
    println!("  MD5: {}", response.md5.unwrap_or_default());
    println!("  Upload time: {:?}", start_time.elapsed());

    Ok(())
}

pub async fn upload_bytes_with_options( &self, data: &[u8], remote_path: &str, options: SimpleUploadOptions, ) -> NetDiskResult<CreateFileResponse>

Upload bytes from memory with custom options

Example

use baidu_netdisk_sdk::{BaiduNetDiskClient, upload::SimpleUploadOptions};

let client = BaiduNetDiskClient::builder().build()?;
client.load_token_from_env()?;

let options = SimpleUploadOptions::default()
    .chunk_size(8 * 1024 * 1024)
    .max_concurrency(20);

let data = b"Hello, World!";
let response = client.upload()
    .upload_bytes_with_options(data, "/remote/hello.txt", options)
    .await?;

println!("Uploaded: {}", response.path);

Trait Implementations

impl Clone for UploadClient

fn clone(&self) -> UploadClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for UploadClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.