Struct RequestBuilder 

pub struct RequestBuilder<'a> { /* private fields */ }

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

impl<'a> RequestBuilder<'a>

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();

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();

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();

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();

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();

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();

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();

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();

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

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

Reads head of server’s response

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

Parses request message for this RequestBuilder

pub fn build(self) -> Request<'a>

Consume self to build a Request instance.

Examples

use http_req::{request::RequestBuilder, uri::Uri};

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

let request = RequestBuilder::new(&addr)
    .header("Connection", "Close")
    .build();

let response = request.send(&mut writer);

Trait Implementations

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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