Struct http_req::request::RequestBuilder

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

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;
use http_req::{request::RequestBuilder, tls, uri::Uri, response::StatusCode};

let addr: Uri = "https://www.rust-lang.org/learn".parse().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));

Methods

impl<'a> RequestBuilder<'a>

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

Creates new RequestBuilder with default parameters

Examples

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

let addr: Uri = "https://www.rust-lang.org/learn".parse().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;
use http_req::{request::{RequestBuilder, Method}, tls, uri::Uri};

let addr: Uri = "https://www.rust-lang.org/learn".parse().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;
use http_req::{request::{RequestBuilder, HttpVersion}, tls, uri::Uri};

let addr: Uri = "https://www.rust-lang.org/learn".parse().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;
use http_req::{request::{RequestBuilder, Method}, response::Headers, tls, uri::Uri};

let addr: Uri = "https://www.rust-lang.org/learn".parse().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: ?Sized, U: ?Sized>(&mut self, key: &T, val: &U) -> &mut Self where
    T: ToString,
    U: ToString, 

Adds new header to existing/default headers

Examples

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

let addr: Uri = "https://www.rust-lang.org/learn".parse().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;
use http_req::{request::{RequestBuilder, Method}, tls, uri::Uri};

let addr: Uri = "https://www.rust-lang.org/learn".parse().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("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;
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 = "http://www.rust-lang.org/learn".parse().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;
use http_req::{request::RequestBuilder, tls, uri::Uri};

let addr: Uri = "https://www.rust-lang.org/learn".parse().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) -> Result<Response, Error>

Reads head of server's response

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

Parses request message for this RequestBuilder

Trait Implementations

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

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

Returns a copy 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<RequestBuilder<'a>> for RequestBuilder<'a>

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

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

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

This method tests for !=.

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