Struct lta::reqwest_blocking::RequestBuilder
pub struct RequestBuilder { /* private fields */ }Expand description
A builder to construct the properties of a Request.
To construct a RequestBuilder, refer to the Client documentation.
Implementations§
§impl RequestBuilder
impl RequestBuilder
pub fn header<K, V>(self, key: K, value: V) -> RequestBuilderwhere
HeaderName: TryFrom<K>,
HeaderValue: TryFrom<V>,
<HeaderName as TryFrom<K>>::Error: Into<Error>,
<HeaderValue as TryFrom<V>>::Error: Into<Error>,
pub fn header<K, V>(self, key: K, value: V) -> RequestBuilderwhere
HeaderName: TryFrom<K>,
HeaderValue: TryFrom<V>,
<HeaderName as TryFrom<K>>::Error: Into<Error>,
<HeaderValue as TryFrom<V>>::Error: Into<Error>,
Add a Header to this Request.
use reqwest::header::USER_AGENT;
let client = reqwest::blocking::Client::new();
let res = client.get("https://www.rust-lang.org")
.header(USER_AGENT, "foo")
.send()?;pub fn headers(self, headers: HeaderMap) -> RequestBuilder
pub fn headers(self, headers: HeaderMap) -> RequestBuilder
Add a set of Headers to the existing ones on this Request.
The headers will be merged in to any already set.
use reqwest::header::{HeaderMap, HeaderValue, USER_AGENT, CONTENT_TYPE};
fn construct_headers() -> HeaderMap {
let mut headers = HeaderMap::new();
headers.insert(USER_AGENT, HeaderValue::from_static("reqwest"));
headers.insert(CONTENT_TYPE, HeaderValue::from_static("image/png"));
headers
}
let file = fs::File::open("much_beauty.png")?;
let client = reqwest::blocking::Client::new();
let res = client.post("http://httpbin.org/post")
.headers(construct_headers())
.body(file)
.send()?;pub fn basic_auth<U, P>(
self,
username: U,
password: Option<P>
) -> RequestBuilder
pub fn basic_auth<U, P>( self, username: U, password: Option<P> ) -> RequestBuilder
Enable HTTP basic authentication.
let client = reqwest::blocking::Client::new();
let resp = client.delete("http://httpbin.org/delete")
.basic_auth("admin", Some("good password"))
.send()?;pub fn bearer_auth<T>(self, token: T) -> RequestBuilderwhere
T: Display,
pub fn bearer_auth<T>(self, token: T) -> RequestBuilderwhere
T: Display,
Enable HTTP bearer authentication.
let client = reqwest::blocking::Client::new();
let resp = client.delete("http://httpbin.org/delete")
.bearer_auth("token")
.send()?;pub fn body<T>(self, body: T) -> RequestBuilderwhere
T: Into<Body>,
pub fn body<T>(self, body: T) -> RequestBuilderwhere
T: Into<Body>,
Set the request body.
Examples
Using a string:
let client = reqwest::blocking::Client::new();
let res = client.post("http://httpbin.org/post")
.body("from a &str!")
.send()?;Using a File:
let file = std::fs::File::open("from_a_file.txt")?;
let client = reqwest::blocking::Client::new();
let res = client.post("http://httpbin.org/post")
.body(file)
.send()?;Using arbitrary bytes:
// from bytes!
let bytes: Vec<u8> = vec![1, 10, 100];
let client = reqwest::blocking::Client::new();
let res = client.post("http://httpbin.org/post")
.body(bytes)
.send()?;pub fn timeout(self, timeout: Duration) -> RequestBuilder
pub fn timeout(self, timeout: Duration) -> RequestBuilder
Enables a request timeout.
The timeout is applied from when the request starts connecting until the
response body has finished. It affects only this request and overrides
the timeout configured using ClientBuilder::timeout().
pub fn query<T>(self, query: &T) -> RequestBuilder
pub fn query<T>(self, query: &T) -> RequestBuilder
Modify the query string of the URL.
Modifies the URL of this request, adding the parameters provided.
This method appends and does not overwrite. This means that it can
be called multiple times and that existing query parameters are not
overwritten if the same key is used. The key will simply show up
twice in the query string.
Calling .query(&[("foo", "a"), ("foo", "b")]) gives "foo=a&foo=b".
let client = reqwest::blocking::Client::new();
let res = client.get("http://httpbin.org")
.query(&[("lang", "rust")])
.send()?;Note
This method does not support serializing a single key-value
pair. Instead of using .query(("key", "val")), use a sequence, such
as .query(&[("key", "val")]). It’s also possible to serialize structs
and maps into a key-value pair.
Errors
This method will fail if the object you provide cannot be serialized into a query string.
pub fn version(self, version: Version) -> RequestBuilder
pub fn version(self, version: Version) -> RequestBuilder
Set HTTP version
pub fn form<T>(self, form: &T) -> RequestBuilder
pub fn form<T>(self, form: &T) -> RequestBuilder
Send a form body.
Sets the body to the url encoded serialization of the passed value,
and also sets the Content-Type: application/x-www-form-urlencoded
header.
let mut params = HashMap::new();
params.insert("lang", "rust");
let client = reqwest::blocking::Client::new();
let res = client.post("http://httpbin.org")
.form(¶ms)
.send()?;Errors
This method fails if the passed value cannot be serialized into url encoded format
pub fn json<T>(self, json: &T) -> RequestBuilder
pub fn json<T>(self, json: &T) -> RequestBuilder
Send a JSON body.
Sets the body to the JSON serialization of the passed value, and
also sets the Content-Type: application/json header.
Optional
This requires the optional json feature enabled.
Examples
let mut map = HashMap::new();
map.insert("lang", "rust");
let client = reqwest::blocking::Client::new();
let res = client.post("http://httpbin.org")
.json(&map)
.send()?;Errors
Serialization can fail if T’s implementation of Serialize decides to
fail, or if T contains a map with non-string keys.
pub fn build(self) -> Result<Request, Error>
pub fn build(self) -> Result<Request, Error>
Build a Request, which can be inspected, modified and executed with
Client::execute().
pub fn send(self) -> Result<Response, Error>
pub fn send(self) -> Result<Response, Error>
Constructs the Request and sends it the target URL, returning a Response.
Errors
This method fails if there was an error while sending request, redirect loop was detected or redirect limit was exhausted.
pub fn try_clone(&self) -> Option<RequestBuilder>
pub fn try_clone(&self) -> Option<RequestBuilder>
Attempts to clone the RequestBuilder.
None is returned if a body is which can not be cloned. This can be because the body is a stream.
Examples
With a static body
let client = reqwest::blocking::Client::new();
let builder = client.post("http://httpbin.org/post")
.body("from a &str!");
let clone = builder.try_clone();
assert!(clone.is_some());Without a body
let client = reqwest::blocking::Client::new();
let builder = client.get("http://httpbin.org/get");
let clone = builder.try_clone();
assert!(clone.is_some());With a non-clonable body
let client = reqwest::blocking::Client::new();
let builder = client.get("http://httpbin.org/get")
.body(reqwest::blocking::Body::new(std::io::empty()));
let clone = builder.try_clone();
assert!(clone.is_none());