weber 0.1.1

Simple web server with VERY limited functionality
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

use std::io::{Read, Write, BufRead, BufReader, ErrorKind};
use std::net::TcpStream;
use crate::{
    net::{
        Error,
        Result,
        HttpData
    },
    parser::Builder
};

const CAPACITY: usize = 512;

///Simplified connection
///
///Has the most simplified methods for communication
pub struct Connection {
    stream: Option<TcpStream>,

    readed: bool,
    writed: bool
}

impl Connection {
    pub(crate) fn new(stream: TcpStream) -> Self {
        Self {
            stream: Some(stream),
            readed: false,
            writed: false
        }
    }

    ///Makes a connection and returns a Connect if successful
    pub fn connect(ip: &str) -> Result<Connection> {
        let stream = match TcpStream::connect(ip) {
            Ok(stream) => stream,
            Err(_) => return Err(Error::ConnectionError)
        };

        Ok(Self::new(stream))
    }

    ///Performs stream reading and parsing
    ///
    ///Returns a request / response if successful
    pub fn parse_incoming(&mut self) -> Result<HttpData> {
        if self.readed {
            return Err(Error::UnableToRead);
        } // If stream is already readed, return Err::BadRequest

        // Create buffers. vec has a minimum size to allocate for optimization
        let mut buf = BufReader::new(self.stream.take().unwrap());
        let mut vec = Vec::with_capacity(CAPACITY);

        while let Ok(n) = buf.read_until('\n' as u8, &mut vec) {
            if n <= 2 {
                break;
            }
        } // Read until \r\n


        let mut parsed = match HttpData::parse(&vec) {
            Ok(parsed) => parsed,
            Err(_) => return Err(Error::BadRequest)
        }; // Parse the request, if failed, return Err::BadRequest


        let headers = parsed.headers();
        parsed.set_content(match headers.get("Content-Length") {
            Some(lenght) => {
                let lenght: usize = match String::from_utf8_lossy(lenght).parse() {
                    Ok(i) => i,
                    Err(_) => return Err(Error::BadRequest)
                };

                let mut vec = vec![0u8; lenght];

                if let Err(_) = buf.read_exact(&mut vec) {
                    return Err(Error::BadRequest);
                } // If the fields are incorrect, return Error::BadRequest

                Some(vec)
            }

            None => {
                None
            }
        }); // If we have content fields, read the content


        self.stream = Some(buf.into_inner());
        self.readed = true;

        Ok(parsed)
    }

    ///Writes a structure that implements the trait Builder
    ///
    ///Structure in process consumed
    pub fn write_builder<T>(&mut self, response: T) -> Result<()>
        where T: Builder
    {
        if self.writed {
            return Err(Error::UnableToWrite);
        }

        let mut stream = self.stream.take().unwrap();
        let response = response.build(); // Build the response

        if let Err(_) = stream.write_all(&response) {
            return Err(Error::UnableToWrite);
        } // If unable to write, return an error

        if let Err(e) = stream.flush() {
            return match e.kind() {
                ErrorKind::ConnectionAborted => Err(Error::ConnectionLost),
                _ => Err(Error::ConnectionError)
            }
        } // If sending failed, return an error

        self.stream = Some(stream);
        self.writed = true;

        Ok(())
    }
}