filerune_fusion 0.2.0

A file splitting & merging solution
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use std::path::{Path, PathBuf};

use tokio::{
    fs,
    io::{self, AsyncReadExt as _, AsyncWriteExt as _},
};

use crate::split::{Split, SplitError, SplitResult};

/// Trait for running the split process.
pub trait SplitAsyncExt {
    /// Run the split process asynchronously.
    fn run_async(
        &self
    ) -> impl std::future::Future<Output = Result<SplitResult, SplitError>> + Send;
}

impl SplitAsyncExt for Split {
    async fn run_async(&self) -> Result<SplitResult, SplitError> {
        let in_file: &Path = match self.in_file {
            | Some(ref p) => {
                let p: &Path = p.as_ref();

                // if in_file not exists
                if !p.exists() {
                    return Err(SplitError::InFileNotFound);
                }

                // if in_file not a file
                if !p.is_file() {
                    return Err(SplitError::InFileNotFile);
                }

                p
            },
            | None => return Err(SplitError::InFileNotSet),
        };

        let out_dir: &Path = match self.out_dir {
            | Some(ref p) => {
                let p: &Path = p.as_ref();

                if !p.exists() {
                    // if out_dir not exists
                    fs::create_dir_all(p)
                        .await
                        .map_err(|_| SplitError::OutDirNotCreated)?
                } else if p.is_file() {
                    // if out_dir not a directory
                    return Err(SplitError::OutDirNotDir);
                }

                p
            },
            | None => return Err(SplitError::OutDirNotSet),
        };

        let chunk_size: usize = self.chunk_size;

        let buffer_capacity: usize = self.buffer_capacity;

        let input_file: fs::File = fs::OpenOptions::new()
            .read(true)
            .open(in_file)
            .await
            .map_err(|_| SplitError::InFileNotOpened)?;

        let file_size: usize = input_file
            .metadata()
            .await
            .map_err(|_| SplitError::InFileNotRead)?
            .len() as usize;

        let mut reader: io::BufReader<fs::File> =
            io::BufReader::with_capacity(buffer_capacity, input_file);

        let mut buffer: Vec<u8> = vec![0; chunk_size];

        let mut total_chunks: usize = 0;

        loop {
            let mut offset: usize = 0;

            while offset < chunk_size {
                match reader.read(&mut buffer[offset..]).await {
                    | Ok(0) => break,
                    | Ok(n) => offset += n,
                    | Err(_) => return Err(SplitError::InFileNotRead),
                };
            }

            if offset == 0 {
                break;
            }

            let output_path: PathBuf = out_dir.join(total_chunks.to_string());

            let output: fs::File = fs::OpenOptions::new()
                .create(true)
                .truncate(true)
                .write(true)
                .open(output_path)
                .await
                .map_err(|_| SplitError::OutFileNotOpened)?;

            let mut writer: io::BufWriter<fs::File> =
                io::BufWriter::with_capacity(buffer_capacity, output);

            writer
                .write_all(&buffer[..offset])
                .await
                .map_err(|_| SplitError::OutFileNotWritten)?;

            writer.flush().await.map_err(|_| SplitError::OutFileNotWritten)?;

            total_chunks += 1;
        }

        Ok(SplitResult { file_size, total_chunks })
    }
}