Struct http_req::request::RequestBuilder

source · 
pub struct RequestBuilder<'a> { /* private fields */ }
Expand description

Relatively low-level struct for making HTTP requests.

It can work with any stream that implements Read and Write. By default it does not close the connection after completion of the response.

§Examples

use std::{net::TcpStream, convert::TryFrom};
use http_req::{request::RequestBuilder, tls, uri::Uri, response::StatusCode};

let addr: Uri = Uri::try_from("https://www.rust-lang.org/learn").unwrap();
let mut writer = Vec::new();

let stream = TcpStream::connect((addr.host().unwrap(), addr.corr_port())).unwrap();
let mut stream = tls::Config::default()
    .connect(addr.host().unwrap_or(""), stream)
    .unwrap();

let response = RequestBuilder::new(&addr)
    .header("Connection", "Close")
    .send(&mut stream, &mut writer)
    .unwrap();

assert_eq!(response.status_code(), StatusCode::new(200));

Implementations§

source§

impl<'a> RequestBuilder<'a>

source

pub fn new(uri: &'a Uri<'a>) -> RequestBuilder<'a>

Creates new RequestBuilder with default parameters

§Examples
use std::{net::TcpStream, convert::TryFrom};
use http_req::{request::RequestBuilder, tls, uri::Uri};

let addr = Uri::try_from("https://www.rust-lang.org/learn").unwrap();
let mut writer = Vec::new();

let stream = TcpStream::connect((addr.host().unwrap(), addr.corr_port())).unwrap();
let mut stream = tls::Config::default()
    .connect(addr.host().unwrap_or(""), stream)
    .unwrap();

let response = RequestBuilder::new(&addr)
    .header("Connection", "Close")
    .send(&mut stream, &mut writer)
    .unwrap();
Examples found in repository?
examples/request_builder_get.rs (line 20)
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

fn main() {
    //Parses a URI and assigns it to a variable `addr`.
    let addr: Uri = Uri::try_from("https://www.rust-lang.org/learn").unwrap();

    //Connects to a remote host. Uses information from `addr`.
    let stream = TcpStream::connect((addr.host().unwrap(), addr.corr_port())).unwrap();

    //Opens a secure connection over TlsStream. This is required due to use of `https` protocol.
    let mut stream = tls::Config::default()
        .connect(addr.host().unwrap_or(""), stream)
        .unwrap();

    //Container for a response's body.
    let mut writer = Vec::new();

    //Adds a header `Connection: Close`.
    let response = RequestBuilder::new(&addr)
        .header("Connection", "Close")
        .send(&mut stream, &mut writer)
        .unwrap();

    println!("Status: {} {}", response.status_code(), response.reason());
    println!("Headers: {}", response.headers());
    //println!("{}", String::from_utf8_lossy(&writer));
}
source

pub fn method<T>(&mut self, method: T) -> &mut Self
where Method: From<T>,

Sets request method

§Examples
use std::{net::TcpStream, convert::TryFrom};
use http_req::{request::{RequestBuilder, Method}, tls, uri::Uri};

let addr= Uri::try_from("https://www.rust-lang.org/learn").unwrap();
let mut writer = Vec::new();

let stream = TcpStream::connect((addr.host().unwrap(), addr.corr_port())).unwrap();
let mut stream = tls::Config::default()
    .connect(addr.host().unwrap_or(""), stream)
    .unwrap();

let response = RequestBuilder::new(&addr)
    .method(Method::HEAD)
    .header("Connection", "Close")
    .send(&mut stream, &mut writer)
    .unwrap();
source

pub fn version<T>(&mut self, version: T) -> &mut Self
where HttpVersion: From<T>,

Sets HTTP version

§Examples
use std::{net::TcpStream, convert::TryFrom};
use http_req::{request::{RequestBuilder, HttpVersion}, tls, uri::Uri};

let addr = Uri::try_from("https://www.rust-lang.org/learn").unwrap();
let mut writer = Vec::new();

let stream = TcpStream::connect((addr.host().unwrap(), addr.corr_port())).unwrap();
let mut stream = tls::Config::default()
    .connect(addr.host().unwrap_or(""), stream)
    .unwrap();

let response = RequestBuilder::new(&addr)
    .version(HttpVersion::Http10)
    .header("Connection", "Close")
    .send(&mut stream, &mut writer)
    .unwrap();
source

pub fn headers<T>(&mut self, headers: T) -> &mut Self
where Headers: From<T>,

Replaces all it’s headers with headers passed to the function

§Examples
use std::{net::TcpStream, convert::TryFrom};
use http_req::{request::{RequestBuilder, Method}, response::Headers, tls, uri::Uri};

let addr = Uri::try_from("https://www.rust-lang.org/learn").unwrap();
let mut writer = Vec::new();
let mut headers = Headers::new();
headers.insert("Accept-Charset", "utf-8");
headers.insert("Accept-Language", "en-US");
headers.insert("Host", "rust-lang.org");
headers.insert("Connection", "Close");

let stream = TcpStream::connect((addr.host().unwrap(), addr.corr_port())).unwrap();
let mut stream = tls::Config::default()
    .connect(addr.host().unwrap_or(""), stream)
    .unwrap();

let response = RequestBuilder::new(&addr)
    .headers(headers)
    .send(&mut stream, &mut writer)
    .unwrap();
source

pub fn header<T, U>(&mut self, key: &T, val: &U) -> &mut Self
where T: ToString + ?Sized, U: ToString + ?Sized,

Adds new header to existing/default headers

§Examples
use std::{net::TcpStream, convert::TryFrom};
use http_req::{request::{RequestBuilder, Method}, tls, uri::Uri};

let addr: Uri = Uri::try_from("https://www.rust-lang.org/learn").unwrap();
let mut writer = Vec::new();

let stream = TcpStream::connect((addr.host().unwrap(), addr.corr_port())).unwrap();
let mut stream = tls::Config::default()
    .connect(addr.host().unwrap_or(""), stream)
    .unwrap();

let response = RequestBuilder::new(&addr)
    .header("Connection", "Close")
    .send(&mut stream, &mut writer)
    .unwrap();
Examples found in repository?
examples/request_builder_get.rs (line 21)
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

fn main() {
    //Parses a URI and assigns it to a variable `addr`.
    let addr: Uri = Uri::try_from("https://www.rust-lang.org/learn").unwrap();

    //Connects to a remote host. Uses information from `addr`.
    let stream = TcpStream::connect((addr.host().unwrap(), addr.corr_port())).unwrap();

    //Opens a secure connection over TlsStream. This is required due to use of `https` protocol.
    let mut stream = tls::Config::default()
        .connect(addr.host().unwrap_or(""), stream)
        .unwrap();

    //Container for a response's body.
    let mut writer = Vec::new();

    //Adds a header `Connection: Close`.
    let response = RequestBuilder::new(&addr)
        .header("Connection", "Close")
        .send(&mut stream, &mut writer)
        .unwrap();

    println!("Status: {} {}", response.status_code(), response.reason());
    println!("Headers: {}", response.headers());
    //println!("{}", String::from_utf8_lossy(&writer));
}
source

pub fn body(&mut self, body: &'a [u8]) -> &mut Self

Sets body for request

§Examples
use std::{net::TcpStream, convert::TryFrom};
use http_req::{request::{RequestBuilder, Method}, tls, uri::Uri};

let addr = Uri::try_from("https://www.rust-lang.org/learn").unwrap();
const body: &[u8; 27] = b"field1=value1&field2=value2";
let mut writer = Vec::new();

let stream = TcpStream::connect((addr.host().unwrap(), addr.corr_port())).unwrap();
let mut stream = tls::Config::default()
    .connect(addr.host().unwrap_or(""), stream)
    .unwrap();

let response = RequestBuilder::new(&addr)
    .method(Method::POST)
    .body(body)
    .header("Content-Length", &body.len())
    .header("Connection", "Close")
    .send(&mut stream, &mut writer)
    .unwrap();
source

pub fn timeout<T>(&mut self, timeout: Option<T>) -> &mut Self
where Duration: From<T>,

Sets timeout for entire connection.

§Examples
use std::{net::TcpStream, time::{Duration, Instant}, convert::TryFrom};
use http_req::{request::RequestBuilder, tls, uri::Uri};

let addr = Uri::try_from("https://www.rust-lang.org/learn").unwrap();
let mut writer = Vec::new();

let stream = TcpStream::connect((addr.host().unwrap(), addr.corr_port())).unwrap();
let mut stream = tls::Config::default()
    .connect(addr.host().unwrap_or(""), stream)
    .unwrap();
let timeout = Some(Duration::from_secs(3600));

let response = RequestBuilder::new(&addr)
    .timeout(timeout)
    .header("Connection", "Close")
    .send(&mut stream, &mut writer)
    .unwrap();
source

pub fn send<T, U>( &self, stream: &mut T, writer: &mut U ) -> Result<Response, Error>
where T: Write + Read, U: Write,

Sends HTTP request in these steps:

  • Writes request message to stream.
  • Writes response’s body to writer.
  • Returns response for this request.
§Examples

HTTP

use std::{net::TcpStream, convert::TryFrom};
use http_req::{request::RequestBuilder, uri::Uri};

 //This address is automatically redirected to HTTPS, so response code will not ever be 200
let addr = Uri::try_from("https://www.rust-lang.org/learn").unwrap();
let mut writer = Vec::new();
let mut stream = TcpStream::connect((addr.host().unwrap(), addr.corr_port())).unwrap();

let response = RequestBuilder::new(&addr)
    .header("Connection", "Close")
    .send(&mut stream, &mut writer)
    .unwrap();

HTTPS

use std::{net::TcpStream, convert::TryFrom};
use http_req::{request::RequestBuilder, tls, uri::Uri};

let addr: Uri = Uri::try_from("https://www.rust-lang.org/learn").unwrap();
let mut writer = Vec::new();

let stream = TcpStream::connect((addr.host().unwrap(), addr.corr_port())).unwrap();
let mut stream = tls::Config::default()
    .connect(addr.host().unwrap_or(""), stream)
    .unwrap();

let response = RequestBuilder::new(&addr)
    .header("Connection", "Close")
    .send(&mut stream, &mut writer)
    .unwrap();
Examples found in repository?
examples/request_builder_get.rs (line 22)
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

fn main() {
    //Parses a URI and assigns it to a variable `addr`.
    let addr: Uri = Uri::try_from("https://www.rust-lang.org/learn").unwrap();

    //Connects to a remote host. Uses information from `addr`.
    let stream = TcpStream::connect((addr.host().unwrap(), addr.corr_port())).unwrap();

    //Opens a secure connection over TlsStream. This is required due to use of `https` protocol.
    let mut stream = tls::Config::default()
        .connect(addr.host().unwrap_or(""), stream)
        .unwrap();

    //Container for a response's body.
    let mut writer = Vec::new();

    //Adds a header `Connection: Close`.
    let response = RequestBuilder::new(&addr)
        .header("Connection", "Close")
        .send(&mut stream, &mut writer)
        .unwrap();

    println!("Status: {} {}", response.status_code(), response.reason());
    println!("Headers: {}", response.headers());
    //println!("{}", String::from_utf8_lossy(&writer));
}
source

pub fn write_msg<T, U>(&self, stream: &mut T, msg: &U) -> Result<(), Error>
where T: Write, U: AsRef<[u8]>,

Writes message to stream and flushes it

source

pub fn read_head<T: Read>( &self, stream: &mut T, deadline: Instant ) -> Result<(Response, Vec<u8>), Error>

Reads head of server’s response

source

pub fn parse_msg(&self) -> Vec<u8>

Parses request message for this RequestBuilder

Trait Implementations§

source§

impl<'a> Clone for RequestBuilder<'a>

source§

fn clone(&self) -> RequestBuilder<'a>

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl<'a> Debug for RequestBuilder<'a>

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl<'a> PartialEq for RequestBuilder<'a>

source§

fn eq(&self, other: &RequestBuilder<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a> StructuralPartialEq for RequestBuilder<'a>

Auto Trait Implementations§

§

impl<'a> Freeze for RequestBuilder<'a>

§

impl<'a> RefUnwindSafe for RequestBuilder<'a>

§

impl<'a> Send for RequestBuilder<'a>

§

impl<'a> Sync for RequestBuilder<'a>

§

impl<'a> Unpin for RequestBuilder<'a>

§

impl<'a> UnwindSafe for RequestBuilder<'a>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.