tauri: [bug] writeBinaryFile cant write file with size more, than ~50 mb

Yeah, that would be great. A little context; I am converting files using ffmpeg and I need to save the converted file on the local machine. But, the speed is so slow and the app freezes when if the file is too big, it would be great if there would be a solution using HTTP or anything else. Any help is much appreciated. @Xiaobaishushu25 @DjakaTechnology

i used salvo to enable web services, this is my simple code to transfer file:

#[handler]
async fn upload(req: &mut Request, res: &mut Response) {
    let path = req.form::<String>("path").await.unwrap();
    let file = req.file("file").await;
    let id = generate_unique_id();
    if let Some(file) = file {
        let id = generate_unique_id();
        // let extension = if let Some(file_name) = file.name(){
        //     file_name.split('.').collect::<Vec<_>>().last().unwrap_or(&"xbss")
        // }else {
        //     "xbss"
        // };
        let extension = file
            .name()
            .and_then(|name: &str| {
                name.split('.')
                    .collect::<Vec<_>>()
                    .last()
                    .map(|str| str.to_string())
            })
            .unwrap_or("xbss".to_string());
        // file.name().and_then(|name|{name.split('.').collect::<Vec<_>>().last()}).unwrap_or(&"xbss");
        let path = Path::new(&path).join(format! {"{id}.{extension}"});
        // let dest = format!("F:\\WorkSpace\\Rust\\RustRover\\paper-enhancement\\src-tauri\\target\\debug\\database\\img\\edit/{}", file.name().unwrap_or("file"));
        // let dest = format!("F:\\WorkSpace\\Rust\\RustRover\\paper-enhancement\\src-tauri\\target\\debug\\database\\img\\edit/{}", file.name().unwrap_or("file"));
        // let info = if let Err(e) = fs::copy(&file.path(), Path::new(&dest)) {
        let info = if let Err(e) = fs::copy(&file.path(), &path) {
            res.status_code(StatusCode::INTERNAL_SERVER_ERROR);
            tracing::info!("file upload failure: {}", e);
            format!("file upload failure: {}", e)
        } else {
            tracing::info!("File uploaded to {:?}", path);
            format!("File uploaded to {:?}", path)
        };
        // res.render(Text::Plain(info));
        res.render(Json(ImagePath(path.to_string_lossy().to_string())))
    } else {
        res.status_code(StatusCode::BAD_REQUEST);
        tracing::error!("file not found in request");
        // res.render(Text::Plain("file not found in request"));
        res.render(Json(ImagePath("file not found in request".to_string())))
    };
}

but now i think use tauriv2 is a good idea, more detail can see https://github.com/tauri-apps/tauri/issues/9322

This is a limitations in current IPC, I encountered same problem and talked with the devs on discord. You need to split into smaller batch, and write incrementally.

I ended up doing this:

following reference: https://github.com/tauri-apps/tauri/issues/585

Flow: Convert blob to array buffer -> JS ArrayBuffer -> Split to smaller chunk -> Rust append the buffer to a file string -> Repeat untill all chunk is writren

async function sendArrayBufferToRust(
  path: string,
  arrayBuffer: ArrayBuffer,
  progressCallback?: (progress: number) => void
) {
  const chunkSize = 1024 * 1024 * 10; // 10MB
  const numChunks = Math.ceil(arrayBuffer.byteLength / chunkSize);
  for (let i = 0; i < numChunks; i++) {
    const start = i * chunkSize;
    const end = Math.min(start + chunkSize, arrayBuffer.byteLength);
    const chunk = arrayBuffer.slice(start, end);
    if (!(await runAppendChunkToRust(path, new Uint8Array(chunk)))) {
      console.log("error");
      return false;
    }
    if (progressCallback) {
      const progress = (i + 1) / numChunks;
      progressCallback(progress);
    }
  }
  return true;

#[tauri::command]
fn append_chunk_to_file(path: String, chunk: Vec<u8>) -> Result<(), String> {
    let mut file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(&path)
        .map_err(|e| e.to_string())?;

    file.write_all(&chunk).map_err(|e| e.to_string())?;

    Ok(())
}