Struct Request 

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

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};
use std::convert::TryFrom;

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

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

Implementations

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};
use std::convert::TryFrom;

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

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

Examples found in repository

examples/add_headers.rs (line 20)

fn main() {
    let mut writer = Vec::new();
    let uri = Uri::try_from("http://eu.httpbin.org/get?msg=WasmEdge").unwrap();
    // let uri = Uri::try_from("https://httpbin.org/get").unwrap(); // uncomment the line for https request

    // add headers to the request
    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");

    Request::new(&uri)
        .headers(headers)
        .send(&mut writer)
        .unwrap();

    println!("{}", String::from_utf8_lossy(&writer));

    // set version
    Request::new(&uri)
        .version(HttpVersion::Http10)
        .send(&mut writer)
        .unwrap();

    println!("{}", String::from_utf8_lossy(&writer));
}

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};
use std::convert::TryFrom;

let mut writer = Vec::new();
let uri: Uri = Uri::try_from("https://www.rust-lang.org/learn").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};
use std::convert::TryFrom;

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

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

Examples found in repository

examples/add_headers.rs (line 29)

fn main() {
    let mut writer = Vec::new();
    let uri = Uri::try_from("http://eu.httpbin.org/get?msg=WasmEdge").unwrap();
    // let uri = Uri::try_from("https://httpbin.org/get").unwrap(); // uncomment the line for https request

    // add headers to the request
    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");

    Request::new(&uri)
        .headers(headers)
        .send(&mut writer)
        .unwrap();

    println!("{}", String::from_utf8_lossy(&writer));

    // set version
    Request::new(&uri)
        .version(HttpVersion::Http10)
        .send(&mut writer)
        .unwrap();

    println!("{}", String::from_utf8_lossy(&writer));
}

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};
use std::convert::TryFrom;

let mut writer = Vec::new();
let uri: Uri = Uri::try_from("https://www.rust-lang.org/learn").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();;

Examples found in repository

examples/add_headers.rs (line 21)

fn main() {
    let mut writer = Vec::new();
    let uri = Uri::try_from("http://eu.httpbin.org/get?msg=WasmEdge").unwrap();
    // let uri = Uri::try_from("https://httpbin.org/get").unwrap(); // uncomment the line for https request

    // add headers to the request
    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");

    Request::new(&uri)
        .headers(headers)
        .send(&mut writer)
        .unwrap();

    println!("{}", String::from_utf8_lossy(&writer));

    // set version
    Request::new(&uri)
        .version(HttpVersion::Http10)
        .send(&mut writer)
        .unwrap();

    println!("{}", String::from_utf8_lossy(&writer));
}

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

where T: ToString + ?Sized, U: ToString + ?Sized,

Adds header to existing/default headers

Examples

use http_req::{request::Request, uri::Uri};
use std::convert::TryFrom;

let mut writer = Vec::new();
let uri = Uri::try_from("https://www.rust-lang.org/learn").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};
use std::convert::TryFrom;

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

let response = Request::new(&uri)
    .method(Method::POST)
    .header("Content-Length", &body.len())
    .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}, convert::TryFrom};
use http_req::{request::Request, uri::Uri};

let mut writer = Vec::new();
let uri = Uri::try_from("https://www.rust-lang.org/learn").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, convert::TryFrom};

let mut writer = Vec::new();
let uri = Uri::try_from("https://www.rust-lang.org/learn").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, convert::TryFrom};

let mut writer = Vec::new();
let uri: Uri = Uri::try_from("https://www.rust-lang.org/learn").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, convert::TryFrom};

let mut writer = Vec::new();
let uri = Uri::try_from("https://www.rust-lang.org/learn").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};
use std::convert::TryFrom;

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

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

Examples found in repository

examples/add_headers.rs (line 22)

fn main() {
    let mut writer = Vec::new();
    let uri = Uri::try_from("http://eu.httpbin.org/get?msg=WasmEdge").unwrap();
    // let uri = Uri::try_from("https://httpbin.org/get").unwrap(); // uncomment the line for https request

    // add headers to the request
    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");

    Request::new(&uri)
        .headers(headers)
        .send(&mut writer)
        .unwrap();

    println!("{}", String::from_utf8_lossy(&writer));

    // set version
    Request::new(&uri)
        .version(HttpVersion::Http10)
        .send(&mut writer)
        .unwrap();

    println!("{}", String::from_utf8_lossy(&writer));
}

Trait Implementations

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

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

Returns a duplicate 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 for Request<'a>

fn eq(&self, other: &Request<'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 Request<'a>