lynx 0.2.0

Small and lightweight HTTP client
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

use std::io::{self, Read};

use http::header::HeaderMap;
#[cfg(feature = "compress")]
use http::header::CONTENT_ENCODING;
#[cfg(feature = "compress")]
use libflate::{deflate, gzip};

#[cfg(feature = "compress")]
use crate::error::HttpError;
use crate::error::HttpResult;
use crate::parsing::body_reader::BodyReader;

pub enum CompressedReader {
    Plain(BodyReader),
    #[cfg(feature = "compress")]
    Deflate(deflate::Decoder<BodyReader>),
    #[cfg(feature = "compress")]
    Gzip(gzip::Decoder<BodyReader>),
}

impl CompressedReader {
    #[cfg(feature = "compress")]
    pub fn new(headers: &HeaderMap, reader: BodyReader) -> HttpResult<CompressedReader> {
        if let Some(content_encoding) = headers.get(CONTENT_ENCODING).map(|v| v.as_bytes()) {
            match content_encoding {
                b"deflate" => Ok(CompressedReader::Deflate(deflate::Decoder::new(reader))),
                b"gzip" => Ok(CompressedReader::Gzip(gzip::Decoder::new(reader)?)),
                _ => Err(HttpError::InvalidResponse("invalid Content-Encoding header")),
            }
        } else {
            Ok(CompressedReader::Plain(reader))
        }
    }

    #[cfg(not(feature = "compress"))]
    pub fn new(_: &HeaderMap, reader: BodyReader) -> HttpResult<CompressedReader> {
        Ok(CompressedReader::Plain(reader))
    }
}

impl Read for CompressedReader {
    #[inline]
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        match self {
            CompressedReader::Plain(s) => s.read(buf),
            #[cfg(feature = "compress")]
            CompressedReader::Deflate(s) => s.read(buf),
            #[cfg(feature = "compress")]
            CompressedReader::Gzip(s) => s.read(buf),
        }
    }
}

#[cfg(test)]
mod tests {
    use std::io::prelude::*;

    #[cfg(feature = "compress")]
    use libflate::{deflate, gzip};

    use crate::parsing::response::parse_response;
    use crate::streams::BaseStream;
    use crate::Request;

    #[test]
    fn test_stream_plain() {
        let payload = b"Hello world!!!!!!!!";

        let mut buf: Vec<u8> = Vec::new();
        let _ = write!(buf, "HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n", payload.len());
        buf.extend(payload);

        let req = Request::get("http://google.ca");

        let sock = BaseStream::mock(buf);
        let (_, _, response) = parse_response(sock, &req).unwrap();
        assert_eq!(response.string().unwrap(), "Hello world!!!!!!!!");
    }

    #[test]
    #[cfg(feature = "compress")]
    fn test_stream_deflate() {
        let mut payload = Vec::new();
        let mut enc = deflate::Encoder::new(&mut payload);
        enc.write_all(b"Hello world!!!!!!!!").unwrap();
        enc.finish();

        let mut buf: Vec<u8> = Vec::new();
        let _ = write!(
            buf,
            "HTTP/1.1 200 OK\r\nContent-Length: {}\r\nContent-Encoding: deflate\r\n\r\n",
            payload.len()
        );
        buf.extend(payload);

        let req = Request::get("http://google.ca");

        let sock = BaseStream::mock(buf);
        let (_, _, response) = parse_response(sock, &req).unwrap();
        assert_eq!(response.string().unwrap(), "Hello world!!!!!!!!");
    }

    #[test]
    #[cfg(feature = "compress")]
    fn test_stream_gzip() {
        let mut payload = Vec::new();
        let mut enc = gzip::Encoder::new(&mut payload).unwrap();
        enc.write_all(b"Hello world!!!!!!!!").unwrap();
        enc.finish();

        let mut buf: Vec<u8> = Vec::new();
        let _ = write!(
            buf,
            "HTTP/1.1 200 OK\r\nContent-Length: {}\r\nContent-Encoding: gzip\r\n\r\n",
            payload.len()
        );
        buf.extend(payload);

        let req = Request::get("http://google.ca");

        let sock = BaseStream::mock(buf);
        let (_, _, response) = parse_response(sock, &req).unwrap();

        assert_eq!(response.string().unwrap(), "Hello world!!!!!!!!");
    }
}