reqrio 0.2.0

A lightweight, high concurrency HTTP request library
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use std::fs::File;
use std::io::Cursor;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use crate::error::HlsResult;
use crate::form_data::FormError;
use crate::form_data::reader::{FileFormReader, FileDataRender};
use crate::reader::RefReader;

enum InputType {
    Bytes(Vec<u8>),
    Path(PathBuf),
}

impl InputType {
    fn as_reader(&self) -> HlsResult<FileDataRender<'_>> {
        match self {
            InputType::Bytes(bytes) => Ok(FileDataRender::Bytes(Cursor::new(bytes))),
            InputType::Path(path) => {
                let filesize = path.metadata()?.len() as usize;
                let file = File::open(path)?;
                Ok(FileDataRender::File((0, filesize, file)))
            }
        }
    }
}

pub struct FileForm {
    filename: String,
    filetype: String,
    field_name: String,
    input: InputType,
}

impl Default for FileForm {
    fn default() -> Self {
        FileForm {
            filename: "123.txt".to_string(),
            filetype: "".to_string(),
            field_name: "file".to_string(),
            input: InputType::Bytes(vec![]),
        }
    }
}

impl FileForm {
    pub fn new_path(path: impl AsRef<Path>) -> HlsResult<FileForm> {
        let path = path.as_ref().to_path_buf();
        let filename = path.file_name().ok_or(FormError::GetFilenameError)?.display().to_string();
        Ok(FileForm {
            filename,
            field_name: "file".to_string(),
            input: InputType::Path(path),
            ..Default::default()
        })
    }

    pub fn new_bytes(bytes: impl Into<Vec<u8>>) -> FileForm {
        FileForm {
            filename: "1223.txt".to_string(),
            field_name: "file".to_string(),
            input: InputType::Bytes(bytes.into()),
            ..Default::default()
        }
    }

    pub fn with_filename(mut self, filename: impl ToString) -> Self {
        self.set_filename(filename);
        self
    }

    pub fn with_filetype(mut self, filetype: impl ToString) -> Self {
        self.set_filetype(filetype);
        self
    }

    pub fn with_field_name(mut self, field_name: impl ToString) -> Self {
        self.set_field_name(field_name);
        self
    }

    pub fn set_filename(&mut self, filename: impl ToString) {
        self.filename = filename.to_string()
    }

    pub fn set_filetype(&mut self, filetype: impl ToString) {
        self.filetype = filetype.to_string()
    }

    pub fn set_field_name(&mut self, field: impl ToString) {
        self.field_name = field.to_string()
    }

    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }

    pub fn len(&self) -> usize {
        let mut len = 94 + self.field_name.len() + self.filename.len() + self.filesize().unwrap_or(0);
        if !self.filetype.is_empty() {
            len += 16 + self.filetype.len()
        }
        len
    }

    pub fn filesize(&self) -> HlsResult<usize> {
        match &self.input {
            InputType::Bytes(bs) => Ok(bs.len()),
            InputType::Path(f) => Ok(f.metadata()?.len() as usize),
        }
    }

    pub fn filename(&self) -> &str { &self.filename }

    pub(crate) fn as_form_render<'a>(&'a self, boundary: &'a Arc<String>) -> HlsResult<FileFormReader<'a>> {
        let mut reader: RefReader<&[u8]> = RefReader::default();
        //line1
        reader.add_buf(b"--");
        reader.add_buf(boundary.as_bytes());
        //line2
        reader.add_buf(b"\r\nContent-Disposition: form-data; name=\"");
        reader.add_buf(self.field_name.as_bytes());
        reader.add_buf(b"\"; filename=\"");
        reader.add_buf(self.filename.as_bytes());
        reader.add_buf(b"\"\r\n");
        //line3
        if !self.filetype.is_empty() {
            //line3
            reader.add_buf(b"Content-Type: "); //14
            reader.add_buf(self.filetype.as_bytes());
            reader.add_buf(b"\r\n");
        }
        //line4
        reader.add_buf(b"\r\n");
        Ok(FileFormReader {
            prefix_reader: reader,
            //line5
            file_reader: self.input.as_reader()?,
            //line6
            suffix_reader: RefReader::new_buf(b"\r\n"),
            pos: 0,
        })
    }
}