how to control file system files

[ktjd123]

Hi,
I'm new to rust and actix-web.

I made a simple api to watermark image.

Api gets image, watermark it and send it back.

The problem is when if request is aborted, the file I temporally saved doesn't get removed.

I tried everything to cleanup but failed.

the code is

#[post("/encode/")]
pub async fn encode(mut payload: Multipart) -> Result<HttpResponse, Error> {
    let mut secret_text: Option<String> = None;
    let mut file_path: Option<String> = None;
    while let Ok(Some(mut field)) = payload.try_next().await {
        let field_filename = field.content_disposition().get_name();

        if Some("file") == field_filename {
            let filename = format!("{}.jpg", Uuid::new_v4());

            let i_file_path = format!("./tmp/{filename}");

            let path_for_file = i_file_path.clone();
            let mut f = match web::block(move || std::fs::File::create(path_for_file))
                .await
                .expect("file creation failed")
            {
                Ok(o) => o,
                Err(e) => panic!("{:?}", e),
            };

            file_path = Some(i_file_path);

            while let Some(chunk) = match field.try_next().await {
                Ok(o) => o,
                Err(_) => {
                    println!("getting chunks fail");
                    let file_path_clone = file_path
                        .clone()
                        .expect("no file path, file path clone failed");
                    web::block(move || {
                        let path = match file_path {
                            Some(o) => o,
                            None => panic!("file path getting failed"),
                        };
                        let path = std::path::Path::new(&path);

                        while std::path::Path::exists(path) {
                            std::fs::remove_file(&file_path_clone).expect("file remove failed");
                        }
                    })
                    .await
                    .expect("file remove failed at chunk getting part");
                    return Ok(HttpResponse::Ok().json(Response {
                        code: 1001,
                        msg: "File receiving failed".to_string(),
                    }));
                }
            } {
                f = web::block(move || f.write_all(&chunk).map(|_| f))
                    .await
                    .expect("writing chunk to file failed")
                    .expect("writing chunk to file failed");
            }
        } else if Some("text") == field_filename {
            let mut string_bytes: Vec<u8> = Vec::new();
            while let Some(chunk) = field.try_next().await.expect("reading secret text failed") {
                string_bytes.append(&mut chunk.to_vec());
            }
            secret_text = match String::from_utf8(string_bytes) {
                Ok(o) => Some(o),
                Err(_) => {
                    println!("secret text getting failed at utf8 section");
                    return Ok(HttpResponse::Ok().json(Response {
                        code: 1002,
                        msg: "Secret text parsing fail".to_string(),
                    }));
                }
            }
        }
    }

    let file_path = match file_path {
        Some(o) => o,
        None => {
            println!("file path getting failed");
            return Ok(HttpResponse::Ok().json(Response {
                code: 1003,
                msg: "No file".to_string(),
            }));
        }
    };

    let secret_text = match secret_text {
        Some(o) => o,
        None => {
            println!("secret text getting failed");
            match web::block(move || std::fs::remove_file(&file_path))
                .await
                .expect("removing file failed at no secret text")
            {
                Ok(o) => o,
                Err(e) => panic!("{}", e),
            };
            return Ok(HttpResponse::Ok().json(Response {
                code: 1004,
                msg: "no secret text".to_string(),
            }));
        }
    };

    // Encode watermark
    let watermark = Watermark::from_path(&file_path).await;
    let encoded_path = format!("./tmp/{}_encode.jpg", Uuid::new_v4());
    match watermark
        .transform_image_with_text(&secret_text, 1.1, &encoded_path)
        .await
    {
        Err(e) => {
            println!("encoding watermark failed");
            match std::fs::remove_file(file_path) {
                Err(e) => println!("File remove failed {:?}", e),
                _ => {}
            }
            match std::fs::remove_file(encoded_path) {
                Err(e) => println!("File remove failed {:?}", e),
                _ => {}
            }
            return Ok(HttpResponse::Ok().json(Response {
                code: 1005,
                msg: format!("{:?}", e),
            }));
        }
        _ => {}
    };

    let encoded_path_clone = encoded_path.clone();
    let encoded_file = match web::block(|| std::fs::read(encoded_path_clone))
        .await
        .expect("reading encoded file failed")
    {
        Ok(o) => o,
        Err(e) => {
            match std::fs::remove_file(file_path) {
                Err(e) => println!("File remove failed {:?}", e),
                _ => {}
            }
            match std::fs::remove_file(encoded_path) {
                Err(e) => println!("File remove failed {:?}", e),
                _ => {}
            }
            panic!("{}", e)
        }
    };
    web::block(|| {
        match std::fs::remove_file(file_path) {
            Err(e) => println!("File remove failed {:?}", e),
            _ => {}
        }
        match std::fs::remove_file(encoded_path) {
            Err(e) => println!("File remove failed {:?}", e),
            _ => {}
        }
    })
    .await
    .expect("removing file at end failed");

    Ok(HttpResponse::Ok().body(encoded_file))
}

the problem happens at while let Some(chunk) = match field.try_next().await {

and not gets cleaned up at println!("getting chunks fail"); section.

I tried these methods.

1. change filename before and after the write_all loop to figure out where the problem comes from and it when field.try_next() fails.
2. Then I added code to remove file at Err section
3. I wondered if when write_all function writes to where file doesn't exist it make one. => was false.
4. I added loop to detect path existence and remove it until it's gone but didn't work as well. => Was not sure if fs::remove_file will give error when remove failed due to file lock? => doesn't seem to give Err but not sure.
5. Checked everywhere else to find if problem is coming from somewhere but it's not.

I set timeout to 0 so it's not related to timeout. => Curious what happens how actix-web behaves when timeout is reached.

The server is giving 200 status code so I think there is no interrupted.

I found this error while stress testing the server for checking real use capacity. (CPU at 100%) => Doesn't seem to be the problem.

Thank you.

[ktjd123]

Sorry for confusing code, not familiar with rust, actix yet 😭