Struct http_req::request::Request

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

Relatively higher-level struct for making HTTP requests.

It creates stream (TcpStream or TlsStream) appropriate for the type of uri (http/https) By default it closes connection after completion of the response.

Examples

use http_req::{request::Request, uri::Uri, response::StatusCode};

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

let response = Request::new(&uri).send(&mut writer).unwrap();;
assert_eq!(response.status_code(), StatusCode::new(200));

Methods

impl<'a> Request<'a>

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

Creates new Request with default parameters

Examples

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

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

let response = Request::new(&uri).send(&mut writer).unwrap();;

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

Sets request method

Examples

use http_req::{request::{Request, Method}, uri::Uri};

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

let response = Request::new(&uri)
    .method(Method::HEAD)
    .send(&mut writer)
    .unwrap();

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

Sets HTTP version

Examples

use http_req::{request::{Request, HttpVersion}, uri::Uri};

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

let response = Request::new(&uri)
    .version(HttpVersion::Http10)
    .send(&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 http_req::{request::Request, uri::Uri, response::Headers};

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

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 response = Request::new(&uri)
    .headers(headers)
    .send(&mut writer)
    .unwrap();;

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

Adds header to existing/default headers

Examples

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

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

let response = Request::new(&uri)
    .header("Accept-Language", "en-US")
    .send(&mut writer)
    .unwrap();

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

Sets body for request

Examples

use http_req::{request::{Request, Method}, uri::Uri};

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

let response = Request::new(&uri)
    .method(Method::POST)
    .body(body)
    .send(&mut writer)
    .unwrap();

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

Sets connection timeout of request.

Examples

use std::time::{Duration, Instant};
use http_req::{request::Request, uri::Uri};

let mut writer = Vec::new();
let uri: Uri = "https://www.rust-lang.org/learn".parse().unwrap();
const body: &[u8; 27] = b"field1=value1&field2=value2";
let timeout = Some(Duration::from_secs(3600));

let response = Request::new(&uri)
    .timeout(timeout)
    .send(&mut writer)
    .unwrap();

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

Sets connect timeout while using internal TcpStream instance

• If there is a timeout, it will be passed to TcpStream::connect_timeout.
• If None is provided, TcpStream::connect will be used. A timeout will still be enforced by the operating system, but the exact value depends on the platform.

Examples

use http_req::{request::Request, uri::Uri};
use std::time::Duration;

let mut writer = Vec::new();
let uri: Uri = "https://www.rust-lang.org/learn".parse().unwrap();
const time: Option<Duration> = Some(Duration::from_secs(10));

let response = Request::new(&uri)
    .connect_timeout(time)
    .send(&mut writer)
    .unwrap();

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

Sets read timeout on internal TcpStream instance

timeout will be passed to TcpStream::set_read_timeout.

Examples

use http_req::{request::Request, uri::Uri};
use std::time::Duration;

let mut writer = Vec::new();
let uri: Uri = "https://www.rust-lang.org/learn".parse().unwrap();
const time: Option<Duration> = Some(Duration::from_secs(15));

let response = Request::new(&uri)
    .read_timeout(time)
    .send(&mut writer)
    .unwrap();

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

Sets write timeout on internal TcpStream instance

timeout will be passed to TcpStream::set_write_timeout.

Examples

use http_req::{request::Request, uri::Uri};
use std::time::Duration;

let mut writer = Vec::new();
let uri: Uri = "https://www.rust-lang.org/learn".parse().unwrap();
const time: Option<Duration> = Some(Duration::from_secs(5));

let response = Request::new(&uri)
    .write_timeout(time)
    .send(&mut writer)
    .unwrap();

pub fn root_cert_file_pem(&mut self, file_path: &'a Path) -> &mut Self

Add a file containing the PEM-encoded certificates that should be added in the trusted root store.

pub fn send<T: Write>(&self, writer: &mut T) -> Result<Response, Error>

Sends HTTP request.

Creates TcpStream (and wraps it with TlsStream if needed). Writes request message to created stream. Returns response for this request. Writes response's body to writer.

Examples

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

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

let response = Request::new(&uri).send(&mut writer).unwrap();

Trait Implementations

impl<'a> Clone for Request<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Request<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq<Request<'a>> for Request<'a>

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

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

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

This method tests for !=.

impl<'a> StructuralPartialEq for Request<'a>