Make the async Client default (#626)
The previously default Client is moved to `reqwest::blocking`, while the async client becomes the main API. Closes #622
This commit is contained in:
Sean McArthur
GitHub
299
src/blocking/body.rs
Normal file
299
src/blocking/body.rs
Normal file
@@ -0,0 +1,299 @@
|
||||
use std::fmt;
|
||||
use std::fs::File;
|
||||
use std::future::Future;
|
||||
use std::io::{self, Cursor, Read};
|
||||
|
||||
use bytes::Bytes;
|
||||
|
||||
use crate::async_impl;
|
||||
|
||||
/// The body of a `Request`.
|
||||
///
|
||||
/// In most cases, this is not needed directly, as the
|
||||
/// [`RequestBuilder.body`][builder] method uses `Into<Body>`, which allows
|
||||
/// passing many things (like a string or vector of bytes).
|
||||
///
|
||||
/// [builder]: ./struct.RequestBuilder.html#method.body
|
||||
#[derive(Debug)]
|
||||
pub struct Body {
|
||||
kind: Kind,
|
||||
}
|
||||
|
||||
impl Body {
|
||||
/// Instantiate a `Body` from a reader.
|
||||
///
|
||||
/// # Note
|
||||
///
|
||||
/// While allowing for many types to be used, these bodies do not have
|
||||
/// a way to reset to the beginning and be reused. This means that when
|
||||
/// encountering a 307 or 308 status code, instead of repeating the
|
||||
/// request at the new location, the `Response` will be returned with
|
||||
/// the redirect status code set.
|
||||
///
|
||||
/// ```rust
|
||||
/// # use std::fs::File;
|
||||
/// # use reqwest::blocking::Body;
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// let file = File::open("national_secrets.txt")?;
|
||||
/// let body = Body::new(file);
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// If you have a set of bytes, like `String` or `Vec<u8>`, using the
|
||||
/// `From` implementations for `Body` will store the data in a manner
|
||||
/// it can be reused.
|
||||
///
|
||||
/// ```rust
|
||||
/// # use reqwest::blocking::Body;
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// let s = "A stringy body";
|
||||
/// let body = Body::from(s);
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub fn new<R: Read + Send + 'static>(reader: R) -> Body {
|
||||
Body {
|
||||
kind: Kind::Reader(Box::from(reader), None),
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a `Body` from a `Read` where the size is known in advance
|
||||
/// but the data should not be fully loaded into memory. This will
|
||||
/// set the `Content-Length` header and stream from the `Read`.
|
||||
///
|
||||
/// ```rust
|
||||
/// # use std::fs::File;
|
||||
/// # use reqwest::blocking::Body;
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// let file = File::open("a_large_file.txt")?;
|
||||
/// let file_size = file.metadata()?.len();
|
||||
/// let body = Body::sized(file, file_size);
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub fn sized<R: Read + Send + 'static>(reader: R, len: u64) -> Body {
|
||||
Body {
|
||||
kind: Kind::Reader(Box::from(reader), Some(len)),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn len(&self) -> Option<u64> {
|
||||
match self.kind {
|
||||
Kind::Reader(_, len) => len,
|
||||
Kind::Bytes(ref bytes) => Some(bytes.len() as u64),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn into_reader(self) -> Reader {
|
||||
match self.kind {
|
||||
Kind::Reader(r, _) => Reader::Reader(r),
|
||||
Kind::Bytes(b) => Reader::Bytes(Cursor::new(b)),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn into_async(self) -> (Option<Sender>, async_impl::Body, Option<u64>) {
|
||||
match self.kind {
|
||||
Kind::Reader(read, len) => {
|
||||
let (tx, rx) = hyper::Body::channel();
|
||||
let tx = Sender {
|
||||
body: (read, len),
|
||||
tx,
|
||||
};
|
||||
(Some(tx), async_impl::Body::wrap(rx), len)
|
||||
}
|
||||
Kind::Bytes(chunk) => {
|
||||
let len = chunk.len() as u64;
|
||||
(None, async_impl::Body::reusable(chunk), Some(len))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn try_clone(&self) -> Option<Body> {
|
||||
self.kind.try_clone().map(|kind| Body { kind })
|
||||
}
|
||||
}
|
||||
|
||||
enum Kind {
|
||||
Reader(Box<dyn Read + Send>, Option<u64>),
|
||||
Bytes(Bytes),
|
||||
}
|
||||
|
||||
impl Kind {
|
||||
fn try_clone(&self) -> Option<Kind> {
|
||||
match self {
|
||||
Kind::Reader(..) => None,
|
||||
Kind::Bytes(v) => Some(Kind::Bytes(v.clone())),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<Vec<u8>> for Body {
|
||||
#[inline]
|
||||
fn from(v: Vec<u8>) -> Body {
|
||||
Body {
|
||||
kind: Kind::Bytes(v.into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<String> for Body {
|
||||
#[inline]
|
||||
fn from(s: String) -> Body {
|
||||
s.into_bytes().into()
|
||||
}
|
||||
}
|
||||
|
||||
impl From<&'static [u8]> for Body {
|
||||
#[inline]
|
||||
fn from(s: &'static [u8]) -> Body {
|
||||
Body {
|
||||
kind: Kind::Bytes(Bytes::from_static(s)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<&'static str> for Body {
|
||||
#[inline]
|
||||
fn from(s: &'static str) -> Body {
|
||||
s.as_bytes().into()
|
||||
}
|
||||
}
|
||||
|
||||
impl From<File> for Body {
|
||||
#[inline]
|
||||
fn from(f: File) -> Body {
|
||||
let len = f.metadata().map(|m| m.len()).ok();
|
||||
Body {
|
||||
kind: Kind::Reader(Box::new(f), len),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Debug for Kind {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
match *self {
|
||||
Kind::Reader(_, ref v) => f
|
||||
.debug_struct("Reader")
|
||||
.field("length", &DebugLength(v))
|
||||
.finish(),
|
||||
Kind::Bytes(ref v) => fmt::Debug::fmt(v, f),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct DebugLength<'a>(&'a Option<u64>);
|
||||
|
||||
impl<'a> fmt::Debug for DebugLength<'a> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
match *self.0 {
|
||||
Some(ref len) => fmt::Debug::fmt(len, f),
|
||||
None => f.write_str("Unknown"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) enum Reader {
|
||||
Reader(Box<dyn Read + Send>),
|
||||
Bytes(Cursor<Bytes>),
|
||||
}
|
||||
|
||||
impl Read for Reader {
|
||||
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
||||
match *self {
|
||||
Reader::Reader(ref mut rdr) => rdr.read(buf),
|
||||
Reader::Bytes(ref mut rdr) => rdr.read(buf),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) struct Sender {
|
||||
body: (Box<dyn Read + Send>, Option<u64>),
|
||||
tx: hyper::body::Sender,
|
||||
}
|
||||
|
||||
async fn send_future(sender: Sender) -> Result<(), crate::Error> {
|
||||
use bytes::{BufMut, BytesMut};
|
||||
use std::cmp;
|
||||
|
||||
let con_len = sender.body.1;
|
||||
let cap = cmp::min(sender.body.1.unwrap_or(8192), 8192);
|
||||
let mut written = 0;
|
||||
let mut buf = BytesMut::with_capacity(cap as usize);
|
||||
let mut body = sender.body.0;
|
||||
// Put in an option so that it can be consumed on error to call abort()
|
||||
let mut tx = Some(sender.tx);
|
||||
|
||||
loop {
|
||||
if Some(written) == con_len {
|
||||
// Written up to content-length, so stop.
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// The input stream is read only if the buffer is empty so
|
||||
// that there is only one read in the buffer at any time.
|
||||
//
|
||||
// We need to know whether there is any data to send before
|
||||
// we check the transmission channel (with poll_ready below)
|
||||
// because somestimes the receiver disappears as soon as is
|
||||
// considers the data is completely transmitted, which may
|
||||
// be true.
|
||||
//
|
||||
// The use case is a web server that closes its
|
||||
// input stream as soon as the data received is valid JSON.
|
||||
// This behaviour is questionable, but it exists and the
|
||||
// fact is that there is actually no remaining data to read.
|
||||
if buf.is_empty() {
|
||||
if buf.remaining_mut() == 0 {
|
||||
buf.reserve(8192);
|
||||
}
|
||||
|
||||
match body.read(unsafe { buf.bytes_mut() }) {
|
||||
Ok(0) => {
|
||||
// The buffer was empty and nothing's left to
|
||||
// read. Return.
|
||||
return Ok(());
|
||||
}
|
||||
Ok(n) => unsafe {
|
||||
buf.advance_mut(n);
|
||||
},
|
||||
Err(e) => {
|
||||
let ret = io::Error::new(e.kind(), e.to_string());
|
||||
tx.take().expect("tx only taken on error").abort();
|
||||
return Err(crate::error::from(ret));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// The only way to get here is when the buffer is not empty.
|
||||
// We can check the transmission channel
|
||||
|
||||
let buf_len = buf.len() as u64;
|
||||
tx.as_mut()
|
||||
.expect("tx only taken on error")
|
||||
.send_data(buf.take().freeze().into())
|
||||
.await
|
||||
.map_err(crate::error::from)?;
|
||||
|
||||
written += buf_len;
|
||||
}
|
||||
}
|
||||
|
||||
impl Sender {
|
||||
// A `Future` that may do blocking read calls.
|
||||
// As a `Future`, this integrates easily with `wait::timeout`.
|
||||
pub(crate) fn send(self) -> impl Future<Output = Result<(), crate::Error>> {
|
||||
send_future(self)
|
||||
}
|
||||
}
|
||||
|
||||
// useful for tests, but not publicly exposed
|
||||
#[cfg(test)]
|
||||
pub(crate) fn read_to_string(mut body: Body) -> io::Result<String> {
|
||||
let mut s = String::new();
|
||||
match body.kind {
|
||||
Kind::Reader(ref mut reader, _) => reader.read_to_string(&mut s),
|
||||
Kind::Bytes(ref mut bytes) => (&**bytes).read_to_string(&mut s),
|
||||
}
|
||||
.map(|_| s)
|
||||
}
|
||||
703
src/blocking/client.rs
Normal file
703
src/blocking/client.rs
Normal file
@@ -0,0 +1,703 @@
|
||||
use std::fmt;
|
||||
use std::future::Future;
|
||||
use std::net::IpAddr;
|
||||
use std::sync::Arc;
|
||||
use std::thread;
|
||||
use std::time::Duration;
|
||||
|
||||
use futures::channel::{mpsc, oneshot};
|
||||
use futures::{StreamExt, TryFutureExt};
|
||||
|
||||
use log::{error, trace};
|
||||
|
||||
use super::request::{Request, RequestBuilder};
|
||||
use super::response::Response;
|
||||
use super::wait;
|
||||
use crate::{async_impl, header, IntoUrl, Method, Proxy, RedirectPolicy};
|
||||
#[cfg(feature = "tls")]
|
||||
use crate::{Certificate, Identity};
|
||||
|
||||
/// A `Client` to make Requests with.
|
||||
///
|
||||
/// The Client has various configuration values to tweak, but the defaults
|
||||
/// are set to what is usually the most commonly desired value. To configure a
|
||||
/// `Client`, use `Client::builder()`.
|
||||
///
|
||||
/// The `Client` holds a connection pool internally, so it is advised that
|
||||
/// you create one and **reuse** it.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```rust
|
||||
/// use reqwest::blocking::Client;
|
||||
/// #
|
||||
/// # fn run() -> Result<(), reqwest::Error> {
|
||||
/// let client = Client::new();
|
||||
/// let resp = client.get("http://httpbin.org/").send()?;
|
||||
/// # drop(resp);
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
///
|
||||
/// ```
|
||||
#[derive(Clone)]
|
||||
pub struct Client {
|
||||
inner: ClientHandle,
|
||||
}
|
||||
|
||||
/// A `ClientBuilder` can be used to create a `Client` with custom configuration.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// # fn run() -> Result<(), reqwest::Error> {
|
||||
/// use std::time::Duration;
|
||||
///
|
||||
/// let client = reqwest::blocking::Client::builder()
|
||||
/// .gzip(true)
|
||||
/// .timeout(Duration::from_secs(10))
|
||||
/// .build()?;
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub struct ClientBuilder {
|
||||
inner: async_impl::ClientBuilder,
|
||||
timeout: Timeout,
|
||||
}
|
||||
|
||||
impl ClientBuilder {
|
||||
/// Constructs a new `ClientBuilder`.
|
||||
///
|
||||
/// This is the same as `Client::builder()`.
|
||||
pub fn new() -> ClientBuilder {
|
||||
ClientBuilder {
|
||||
inner: async_impl::ClientBuilder::new(),
|
||||
timeout: Timeout::default(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns a `Client` that uses this `ClientBuilder` configuration.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This method fails if TLS backend cannot be initialized, or the resolver
|
||||
/// cannot load the system configuration.
|
||||
pub fn build(self) -> crate::Result<Client> {
|
||||
ClientHandle::new(self).map(|handle| Client { inner: handle })
|
||||
}
|
||||
|
||||
/// Disable proxy setting.
|
||||
pub fn no_proxy(self) -> ClientBuilder {
|
||||
self.with_inner(move |inner| inner.no_proxy())
|
||||
}
|
||||
|
||||
/// Enable system proxy setting.
|
||||
pub fn use_sys_proxy(self) -> ClientBuilder {
|
||||
self.with_inner(move |inner| inner.use_sys_proxy())
|
||||
}
|
||||
|
||||
/// Set that all sockets have `SO_NODELAY` set to `true`.
|
||||
pub fn tcp_nodelay(self) -> ClientBuilder {
|
||||
self.with_inner(move |inner| inner.tcp_nodelay())
|
||||
}
|
||||
|
||||
/// Use native TLS backend.
|
||||
#[cfg(feature = "default-tls")]
|
||||
pub fn use_default_tls(self) -> ClientBuilder {
|
||||
self.with_inner(move |inner| inner.use_default_tls())
|
||||
}
|
||||
|
||||
/// Use rustls TLS backend.
|
||||
#[cfg(feature = "rustls-tls")]
|
||||
pub fn use_rustls_tls(self) -> ClientBuilder {
|
||||
self.with_inner(move |inner| inner.use_rustls_tls())
|
||||
}
|
||||
|
||||
/// Add a custom root certificate.
|
||||
///
|
||||
/// This allows connecting to a server that has a self-signed
|
||||
/// certificate for example. This **does not** replace the existing
|
||||
/// trusted store.
|
||||
///
|
||||
/// # Example
|
||||
/// ```
|
||||
/// # use std::fs::File;
|
||||
/// # use std::io::Read;
|
||||
/// # fn build_client() -> Result<(), Box<std::error::Error>> {
|
||||
/// // read a local binary DER encoded certificate
|
||||
/// let mut buf = Vec::new();
|
||||
/// File::open("my-cert.der")?.read_to_end(&mut buf)?;
|
||||
///
|
||||
/// // create a certificate
|
||||
/// let cert = reqwest::Certificate::from_der(&buf)?;
|
||||
///
|
||||
/// // get a client builder
|
||||
/// let client = reqwest::blocking::Client::builder()
|
||||
/// .add_root_certificate(cert)
|
||||
/// .build()?;
|
||||
/// # drop(client);
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This method fails if adding root certificate was unsuccessful.
|
||||
#[cfg(feature = "tls")]
|
||||
pub fn add_root_certificate(self, cert: Certificate) -> ClientBuilder {
|
||||
self.with_inner(move |inner| inner.add_root_certificate(cert))
|
||||
}
|
||||
|
||||
/// Sets the identity to be used for client certificate authentication.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// # use std::fs::File;
|
||||
/// # use std::io::Read;
|
||||
/// # fn build_client() -> Result<(), Box<std::error::Error>> {
|
||||
/// // read a local PKCS12 bundle
|
||||
/// let mut buf = Vec::new();
|
||||
///
|
||||
/// #[cfg(feature = "default-tls")]
|
||||
/// File::open("my-ident.pfx")?.read_to_end(&mut buf)?;
|
||||
/// #[cfg(feature = "rustls-tls")]
|
||||
/// File::open("my-ident.pem")?.read_to_end(&mut buf)?;
|
||||
///
|
||||
/// #[cfg(feature = "default-tls")]
|
||||
/// // create an Identity from the PKCS#12 archive
|
||||
/// let pkcs12 = reqwest::Identity::from_pkcs12_der(&buf, "my-privkey-password")?;
|
||||
/// #[cfg(feature = "rustls-tls")]
|
||||
/// // create an Identity from the PEM file
|
||||
/// let pkcs12 = reqwest::Identity::from_pem(&buf)?;
|
||||
///
|
||||
/// // get a client builder
|
||||
/// let client = reqwest::blocking::Client::builder()
|
||||
/// .identity(pkcs12)
|
||||
/// .build()?;
|
||||
/// # drop(client);
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
#[cfg(feature = "tls")]
|
||||
pub fn identity(self, identity: Identity) -> ClientBuilder {
|
||||
self.with_inner(move |inner| inner.identity(identity))
|
||||
}
|
||||
|
||||
/// Controls the use of hostname verification.
|
||||
///
|
||||
/// Defaults to `false`.
|
||||
///
|
||||
/// # Warning
|
||||
///
|
||||
/// You should think very carefully before you use this method. If
|
||||
/// hostname verification is not used, any valid certificate for any
|
||||
/// site will be trusted for use from any other. This introduces a
|
||||
/// significant vulnerability to man-in-the-middle attacks.
|
||||
#[cfg(feature = "default-tls")]
|
||||
pub fn danger_accept_invalid_hostnames(self, accept_invalid_hostname: bool) -> ClientBuilder {
|
||||
self.with_inner(|inner| inner.danger_accept_invalid_hostnames(accept_invalid_hostname))
|
||||
}
|
||||
|
||||
/// Controls the use of certificate validation.
|
||||
///
|
||||
/// Defaults to `false`.
|
||||
///
|
||||
/// # Warning
|
||||
///
|
||||
/// You should think very carefully before using this method. If
|
||||
/// invalid certificates are trusted, *any* certificate for *any* site
|
||||
/// will be trusted for use. This includes expired certificates. This
|
||||
/// introduces significant vulnerabilities, and should only be used
|
||||
/// as a last resort.
|
||||
#[cfg(feature = "tls")]
|
||||
pub fn danger_accept_invalid_certs(self, accept_invalid_certs: bool) -> ClientBuilder {
|
||||
self.with_inner(|inner| inner.danger_accept_invalid_certs(accept_invalid_certs))
|
||||
}
|
||||
|
||||
/// Sets the default headers for every request.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust
|
||||
/// use reqwest::header;
|
||||
/// # fn build_client() -> Result<(), Box<std::error::Error>> {
|
||||
/// let mut headers = header::HeaderMap::new();
|
||||
/// headers.insert(header::AUTHORIZATION, header::HeaderValue::from_static("secret"));
|
||||
///
|
||||
/// // get a client builder
|
||||
/// let client = reqwest::blocking::Client::builder()
|
||||
/// .default_headers(headers)
|
||||
/// .build()?;
|
||||
/// let res = client.get("https://www.rust-lang.org").send()?;
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// Override the default headers:
|
||||
///
|
||||
/// ```rust
|
||||
/// use reqwest::header;
|
||||
/// # fn build_client() -> Result<(), Box<std::error::Error>> {
|
||||
/// let mut headers = header::HeaderMap::new();
|
||||
/// headers.insert(header::AUTHORIZATION, header::HeaderValue::from_static("secret"));
|
||||
///
|
||||
/// // get a client builder
|
||||
/// let client = reqwest::blocking::Client::builder()
|
||||
/// .default_headers(headers)
|
||||
/// .build()?;
|
||||
/// let res = client
|
||||
/// .get("https://www.rust-lang.org")
|
||||
/// .header(header::AUTHORIZATION, "token")
|
||||
/// .send()?;
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub fn default_headers(self, headers: header::HeaderMap) -> ClientBuilder {
|
||||
self.with_inner(move |inner| inner.default_headers(headers))
|
||||
}
|
||||
|
||||
/// Enable auto gzip decompression by checking the ContentEncoding response header.
|
||||
///
|
||||
/// If auto gzip decompresson is turned on:
|
||||
/// - When sending a request and if the request's headers do not already contain
|
||||
/// an `Accept-Encoding` **and** `Range` values, the `Accept-Encoding` header is set to `gzip`.
|
||||
/// The body is **not** automatically inflated.
|
||||
/// - When receiving a response, if it's headers contain a `Content-Encoding` value that
|
||||
/// equals to `gzip`, both values `Content-Encoding` and `Content-Length` are removed from the
|
||||
/// headers' set. The body is automatically deinflated.
|
||||
///
|
||||
/// Default is enabled.
|
||||
pub fn gzip(self, enable: bool) -> ClientBuilder {
|
||||
self.with_inner(|inner| inner.gzip(enable))
|
||||
}
|
||||
|
||||
/// Add a `Proxy` to the list of proxies the `Client` will use.
|
||||
pub fn proxy(self, proxy: Proxy) -> ClientBuilder {
|
||||
self.with_inner(move |inner| inner.proxy(proxy))
|
||||
}
|
||||
|
||||
/// Set a `RedirectPolicy` for this client.
|
||||
///
|
||||
/// Default will follow redirects up to a maximum of 10.
|
||||
pub fn redirect(self, policy: RedirectPolicy) -> ClientBuilder {
|
||||
self.with_inner(move |inner| inner.redirect(policy))
|
||||
}
|
||||
|
||||
/// Enable or disable automatic setting of the `Referer` header.
|
||||
///
|
||||
/// Default is `true`.
|
||||
pub fn referer(self, enable: bool) -> ClientBuilder {
|
||||
self.with_inner(|inner| inner.referer(enable))
|
||||
}
|
||||
|
||||
/// Set a timeout for connect, read and write operations of a `Client`.
|
||||
///
|
||||
/// Default is 30 seconds.
|
||||
///
|
||||
/// Pass `None` to disable timeout.
|
||||
pub fn timeout<T>(mut self, timeout: T) -> ClientBuilder
|
||||
where
|
||||
T: Into<Option<Duration>>,
|
||||
{
|
||||
self.timeout = Timeout(timeout.into());
|
||||
self
|
||||
}
|
||||
|
||||
/// Sets the maximum idle connection per host allowed in the pool.
|
||||
///
|
||||
/// Default is usize::MAX (no limit).
|
||||
pub fn max_idle_per_host(self, max: usize) -> ClientBuilder {
|
||||
self.with_inner(move |inner| inner.max_idle_per_host(max))
|
||||
}
|
||||
|
||||
/// Set a timeout for only the connect phase of a `Client`.
|
||||
///
|
||||
/// Default is `None`.
|
||||
pub fn connect_timeout<T>(self, timeout: T) -> ClientBuilder
|
||||
where
|
||||
T: Into<Option<Duration>>,
|
||||
{
|
||||
let timeout = timeout.into();
|
||||
if let Some(dur) = timeout {
|
||||
self.with_inner(|inner| inner.connect_timeout(dur))
|
||||
} else {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
fn with_inner<F>(mut self, func: F) -> ClientBuilder
|
||||
where
|
||||
F: FnOnce(async_impl::ClientBuilder) -> async_impl::ClientBuilder,
|
||||
{
|
||||
self.inner = func(self.inner);
|
||||
self
|
||||
}
|
||||
|
||||
/// Only use HTTP/2.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// let client = reqwest::blocking::Client::builder()
|
||||
/// .h2_prior_knowledge()
|
||||
/// .build().unwrap();
|
||||
/// ```
|
||||
pub fn h2_prior_knowledge(self) -> ClientBuilder {
|
||||
self.with_inner(|inner| inner.h2_prior_knowledge())
|
||||
}
|
||||
|
||||
/// Enable case sensitive headers.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// let client = reqwest::blocking::Client::builder()
|
||||
/// .http1_title_case_headers()
|
||||
/// .build().unwrap();
|
||||
/// ```
|
||||
pub fn http1_title_case_headers(self) -> ClientBuilder {
|
||||
self.with_inner(|inner| inner.http1_title_case_headers())
|
||||
}
|
||||
|
||||
/// Bind to a local IP Address
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// use std::net::IpAddr;
|
||||
/// let local_addr = IpAddr::from([12, 4, 1, 8]);
|
||||
/// let client = reqwest::blocking::Client::builder()
|
||||
/// .local_address(local_addr)
|
||||
/// .build().unwrap();
|
||||
/// ```
|
||||
pub fn local_address<T>(self, addr: T) -> ClientBuilder
|
||||
where
|
||||
T: Into<Option<IpAddr>>,
|
||||
{
|
||||
self.with_inner(move |inner| inner.local_address(addr))
|
||||
}
|
||||
|
||||
/// Enable a persistent cookie store for the client.
|
||||
///
|
||||
/// Cookies received in responses will be preserved and included in
|
||||
/// additional requests.
|
||||
///
|
||||
/// By default, no cookie store is used.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// let client = reqwest::blocking::Client::builder()
|
||||
/// .cookie_store(true)
|
||||
/// .build()
|
||||
/// .unwrap();
|
||||
/// ```
|
||||
pub fn cookie_store(self, enable: bool) -> ClientBuilder {
|
||||
self.with_inner(|inner| inner.cookie_store(enable))
|
||||
}
|
||||
}
|
||||
|
||||
impl Client {
|
||||
/// Constructs a new `Client`.
|
||||
///
|
||||
/// # Panic
|
||||
///
|
||||
/// This method panics if TLS backend cannot initialized, or the resolver
|
||||
/// cannot load the system configuration.
|
||||
///
|
||||
/// Use `Client::builder()` if you wish to handle the failure as an `Error`
|
||||
/// instead of panicking.
|
||||
pub fn new() -> Client {
|
||||
ClientBuilder::new().build().expect("Client::new()")
|
||||
}
|
||||
|
||||
/// Creates a `ClientBuilder` to configure a `Client`.
|
||||
///
|
||||
/// This is the same as `ClientBuilder::new()`.
|
||||
pub fn builder() -> ClientBuilder {
|
||||
ClientBuilder::new()
|
||||
}
|
||||
|
||||
/// Convenience method to make a `GET` request to a URL.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This method fails whenever supplied `Url` cannot be parsed.
|
||||
pub fn get<U: IntoUrl>(&self, url: U) -> RequestBuilder {
|
||||
self.request(Method::GET, url)
|
||||
}
|
||||
|
||||
/// Convenience method to make a `POST` request to a URL.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This method fails whenever supplied `Url` cannot be parsed.
|
||||
pub fn post<U: IntoUrl>(&self, url: U) -> RequestBuilder {
|
||||
self.request(Method::POST, url)
|
||||
}
|
||||
|
||||
/// Convenience method to make a `PUT` request to a URL.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This method fails whenever supplied `Url` cannot be parsed.
|
||||
pub fn put<U: IntoUrl>(&self, url: U) -> RequestBuilder {
|
||||
self.request(Method::PUT, url)
|
||||
}
|
||||
|
||||
/// Convenience method to make a `PATCH` request to a URL.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This method fails whenever supplied `Url` cannot be parsed.
|
||||
pub fn patch<U: IntoUrl>(&self, url: U) -> RequestBuilder {
|
||||
self.request(Method::PATCH, url)
|
||||
}
|
||||
|
||||
/// Convenience method to make a `DELETE` request to a URL.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This method fails whenever supplied `Url` cannot be parsed.
|
||||
pub fn delete<U: IntoUrl>(&self, url: U) -> RequestBuilder {
|
||||
self.request(Method::DELETE, url)
|
||||
}
|
||||
|
||||
/// Convenience method to make a `HEAD` request to a URL.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This method fails whenever supplied `Url` cannot be parsed.
|
||||
pub fn head<U: IntoUrl>(&self, url: U) -> RequestBuilder {
|
||||
self.request(Method::HEAD, url)
|
||||
}
|
||||
|
||||
/// Start building a `Request` with the `Method` and `Url`.
|
||||
///
|
||||
/// Returns a `RequestBuilder`, which will allow setting headers and
|
||||
/// request body before sending.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This method fails whenever supplied `Url` cannot be parsed.
|
||||
pub fn request<U: IntoUrl>(&self, method: Method, url: U) -> RequestBuilder {
|
||||
let req = url.into_url().map(move |url| Request::new(method, url));
|
||||
RequestBuilder::new(self.clone(), req)
|
||||
}
|
||||
|
||||
/// Executes a `Request`.
|
||||
///
|
||||
/// A `Request` can be built manually with `Request::new()` or obtained
|
||||
/// from a RequestBuilder with `RequestBuilder::build()`.
|
||||
///
|
||||
/// You should prefer to use the `RequestBuilder` and
|
||||
/// `RequestBuilder::send()`.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This method fails if there was an error while sending request,
|
||||
/// redirect loop was detected or redirect limit was exhausted.
|
||||
pub fn execute(&self, request: Request) -> crate::Result<Response> {
|
||||
self.inner.execute_request(request)
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Debug for Client {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
f.debug_struct("Client")
|
||||
//.field("gzip", &self.inner.gzip)
|
||||
//.field("redirect_policy", &self.inner.redirect_policy)
|
||||
//.field("referer", &self.inner.referer)
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Debug for ClientBuilder {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
f.debug_struct("ClientBuilder").finish()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct ClientHandle {
|
||||
timeout: Timeout,
|
||||
inner: Arc<InnerClientHandle>,
|
||||
}
|
||||
|
||||
type OneshotResponse = oneshot::Sender<crate::Result<async_impl::Response>>;
|
||||
type ThreadSender = mpsc::UnboundedSender<(async_impl::Request, OneshotResponse)>;
|
||||
|
||||
struct InnerClientHandle {
|
||||
tx: Option<ThreadSender>,
|
||||
thread: Option<thread::JoinHandle<()>>,
|
||||
}
|
||||
|
||||
impl Drop for InnerClientHandle {
|
||||
fn drop(&mut self) {
|
||||
self.tx.take();
|
||||
self.thread.take().map(|h| h.join());
|
||||
}
|
||||
}
|
||||
|
||||
impl ClientHandle {
|
||||
fn new(builder: ClientBuilder) -> crate::Result<ClientHandle> {
|
||||
let timeout = builder.timeout;
|
||||
let builder = builder.inner;
|
||||
let (tx, rx) = mpsc::unbounded::<(async_impl::Request, OneshotResponse)>();
|
||||
let (spawn_tx, spawn_rx) = oneshot::channel::<crate::Result<()>>();
|
||||
let handle = thread::Builder::new()
|
||||
.name("reqwest-internal-sync-runtime".into())
|
||||
.spawn(move || {
|
||||
use tokio::runtime::current_thread::Runtime;
|
||||
|
||||
let mut rt = match Runtime::new().map_err(crate::error::from) {
|
||||
Err(e) => {
|
||||
if let Err(e) = spawn_tx.send(Err(e)) {
|
||||
error!("Failed to communicate runtime creation failure: {:?}", e);
|
||||
}
|
||||
return;
|
||||
}
|
||||
Ok(v) => v,
|
||||
};
|
||||
|
||||
let f = async move {
|
||||
let client = match builder.build() {
|
||||
Err(e) => {
|
||||
if let Err(e) = spawn_tx.send(Err(e)) {
|
||||
error!("Failed to communicate client creation failure: {:?}", e);
|
||||
}
|
||||
return;
|
||||
}
|
||||
Ok(v) => v,
|
||||
};
|
||||
if let Err(e) = spawn_tx.send(Ok(())) {
|
||||
error!("Failed to communicate successful startup: {:?}", e);
|
||||
return;
|
||||
}
|
||||
|
||||
let mut rx = rx;
|
||||
|
||||
while let Some((req, req_tx)) = rx.next().await {
|
||||
let req_fut = client.execute(req);
|
||||
tokio::spawn(forward(req_fut, req_tx));
|
||||
}
|
||||
|
||||
trace!("Receiver is shutdown");
|
||||
};
|
||||
|
||||
rt.block_on(f)
|
||||
})
|
||||
.map_err(crate::error::from)?;
|
||||
|
||||
// Wait for the runtime thread to start up...
|
||||
match wait::timeout(spawn_rx, None) {
|
||||
Ok(Ok(())) => (),
|
||||
Ok(Err(err)) => return Err(err),
|
||||
Err(_canceled) => event_loop_panicked(),
|
||||
}
|
||||
|
||||
let inner_handle = Arc::new(InnerClientHandle {
|
||||
tx: Some(tx),
|
||||
thread: Some(handle),
|
||||
});
|
||||
|
||||
Ok(ClientHandle {
|
||||
timeout,
|
||||
inner: inner_handle,
|
||||
})
|
||||
}
|
||||
|
||||
fn execute_request(&self, req: Request) -> crate::Result<Response> {
|
||||
let (tx, rx) = oneshot::channel();
|
||||
let (req, body) = req.into_async();
|
||||
let url = req.url().clone();
|
||||
self.inner
|
||||
.tx
|
||||
.as_ref()
|
||||
.expect("core thread exited early")
|
||||
.unbounded_send((req, tx))
|
||||
.expect("core thread panicked");
|
||||
|
||||
let result: Result<crate::Result<async_impl::Response>, wait::Waited<crate::Error>> =
|
||||
if let Some(body) = body {
|
||||
let f = async move {
|
||||
body.send().await?;
|
||||
rx.await.map_err(|_canceled| event_loop_panicked())
|
||||
};
|
||||
wait::timeout(f, self.timeout.0)
|
||||
} else {
|
||||
wait::timeout(
|
||||
rx.map_err(|_canceled| event_loop_panicked()),
|
||||
self.timeout.0,
|
||||
)
|
||||
};
|
||||
|
||||
match result {
|
||||
Ok(Err(err)) => Err(err.with_url(url)),
|
||||
Ok(Ok(res)) => Ok(Response::new(
|
||||
res,
|
||||
self.timeout.0,
|
||||
KeepCoreThreadAlive(Some(self.inner.clone())),
|
||||
)),
|
||||
Err(wait::Waited::TimedOut) => Err(crate::error::timedout(Some(url))),
|
||||
Err(wait::Waited::Executor(err)) => Err(crate::error::from(err).with_url(url)),
|
||||
Err(wait::Waited::Inner(err)) => Err(err.with_url(url)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn forward<F>(fut: F, mut tx: OneshotResponse)
|
||||
where
|
||||
F: Future<Output = crate::Result<async_impl::Response>>,
|
||||
{
|
||||
use std::task::Poll;
|
||||
|
||||
futures::pin_mut!(fut);
|
||||
|
||||
// "select" on the sender being canceled, and the future completing
|
||||
let res = futures::future::poll_fn(|cx| {
|
||||
match fut.as_mut().poll(cx) {
|
||||
Poll::Ready(val) => Poll::Ready(Some(val)),
|
||||
Poll::Pending => {
|
||||
// check if the callback is canceled
|
||||
futures::ready!(tx.poll_cancel(cx));
|
||||
Poll::Ready(None)
|
||||
}
|
||||
}
|
||||
})
|
||||
.await;
|
||||
|
||||
if let Some(res) = res {
|
||||
let _ = tx.send(res);
|
||||
}
|
||||
// else request is canceled
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
struct Timeout(Option<Duration>);
|
||||
|
||||
impl Default for Timeout {
|
||||
fn default() -> Timeout {
|
||||
// default mentioned in ClientBuilder::timeout() doc comment
|
||||
Timeout(Some(Duration::from_secs(30)))
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) struct KeepCoreThreadAlive(Option<Arc<InnerClientHandle>>);
|
||||
|
||||
impl KeepCoreThreadAlive {
|
||||
pub(crate) fn empty() -> KeepCoreThreadAlive {
|
||||
KeepCoreThreadAlive(None)
|
||||
}
|
||||
}
|
||||
|
||||
#[cold]
|
||||
#[inline(never)]
|
||||
fn event_loop_panicked() -> ! {
|
||||
// The only possible reason there would be a Canceled error
|
||||
// is if the thread running the event loop panicked. We could return
|
||||
// an Err here, like a BrokenPipe, but the Client is not
|
||||
// recoverable. Additionally, the panic in the other thread
|
||||
// is not normal, and should likely be propagated.
|
||||
panic!("event loop thread panicked");
|
||||
}
|
||||
98
src/blocking/mod.rs
Normal file
98
src/blocking/mod.rs
Normal file
@@ -0,0 +1,98 @@
|
||||
//! A blocking Client API.
|
||||
//!
|
||||
//! The blocking `Client` will block the current thread to execute, instead
|
||||
//! of returning futures that need to be executed on a runtime.
|
||||
//!
|
||||
//! ## Making a GET request
|
||||
//!
|
||||
//! For a single request, you can use the [`get`](get) shortcut method.
|
||||
//!
|
||||
//! ```rust
|
||||
//! # use reqwest::{Error, Response};
|
||||
//!
|
||||
//! # fn run() -> Result<(), Error> {
|
||||
//! let body = reqwest::blocking::get("https://www.rust-lang.org")?
|
||||
//! .text()?;
|
||||
//!
|
||||
//! println!("body = {:?}", body);
|
||||
//! # Ok(())
|
||||
//! # }
|
||||
//! ```
|
||||
//!
|
||||
//! Additionally, the blocking [`Response`](Response) struct implements Rust's
|
||||
//! `Read` trait, so many useful standard library and third party crates will
|
||||
//! have convenience methods that take a `Response` anywhere `T: Read` is
|
||||
//! acceptable.
|
||||
//!
|
||||
//! **NOTE**: If you plan to perform multiple requests, it is best to create a
|
||||
//! [`Client`](Client) and reuse it, taking advantage of keep-alive connection
|
||||
//! pooling.
|
||||
//!
|
||||
//! ## Making POST requests (or setting request bodies)
|
||||
//!
|
||||
//! There are several ways you can set the body of a request. The basic one is
|
||||
//! by using the `body()` method of a [`RequestBuilder`](RequestBuilder). This lets you set the
|
||||
//! exact raw bytes of what the body should be. It accepts various types,
|
||||
//! including `String`, `Vec<u8>`, and `File`. If you wish to pass a custom
|
||||
//! Reader, you can use the `reqwest::blocking::Body::new()` constructor.
|
||||
//!
|
||||
//! ```rust
|
||||
//! # use reqwest::Error;
|
||||
//! #
|
||||
//! # fn run() -> Result<(), Error> {
|
||||
//! let client = reqwest::blocking::Client::new();
|
||||
//! let res = client.post("http://httpbin.org/post")
|
||||
//! .body("the exact body that is sent")
|
||||
//! .send()?;
|
||||
//! # Ok(())
|
||||
//! # }
|
||||
//! ```
|
||||
//!
|
||||
//! ## And More
|
||||
//!
|
||||
//! Most features available to the asynchronous `Client` are also available,
|
||||
//! on the blocking `Client`, see those docs for more.
|
||||
|
||||
mod body;
|
||||
mod client;
|
||||
pub mod multipart;
|
||||
mod request;
|
||||
mod response;
|
||||
mod wait;
|
||||
|
||||
pub(crate) use self::wait::Waited;
|
||||
|
||||
pub use self::body::Body;
|
||||
pub use self::client::{Client, ClientBuilder};
|
||||
pub use self::request::{Request, RequestBuilder};
|
||||
pub use self::response::Response;
|
||||
|
||||
/// Shortcut method to quickly make a *blocking* `GET` request.
|
||||
///
|
||||
/// **NOTE**: This function creates a new internal `Client` on each call,
|
||||
/// and so should not be used if making many requests. Create a
|
||||
/// [`Client`](./struct.Client.html) instead.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```rust
|
||||
/// # fn run() -> Result<(), reqwest::Error> {
|
||||
/// let body = reqwest::blocking::get("https://www.rust-lang.org")?
|
||||
/// .text()?;
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// # fn main() { }
|
||||
/// ```
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function fails if:
|
||||
///
|
||||
/// - native TLS backend cannot be initialized
|
||||
/// - supplied `Url` cannot be parsed
|
||||
/// - there was an error while sending request
|
||||
/// - redirect loop was detected
|
||||
/// - redirect limit was exhausted
|
||||
pub fn get<T: crate::IntoUrl>(url: T) -> crate::Result<Response> {
|
||||
Client::builder().build()?.get(url).send()
|
||||
}
|
||||
471
src/blocking/multipart.rs
Normal file
471
src/blocking/multipart.rs
Normal file
@@ -0,0 +1,471 @@
|
||||
//! multipart/form-data
|
||||
//!
|
||||
//! To send a `multipart/form-data` body, a [`Form`](crate::multipart::Form) is built up, adding
|
||||
//! fields or customized [`Part`](crate::multipart::Part)s, and then calling the
|
||||
//! [`multipart`][builder] method on the `RequestBuilder`.
|
||||
//!
|
||||
//! # Example
|
||||
//!
|
||||
//! ```
|
||||
//! use reqwest::blocking::multipart;
|
||||
//!
|
||||
//! # fn run() -> Result<(), Box<dyn std::error::Error>> {
|
||||
//! let form = multipart::Form::new()
|
||||
//! // Adding just a simple text field...
|
||||
//! .text("username", "seanmonstar")
|
||||
//! // And a file...
|
||||
//! .file("photo", "/path/to/photo.png")?;
|
||||
//!
|
||||
//! // Customize all the details of a Part if needed...
|
||||
//! let bio = multipart::Part::text("hallo peeps")
|
||||
//! .file_name("bio.txt")
|
||||
//! .mime_str("text/plain")?;
|
||||
//!
|
||||
//! // Add the custom part to our form...
|
||||
//! let form = form.part("biography", bio);
|
||||
//!
|
||||
//! // And finally, send the form
|
||||
//! let client = reqwest::blocking::Client::new();
|
||||
//! let resp = client
|
||||
//! .post("http://localhost:8080/user")
|
||||
//! .multipart(form)
|
||||
//! .send()?;
|
||||
//! # Ok(())
|
||||
//! # }
|
||||
//! # fn main() {}
|
||||
//! ```
|
||||
//!
|
||||
//! [builder]: ../struct.RequestBuilder.html#method.multipart
|
||||
use std::borrow::Cow;
|
||||
use std::fmt;
|
||||
use std::fs::File;
|
||||
use std::io::{self, Cursor, Read};
|
||||
use std::path::Path;
|
||||
|
||||
use mime_guess::{self, Mime};
|
||||
|
||||
use super::Body;
|
||||
use crate::async_impl::multipart::{FormParts, PartMetadata, PartProps};
|
||||
|
||||
/// A multipart/form-data request.
|
||||
pub struct Form {
|
||||
inner: FormParts<Part>,
|
||||
}
|
||||
|
||||
/// A field in a multipart form.
|
||||
pub struct Part {
|
||||
meta: PartMetadata,
|
||||
value: Body,
|
||||
}
|
||||
|
||||
impl Form {
|
||||
/// Creates a new Form without any content.
|
||||
pub fn new() -> Form {
|
||||
Form {
|
||||
inner: FormParts::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the boundary that this form will use.
|
||||
#[inline]
|
||||
pub fn boundary(&self) -> &str {
|
||||
self.inner.boundary()
|
||||
}
|
||||
|
||||
/// Add a data field with supplied name and value.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// let form = reqwest::blocking::multipart::Form::new()
|
||||
/// .text("username", "seanmonstar")
|
||||
/// .text("password", "secret");
|
||||
/// ```
|
||||
pub fn text<T, U>(self, name: T, value: U) -> Form
|
||||
where
|
||||
T: Into<Cow<'static, str>>,
|
||||
U: Into<Cow<'static, str>>,
|
||||
{
|
||||
self.part(name, Part::text(value))
|
||||
}
|
||||
|
||||
/// Adds a file field.
|
||||
///
|
||||
/// The path will be used to try to guess the filename and mime.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn run() -> std::io::Result<()> {
|
||||
/// let files = reqwest::blocking::multipart::Form::new()
|
||||
/// .file("key", "/path/to/file")?;
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// Errors when the file cannot be opened.
|
||||
pub fn file<T, U>(self, name: T, path: U) -> io::Result<Form>
|
||||
where
|
||||
T: Into<Cow<'static, str>>,
|
||||
U: AsRef<Path>,
|
||||
{
|
||||
Ok(self.part(name, Part::file(path)?))
|
||||
}
|
||||
|
||||
/// Adds a customized Part.
|
||||
pub fn part<T>(self, name: T, part: Part) -> Form
|
||||
where
|
||||
T: Into<Cow<'static, str>>,
|
||||
{
|
||||
self.with_inner(move |inner| inner.part(name, part))
|
||||
}
|
||||
|
||||
/// Configure this `Form` to percent-encode using the `path-segment` rules.
|
||||
pub fn percent_encode_path_segment(self) -> Form {
|
||||
self.with_inner(|inner| inner.percent_encode_path_segment())
|
||||
}
|
||||
|
||||
/// Configure this `Form` to percent-encode using the `attr-char` rules.
|
||||
pub fn percent_encode_attr_chars(self) -> Form {
|
||||
self.with_inner(|inner| inner.percent_encode_attr_chars())
|
||||
}
|
||||
|
||||
/// Configure this `Form` to skip percent-encoding
|
||||
pub fn percent_encode_noop(self) -> Form {
|
||||
self.with_inner(|inner| inner.percent_encode_noop())
|
||||
}
|
||||
|
||||
pub(crate) fn reader(self) -> Reader {
|
||||
Reader::new(self)
|
||||
}
|
||||
|
||||
// If predictable, computes the length the request will have
|
||||
// The length should be preditable if only String and file fields have been added,
|
||||
// but not if a generic reader has been added;
|
||||
pub(crate) fn compute_length(&mut self) -> Option<u64> {
|
||||
self.inner.compute_length()
|
||||
}
|
||||
|
||||
fn with_inner<F>(self, func: F) -> Self
|
||||
where
|
||||
F: FnOnce(FormParts<Part>) -> FormParts<Part>,
|
||||
{
|
||||
Form {
|
||||
inner: func(self.inner),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Debug for Form {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
self.inner.fmt_fields("Form", f)
|
||||
}
|
||||
}
|
||||
|
||||
impl Part {
|
||||
/// Makes a text parameter.
|
||||
pub fn text<T>(value: T) -> Part
|
||||
where
|
||||
T: Into<Cow<'static, str>>,
|
||||
{
|
||||
let body = match value.into() {
|
||||
Cow::Borrowed(slice) => Body::from(slice),
|
||||
Cow::Owned(string) => Body::from(string),
|
||||
};
|
||||
Part::new(body)
|
||||
}
|
||||
|
||||
/// Makes a new parameter from arbitrary bytes.
|
||||
pub fn bytes<T>(value: T) -> Part
|
||||
where
|
||||
T: Into<Cow<'static, [u8]>>,
|
||||
{
|
||||
let body = match value.into() {
|
||||
Cow::Borrowed(slice) => Body::from(slice),
|
||||
Cow::Owned(vec) => Body::from(vec),
|
||||
};
|
||||
Part::new(body)
|
||||
}
|
||||
|
||||
/// Adds a generic reader.
|
||||
///
|
||||
/// Does not set filename or mime.
|
||||
pub fn reader<T: Read + Send + 'static>(value: T) -> Part {
|
||||
Part::new(Body::new(value))
|
||||
}
|
||||
|
||||
/// Adds a generic reader with known length.
|
||||
///
|
||||
/// Does not set filename or mime.
|
||||
pub fn reader_with_length<T: Read + Send + 'static>(value: T, length: u64) -> Part {
|
||||
Part::new(Body::sized(value, length))
|
||||
}
|
||||
|
||||
/// Makes a file parameter.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// Errors when the file cannot be opened.
|
||||
pub fn file<T: AsRef<Path>>(path: T) -> io::Result<Part> {
|
||||
let path = path.as_ref();
|
||||
let file_name = path
|
||||
.file_name()
|
||||
.map(|filename| filename.to_string_lossy().into_owned());
|
||||
let ext = path.extension().and_then(|ext| ext.to_str()).unwrap_or("");
|
||||
let mime = mime_guess::from_ext(ext).first_or_octet_stream();
|
||||
let file = File::open(path)?;
|
||||
let field = Part::new(Body::from(file)).mime(mime);
|
||||
|
||||
Ok(if let Some(file_name) = file_name {
|
||||
field.file_name(file_name)
|
||||
} else {
|
||||
field
|
||||
})
|
||||
}
|
||||
|
||||
fn new(value: Body) -> Part {
|
||||
Part {
|
||||
meta: PartMetadata::new(),
|
||||
value,
|
||||
}
|
||||
}
|
||||
|
||||
/// Tries to set the mime of this part.
|
||||
pub fn mime_str(self, mime: &str) -> crate::Result<Part> {
|
||||
Ok(self.mime(mime.parse().map_err(crate::error::from)?))
|
||||
}
|
||||
|
||||
// Re-export when mime 0.4 is available, with split MediaType/MediaRange.
|
||||
fn mime(self, mime: Mime) -> Part {
|
||||
self.with_inner(move |inner| inner.mime(mime))
|
||||
}
|
||||
|
||||
/// Sets the filename, builder style.
|
||||
pub fn file_name<T>(self, filename: T) -> Part
|
||||
where
|
||||
T: Into<Cow<'static, str>>,
|
||||
{
|
||||
self.with_inner(move |inner| inner.file_name(filename))
|
||||
}
|
||||
|
||||
fn with_inner<F>(self, func: F) -> Self
|
||||
where
|
||||
F: FnOnce(PartMetadata) -> PartMetadata,
|
||||
{
|
||||
Part {
|
||||
meta: func(self.meta),
|
||||
value: self.value,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Debug for Part {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
let mut dbg = f.debug_struct("Part");
|
||||
dbg.field("value", &self.value);
|
||||
self.meta.fmt_fields(&mut dbg);
|
||||
dbg.finish()
|
||||
}
|
||||
}
|
||||
|
||||
impl PartProps for Part {
|
||||
fn value_len(&self) -> Option<u64> {
|
||||
self.value.len()
|
||||
}
|
||||
|
||||
fn metadata(&self) -> &PartMetadata {
|
||||
&self.meta
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) struct Reader {
|
||||
form: Form,
|
||||
active_reader: Option<Box<dyn Read + Send>>,
|
||||
}
|
||||
|
||||
impl fmt::Debug for Reader {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
f.debug_struct("Reader").field("form", &self.form).finish()
|
||||
}
|
||||
}
|
||||
|
||||
impl Reader {
|
||||
fn new(form: Form) -> Reader {
|
||||
let mut reader = Reader {
|
||||
form,
|
||||
active_reader: None,
|
||||
};
|
||||
reader.next_reader();
|
||||
reader
|
||||
}
|
||||
|
||||
fn next_reader(&mut self) {
|
||||
self.active_reader = if !self.form.inner.fields.is_empty() {
|
||||
// We need to move out of the vector here because we are consuming the field's reader
|
||||
let (name, field) = self.form.inner.fields.remove(0);
|
||||
let boundary = Cursor::new(format!("--{}\r\n", self.form.boundary()));
|
||||
let header = Cursor::new({
|
||||
// Try to use cached headers created by compute_length
|
||||
let mut h = if !self.form.inner.computed_headers.is_empty() {
|
||||
self.form.inner.computed_headers.remove(0)
|
||||
} else {
|
||||
self.form
|
||||
.inner
|
||||
.percent_encoding
|
||||
.encode_headers(&name, field.metadata())
|
||||
};
|
||||
h.extend_from_slice(b"\r\n\r\n");
|
||||
h
|
||||
});
|
||||
let reader = boundary
|
||||
.chain(header)
|
||||
.chain(field.value.into_reader())
|
||||
.chain(Cursor::new("\r\n"));
|
||||
// According to https://tools.ietf.org/html/rfc2046#section-5.1.1
|
||||
// the very last field has a special boundary
|
||||
if !self.form.inner.fields.is_empty() {
|
||||
Some(Box::new(reader))
|
||||
} else {
|
||||
Some(Box::new(reader.chain(Cursor::new(format!(
|
||||
"--{}--\r\n",
|
||||
self.form.boundary()
|
||||
)))))
|
||||
}
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Read for Reader {
|
||||
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
||||
let mut total_bytes_read = 0usize;
|
||||
let mut last_read_bytes;
|
||||
loop {
|
||||
match self.active_reader {
|
||||
Some(ref mut reader) => {
|
||||
last_read_bytes = reader.read(&mut buf[total_bytes_read..])?;
|
||||
total_bytes_read += last_read_bytes;
|
||||
if total_bytes_read == buf.len() {
|
||||
return Ok(total_bytes_read);
|
||||
}
|
||||
}
|
||||
None => return Ok(total_bytes_read),
|
||||
};
|
||||
if last_read_bytes == 0 && !buf.is_empty() {
|
||||
self.next_reader();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn form_empty() {
|
||||
let mut output = Vec::new();
|
||||
let mut form = Form::new();
|
||||
let length = form.compute_length();
|
||||
form.reader().read_to_end(&mut output).unwrap();
|
||||
assert_eq!(output, b"");
|
||||
assert_eq!(length.unwrap(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_to_end() {
|
||||
let mut output = Vec::new();
|
||||
let mut form = Form::new()
|
||||
.part("reader1", Part::reader(std::io::empty()))
|
||||
.part("key1", Part::text("value1"))
|
||||
.part("key2", Part::text("value2").mime(mime::IMAGE_BMP))
|
||||
.part("reader2", Part::reader(std::io::empty()))
|
||||
.part("key3", Part::text("value3").file_name("filename"));
|
||||
form.inner.boundary = "boundary".to_string();
|
||||
let length = form.compute_length();
|
||||
let expected =
|
||||
"--boundary\r\n\
|
||||
Content-Disposition: form-data; name=\"reader1\"\r\n\r\n\
|
||||
\r\n\
|
||||
--boundary\r\n\
|
||||
Content-Disposition: form-data; name=\"key1\"\r\n\r\n\
|
||||
value1\r\n\
|
||||
--boundary\r\n\
|
||||
Content-Disposition: form-data; name=\"key2\"\r\n\
|
||||
Content-Type: image/bmp\r\n\r\n\
|
||||
value2\r\n\
|
||||
--boundary\r\n\
|
||||
Content-Disposition: form-data; name=\"reader2\"\r\n\r\n\
|
||||
\r\n\
|
||||
--boundary\r\n\
|
||||
Content-Disposition: form-data; name=\"key3\"; filename=\"filename\"\r\n\r\n\
|
||||
value3\r\n--boundary--\r\n";
|
||||
form.reader().read_to_end(&mut output).unwrap();
|
||||
// These prints are for debug purposes in case the test fails
|
||||
println!(
|
||||
"START REAL\n{}\nEND REAL",
|
||||
std::str::from_utf8(&output).unwrap()
|
||||
);
|
||||
println!("START EXPECTED\n{}\nEND EXPECTED", expected);
|
||||
assert_eq!(std::str::from_utf8(&output).unwrap(), expected);
|
||||
assert!(length.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_to_end_with_length() {
|
||||
let mut output = Vec::new();
|
||||
let mut form = Form::new()
|
||||
.text("key1", "value1")
|
||||
.part("key2", Part::text("value2").mime(mime::IMAGE_BMP))
|
||||
.part("key3", Part::text("value3").file_name("filename"));
|
||||
form.inner.boundary = "boundary".to_string();
|
||||
let length = form.compute_length();
|
||||
let expected =
|
||||
"--boundary\r\n\
|
||||
Content-Disposition: form-data; name=\"key1\"\r\n\r\n\
|
||||
value1\r\n\
|
||||
--boundary\r\n\
|
||||
Content-Disposition: form-data; name=\"key2\"\r\n\
|
||||
Content-Type: image/bmp\r\n\r\n\
|
||||
value2\r\n\
|
||||
--boundary\r\n\
|
||||
Content-Disposition: form-data; name=\"key3\"; filename=\"filename\"\r\n\r\n\
|
||||
value3\r\n--boundary--\r\n";
|
||||
form.reader().read_to_end(&mut output).unwrap();
|
||||
// These prints are for debug purposes in case the test fails
|
||||
println!(
|
||||
"START REAL\n{}\nEND REAL",
|
||||
std::str::from_utf8(&output).unwrap()
|
||||
);
|
||||
println!("START EXPECTED\n{}\nEND EXPECTED", expected);
|
||||
assert_eq!(std::str::from_utf8(&output).unwrap(), expected);
|
||||
assert_eq!(length.unwrap(), expected.len() as u64);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_to_end_with_header() {
|
||||
let mut output = Vec::new();
|
||||
let mut part = Part::text("value2").mime(mime::IMAGE_BMP);
|
||||
part.meta.headers.insert("Hdr3", "/a/b/c".parse().unwrap());
|
||||
let mut form = Form::new().part("key2", part);
|
||||
form.inner.boundary = "boundary".to_string();
|
||||
let expected = "--boundary\r\n\
|
||||
Content-Disposition: form-data; name=\"key2\"\r\n\
|
||||
Content-Type: image/bmp\r\n\
|
||||
hdr3: /a/b/c\r\n\
|
||||
\r\n\
|
||||
value2\r\n\
|
||||
--boundary--\r\n";
|
||||
form.reader().read_to_end(&mut output).unwrap();
|
||||
// These prints are for debug purposes in case the test fails
|
||||
println!(
|
||||
"START REAL\n{}\nEND REAL",
|
||||
std::str::from_utf8(&output).unwrap()
|
||||
);
|
||||
println!("START EXPECTED\n{}\nEND EXPECTED", expected);
|
||||
assert_eq!(std::str::from_utf8(&output).unwrap(), expected);
|
||||
}
|
||||
}
|
||||
859
src/blocking/request.rs
Normal file
859
src/blocking/request.rs
Normal file
@@ -0,0 +1,859 @@
|
||||
use std::fmt;
|
||||
|
||||
use base64::encode;
|
||||
use http::HttpTryFrom;
|
||||
use serde::Serialize;
|
||||
use serde_json;
|
||||
use serde_urlencoded;
|
||||
|
||||
use super::body::{self, Body};
|
||||
use super::multipart;
|
||||
use super::Client;
|
||||
use crate::header::{HeaderMap, HeaderName, HeaderValue, CONTENT_TYPE};
|
||||
use crate::{async_impl, Method, Url};
|
||||
|
||||
/// A request which can be executed with `Client::execute()`.
|
||||
pub struct Request {
|
||||
body: Option<Body>,
|
||||
inner: async_impl::Request,
|
||||
}
|
||||
|
||||
/// A builder to construct the properties of a `Request`.
|
||||
#[derive(Debug)]
|
||||
pub struct RequestBuilder {
|
||||
client: Client,
|
||||
request: crate::Result<Request>,
|
||||
}
|
||||
|
||||
impl Request {
|
||||
/// Constructs a new request.
|
||||
#[inline]
|
||||
pub fn new(method: Method, url: Url) -> Self {
|
||||
Request {
|
||||
body: None,
|
||||
inner: async_impl::Request::new(method, url),
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the method.
|
||||
#[inline]
|
||||
pub fn method(&self) -> &Method {
|
||||
self.inner.method()
|
||||
}
|
||||
|
||||
/// Get a mutable reference to the method.
|
||||
#[inline]
|
||||
pub fn method_mut(&mut self) -> &mut Method {
|
||||
self.inner.method_mut()
|
||||
}
|
||||
|
||||
/// Get the url.
|
||||
#[inline]
|
||||
pub fn url(&self) -> &Url {
|
||||
self.inner.url()
|
||||
}
|
||||
|
||||
/// Get a mutable reference to the url.
|
||||
#[inline]
|
||||
pub fn url_mut(&mut self) -> &mut Url {
|
||||
self.inner.url_mut()
|
||||
}
|
||||
|
||||
/// Get the headers.
|
||||
#[inline]
|
||||
pub fn headers(&self) -> &HeaderMap {
|
||||
self.inner.headers()
|
||||
}
|
||||
|
||||
/// Get a mutable reference to the headers.
|
||||
#[inline]
|
||||
pub fn headers_mut(&mut self) -> &mut HeaderMap {
|
||||
self.inner.headers_mut()
|
||||
}
|
||||
|
||||
/// Get the body.
|
||||
#[inline]
|
||||
pub fn body(&self) -> Option<&Body> {
|
||||
self.body.as_ref()
|
||||
}
|
||||
|
||||
/// Get a mutable reference to the body.
|
||||
#[inline]
|
||||
pub fn body_mut(&mut self) -> &mut Option<Body> {
|
||||
&mut self.body
|
||||
}
|
||||
|
||||
/// Attempts to clone the `Request`.
|
||||
///
|
||||
/// None is returned if a body is which can not be cloned. This can be because the body is a
|
||||
/// stream.
|
||||
pub fn try_clone(&self) -> Option<Request> {
|
||||
let body = if let Some(ref body) = self.body.as_ref() {
|
||||
if let Some(body) = body.try_clone() {
|
||||
Some(body)
|
||||
} else {
|
||||
return None;
|
||||
}
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let mut req = Request::new(self.method().clone(), self.url().clone());
|
||||
*req.headers_mut() = self.headers().clone();
|
||||
req.body = body;
|
||||
Some(req)
|
||||
}
|
||||
|
||||
pub(crate) fn into_async(self) -> (async_impl::Request, Option<body::Sender>) {
|
||||
use crate::header::CONTENT_LENGTH;
|
||||
|
||||
let mut req_async = self.inner;
|
||||
let body = self.body.and_then(|body| {
|
||||
let (tx, body, len) = body.into_async();
|
||||
if let Some(len) = len {
|
||||
req_async.headers_mut().insert(CONTENT_LENGTH, len.into());
|
||||
}
|
||||
*req_async.body_mut() = Some(body);
|
||||
tx
|
||||
});
|
||||
(req_async, body)
|
||||
}
|
||||
}
|
||||
|
||||
impl RequestBuilder {
|
||||
pub(crate) fn new(client: Client, request: crate::Result<Request>) -> RequestBuilder {
|
||||
RequestBuilder { client, request }
|
||||
}
|
||||
|
||||
/// Add a `Header` to this Request.
|
||||
///
|
||||
/// ```rust
|
||||
/// use reqwest::header::USER_AGENT;
|
||||
///
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// let client = reqwest::blocking::Client::new();
|
||||
/// let res = client.get("https://www.rust-lang.org")
|
||||
/// .header(USER_AGENT, "foo")
|
||||
/// .send()?;
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub fn header<K, V>(mut self, key: K, value: V) -> RequestBuilder
|
||||
where
|
||||
HeaderName: HttpTryFrom<K>,
|
||||
HeaderValue: HttpTryFrom<V>,
|
||||
{
|
||||
let mut error = None;
|
||||
if let Ok(ref mut req) = self.request {
|
||||
match <HeaderName as HttpTryFrom<K>>::try_from(key) {
|
||||
Ok(key) => match <HeaderValue as HttpTryFrom<V>>::try_from(value) {
|
||||
Ok(value) => {
|
||||
req.headers_mut().append(key, value);
|
||||
}
|
||||
Err(e) => error = Some(crate::error::from(e.into())),
|
||||
},
|
||||
Err(e) => error = Some(crate::error::from(e.into())),
|
||||
};
|
||||
}
|
||||
if let Some(err) = error {
|
||||
self.request = Err(err);
|
||||
}
|
||||
self
|
||||
}
|
||||
|
||||
/// Add a set of Headers to the existing ones on this Request.
|
||||
///
|
||||
/// The headers will be merged in to any already set.
|
||||
///
|
||||
/// ```rust
|
||||
/// use reqwest::header::{HeaderMap, HeaderValue, USER_AGENT, CONTENT_TYPE};
|
||||
/// # use std::fs;
|
||||
///
|
||||
/// 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
|
||||
/// }
|
||||
///
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// 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()?;
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub fn headers(mut self, headers: crate::header::HeaderMap) -> RequestBuilder {
|
||||
if let Ok(ref mut req) = self.request {
|
||||
async_impl::request::replace_headers(req.headers_mut(), headers);
|
||||
}
|
||||
self
|
||||
}
|
||||
|
||||
/// Enable HTTP basic authentication.
|
||||
///
|
||||
/// ```rust
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// let client = reqwest::blocking::Client::new();
|
||||
/// let resp = client.delete("http://httpbin.org/delete")
|
||||
/// .basic_auth("admin", Some("good password"))
|
||||
/// .send()?;
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub fn basic_auth<U, P>(self, username: U, password: Option<P>) -> RequestBuilder
|
||||
where
|
||||
U: fmt::Display,
|
||||
P: fmt::Display,
|
||||
{
|
||||
let auth = match password {
|
||||
Some(password) => format!("{}:{}", username, password),
|
||||
None => format!("{}:", username),
|
||||
};
|
||||
let header_value = format!("Basic {}", encode(&auth));
|
||||
self.header(crate::header::AUTHORIZATION, &*header_value)
|
||||
}
|
||||
|
||||
/// Enable HTTP bearer authentication.
|
||||
///
|
||||
/// ```rust
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// let client = reqwest::blocking::Client::new();
|
||||
/// let resp = client.delete("http://httpbin.org/delete")
|
||||
/// .bearer_auth("token")
|
||||
/// .send()?;
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub fn bearer_auth<T>(self, token: T) -> RequestBuilder
|
||||
where
|
||||
T: fmt::Display,
|
||||
{
|
||||
let header_value = format!("Bearer {}", token);
|
||||
self.header(crate::header::AUTHORIZATION, &*header_value)
|
||||
}
|
||||
|
||||
/// Set the request body.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// Using a string:
|
||||
///
|
||||
/// ```rust
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// let client = reqwest::blocking::Client::new();
|
||||
/// let res = client.post("http://httpbin.org/post")
|
||||
/// .body("from a &str!")
|
||||
/// .send()?;
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// Using a `File`:
|
||||
///
|
||||
/// ```rust
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// 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()?;
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// Using arbitrary bytes:
|
||||
///
|
||||
/// ```rust
|
||||
/// # use std::fs;
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// // 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()?;
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub fn body<T: Into<Body>>(mut self, body: T) -> RequestBuilder {
|
||||
if let Ok(ref mut req) = self.request {
|
||||
*req.body_mut() = Some(body.into());
|
||||
}
|
||||
self
|
||||
}
|
||||
|
||||
/// 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"`.
|
||||
///
|
||||
/// ```rust
|
||||
/// # use reqwest::Error;
|
||||
/// #
|
||||
/// # fn run() -> Result<(), Error> {
|
||||
/// let client = reqwest::blocking::Client::new();
|
||||
/// let res = client.get("http://httpbin.org")
|
||||
/// .query(&[("lang", "rust")])
|
||||
/// .send()?;
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// # 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 query<T: Serialize + ?Sized>(mut self, query: &T) -> RequestBuilder {
|
||||
let mut error = None;
|
||||
if let Ok(ref mut req) = self.request {
|
||||
let url = req.url_mut();
|
||||
let mut pairs = url.query_pairs_mut();
|
||||
let serializer = serde_urlencoded::Serializer::new(&mut pairs);
|
||||
|
||||
if let Err(err) = query.serialize(serializer) {
|
||||
error = Some(crate::error::from(err));
|
||||
}
|
||||
}
|
||||
if let Ok(ref mut req) = self.request {
|
||||
if let Some("") = req.url().query() {
|
||||
req.url_mut().set_query(None);
|
||||
}
|
||||
}
|
||||
if let Some(err) = error {
|
||||
self.request = Err(err);
|
||||
}
|
||||
self
|
||||
}
|
||||
|
||||
/// 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.
|
||||
///
|
||||
/// ```rust
|
||||
/// # use reqwest::Error;
|
||||
/// # use std::collections::HashMap;
|
||||
/// #
|
||||
/// # fn run() -> Result<(), Error> {
|
||||
/// 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()?;
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This method fails if the passed value cannot be serialized into
|
||||
/// url encoded format
|
||||
pub fn form<T: Serialize + ?Sized>(mut self, form: &T) -> RequestBuilder {
|
||||
let mut error = None;
|
||||
if let Ok(ref mut req) = self.request {
|
||||
match serde_urlencoded::to_string(form) {
|
||||
Ok(body) => {
|
||||
req.headers_mut().insert(
|
||||
CONTENT_TYPE,
|
||||
HeaderValue::from_static("application/x-www-form-urlencoded"),
|
||||
);
|
||||
*req.body_mut() = Some(body.into());
|
||||
}
|
||||
Err(err) => error = Some(crate::error::from(err)),
|
||||
}
|
||||
}
|
||||
if let Some(err) = error {
|
||||
self.request = Err(err);
|
||||
}
|
||||
self
|
||||
}
|
||||
|
||||
/// Send a JSON body.
|
||||
///
|
||||
/// Sets the body to the JSON serialization of the passed value, and
|
||||
/// also sets the `Content-Type: application/json` header.
|
||||
///
|
||||
/// ```rust
|
||||
/// # use reqwest::Error;
|
||||
/// # use std::collections::HashMap;
|
||||
/// #
|
||||
/// # fn run() -> Result<(), Error> {
|
||||
/// 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()?;
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// # 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 json<T: Serialize + ?Sized>(mut self, json: &T) -> RequestBuilder {
|
||||
let mut error = None;
|
||||
if let Ok(ref mut req) = self.request {
|
||||
match serde_json::to_vec(json) {
|
||||
Ok(body) => {
|
||||
req.headers_mut()
|
||||
.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
|
||||
*req.body_mut() = Some(body.into());
|
||||
}
|
||||
Err(err) => error = Some(crate::error::from(err)),
|
||||
}
|
||||
}
|
||||
if let Some(err) = error {
|
||||
self.request = Err(err);
|
||||
}
|
||||
self
|
||||
}
|
||||
|
||||
/// Sends a multipart/form-data body.
|
||||
///
|
||||
/// ```
|
||||
/// # use reqwest::Error;
|
||||
///
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// let client = reqwest::blocking::Client::new();
|
||||
/// let form = reqwest::blocking::multipart::Form::new()
|
||||
/// .text("key3", "value3")
|
||||
/// .file("file", "/path/to/field")?;
|
||||
///
|
||||
/// let response = client.post("your url")
|
||||
/// .multipart(form)
|
||||
/// .send()?;
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// See [`multipart`](multipart/) for more examples.
|
||||
pub fn multipart(self, mut multipart: multipart::Form) -> RequestBuilder {
|
||||
let mut builder = self.header(
|
||||
CONTENT_TYPE,
|
||||
format!("multipart/form-data; boundary={}", multipart.boundary()).as_str(),
|
||||
);
|
||||
if let Ok(ref mut req) = builder.request {
|
||||
*req.body_mut() = Some(match multipart.compute_length() {
|
||||
Some(length) => Body::sized(multipart.reader(), length),
|
||||
None => Body::new(multipart.reader()),
|
||||
})
|
||||
}
|
||||
builder
|
||||
}
|
||||
|
||||
/// Build a `Request`, which can be inspected, modified and executed with
|
||||
/// `Client::execute()`.
|
||||
pub fn build(self) -> crate::Result<Request> {
|
||||
self.request
|
||||
}
|
||||
|
||||
/// 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 send(self) -> crate::Result<super::Response> {
|
||||
self.client.execute(self.request?)
|
||||
}
|
||||
|
||||
/// 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
|
||||
///
|
||||
/// ```rust
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// 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());
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// Without a body
|
||||
///
|
||||
/// ```rust
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// let client = reqwest::blocking::Client::new();
|
||||
/// let builder = client.get("http://httpbin.org/get");
|
||||
/// let clone = builder.try_clone();
|
||||
/// assert!(clone.is_some());
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// With a non-clonable body
|
||||
///
|
||||
/// ```rust
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// 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());
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub fn try_clone(&self) -> Option<RequestBuilder> {
|
||||
self.request
|
||||
.as_ref()
|
||||
.ok()
|
||||
.and_then(|req| req.try_clone())
|
||||
.map(|req| RequestBuilder {
|
||||
client: self.client.clone(),
|
||||
request: Ok(req),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Debug for Request {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
fmt_request_fields(&mut f.debug_struct("Request"), self).finish()
|
||||
}
|
||||
}
|
||||
|
||||
fn fmt_request_fields<'a, 'b>(
|
||||
f: &'a mut fmt::DebugStruct<'a, 'b>,
|
||||
req: &Request,
|
||||
) -> &'a mut fmt::DebugStruct<'a, 'b> {
|
||||
f.field("method", req.method())
|
||||
.field("url", req.url())
|
||||
.field("headers", req.headers())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::super::{body, Client};
|
||||
use crate::header::{HeaderMap, HeaderValue, ACCEPT, CONTENT_TYPE, HOST};
|
||||
use crate::Method;
|
||||
use serde::Serialize;
|
||||
use serde_json;
|
||||
use serde_urlencoded;
|
||||
use std::collections::{BTreeMap, HashMap};
|
||||
|
||||
#[test]
|
||||
fn basic_get_request() {
|
||||
let client = Client::new();
|
||||
let some_url = "https://google.com/";
|
||||
let r = client.get(some_url).build().unwrap();
|
||||
|
||||
assert_eq!(r.method(), &Method::GET);
|
||||
assert_eq!(r.url().as_str(), some_url);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn basic_head_request() {
|
||||
let client = Client::new();
|
||||
let some_url = "https://google.com/";
|
||||
let r = client.head(some_url).build().unwrap();
|
||||
|
||||
assert_eq!(r.method(), &Method::HEAD);
|
||||
assert_eq!(r.url().as_str(), some_url);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn basic_post_request() {
|
||||
let client = Client::new();
|
||||
let some_url = "https://google.com/";
|
||||
let r = client.post(some_url).build().unwrap();
|
||||
|
||||
assert_eq!(r.method(), &Method::POST);
|
||||
assert_eq!(r.url().as_str(), some_url);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn basic_put_request() {
|
||||
let client = Client::new();
|
||||
let some_url = "https://google.com/";
|
||||
let r = client.put(some_url).build().unwrap();
|
||||
|
||||
assert_eq!(r.method(), &Method::PUT);
|
||||
assert_eq!(r.url().as_str(), some_url);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn basic_patch_request() {
|
||||
let client = Client::new();
|
||||
let some_url = "https://google.com/";
|
||||
let r = client.patch(some_url).build().unwrap();
|
||||
|
||||
assert_eq!(r.method(), &Method::PATCH);
|
||||
assert_eq!(r.url().as_str(), some_url);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn basic_delete_request() {
|
||||
let client = Client::new();
|
||||
let some_url = "https://google.com/";
|
||||
let r = client.delete(some_url).build().unwrap();
|
||||
|
||||
assert_eq!(r.method(), &Method::DELETE);
|
||||
assert_eq!(r.url().as_str(), some_url);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn add_header() {
|
||||
let client = Client::new();
|
||||
let some_url = "https://google.com/";
|
||||
let r = client.post(some_url);
|
||||
|
||||
let header = HeaderValue::from_static("google.com");
|
||||
|
||||
// Add a copy of the header to the request builder
|
||||
let r = r.header(HOST, header.clone()).build().unwrap();
|
||||
|
||||
// then check it was actually added
|
||||
assert_eq!(r.headers().get(HOST), Some(&header));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn add_headers() {
|
||||
let client = Client::new();
|
||||
let some_url = "https://google.com/";
|
||||
let r = client.post(some_url);
|
||||
|
||||
let header = HeaderValue::from_static("google.com");
|
||||
|
||||
let mut headers = HeaderMap::new();
|
||||
headers.insert(HOST, header);
|
||||
|
||||
// Add a copy of the headers to the request builder
|
||||
let r = r.headers(headers.clone()).build().unwrap();
|
||||
|
||||
// then make sure they were added correctly
|
||||
assert_eq!(r.headers(), &headers);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn add_headers_multi() {
|
||||
let client = Client::new();
|
||||
let some_url = "https://google.com/";
|
||||
let r = client.post(some_url);
|
||||
|
||||
let header_json = HeaderValue::from_static("application/json");
|
||||
let header_xml = HeaderValue::from_static("application/xml");
|
||||
|
||||
let mut headers = HeaderMap::new();
|
||||
headers.append(ACCEPT, header_json);
|
||||
headers.append(ACCEPT, header_xml);
|
||||
|
||||
// Add a copy of the headers to the request builder
|
||||
let r = r.headers(headers.clone()).build().unwrap();
|
||||
|
||||
// then make sure they were added correctly
|
||||
assert_eq!(r.headers(), &headers);
|
||||
let mut all_values = r.headers().get_all(ACCEPT).iter();
|
||||
assert_eq!(all_values.next().unwrap(), &"application/json");
|
||||
assert_eq!(all_values.next().unwrap(), &"application/xml");
|
||||
assert_eq!(all_values.next(), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn add_body() {
|
||||
let client = Client::new();
|
||||
let some_url = "https://google.com/";
|
||||
let r = client.post(some_url);
|
||||
|
||||
let body = "Some interesting content";
|
||||
|
||||
let mut r = r.body(body).build().unwrap();
|
||||
|
||||
let buf = body::read_to_string(r.body_mut().take().unwrap()).unwrap();
|
||||
|
||||
assert_eq!(buf, body);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn add_query_append() {
|
||||
let client = Client::new();
|
||||
let some_url = "https://google.com/";
|
||||
let mut r = client.get(some_url);
|
||||
|
||||
r = r.query(&[("foo", "bar")]);
|
||||
r = r.query(&[("qux", 3)]);
|
||||
|
||||
let req = r.build().expect("request is valid");
|
||||
assert_eq!(req.url().query(), Some("foo=bar&qux=3"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn add_query_append_same() {
|
||||
let client = Client::new();
|
||||
let some_url = "https://google.com/";
|
||||
let mut r = client.get(some_url);
|
||||
|
||||
r = r.query(&[("foo", "a"), ("foo", "b")]);
|
||||
|
||||
let req = r.build().expect("request is valid");
|
||||
assert_eq!(req.url().query(), Some("foo=a&foo=b"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn add_query_struct() {
|
||||
#[derive(Serialize)]
|
||||
struct Params {
|
||||
foo: String,
|
||||
qux: i32,
|
||||
}
|
||||
|
||||
let client = Client::new();
|
||||
let some_url = "https://google.com/";
|
||||
let mut r = client.get(some_url);
|
||||
|
||||
let params = Params {
|
||||
foo: "bar".into(),
|
||||
qux: 3,
|
||||
};
|
||||
|
||||
r = r.query(¶ms);
|
||||
|
||||
let req = r.build().expect("request is valid");
|
||||
assert_eq!(req.url().query(), Some("foo=bar&qux=3"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn add_query_map() {
|
||||
let mut params = BTreeMap::new();
|
||||
params.insert("foo", "bar");
|
||||
params.insert("qux", "three");
|
||||
|
||||
let client = Client::new();
|
||||
let some_url = "https://google.com/";
|
||||
let mut r = client.get(some_url);
|
||||
|
||||
r = r.query(¶ms);
|
||||
|
||||
let req = r.build().expect("request is valid");
|
||||
assert_eq!(req.url().query(), Some("foo=bar&qux=three"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn add_form() {
|
||||
let client = Client::new();
|
||||
let some_url = "https://google.com/";
|
||||
let r = client.post(some_url);
|
||||
|
||||
let mut form_data = HashMap::new();
|
||||
form_data.insert("foo", "bar");
|
||||
|
||||
let mut r = r.form(&form_data).build().unwrap();
|
||||
|
||||
// Make sure the content type was set
|
||||
assert_eq!(
|
||||
r.headers().get(CONTENT_TYPE).unwrap(),
|
||||
&"application/x-www-form-urlencoded"
|
||||
);
|
||||
|
||||
let buf = body::read_to_string(r.body_mut().take().unwrap()).unwrap();
|
||||
|
||||
let body_should_be = serde_urlencoded::to_string(&form_data).unwrap();
|
||||
assert_eq!(buf, body_should_be);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn add_json() {
|
||||
let client = Client::new();
|
||||
let some_url = "https://google.com/";
|
||||
let r = client.post(some_url);
|
||||
|
||||
let mut json_data = HashMap::new();
|
||||
json_data.insert("foo", "bar");
|
||||
|
||||
let mut r = r.json(&json_data).build().unwrap();
|
||||
|
||||
// Make sure the content type was set
|
||||
assert_eq!(r.headers().get(CONTENT_TYPE).unwrap(), &"application/json");
|
||||
|
||||
let buf = body::read_to_string(r.body_mut().take().unwrap()).unwrap();
|
||||
|
||||
let body_should_be = serde_json::to_string(&json_data).unwrap();
|
||||
assert_eq!(buf, body_should_be);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn add_json_fail() {
|
||||
use serde::ser::Error;
|
||||
use serde::{Serialize, Serializer};
|
||||
struct MyStruct;
|
||||
impl Serialize for MyStruct {
|
||||
fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
|
||||
where
|
||||
S: Serializer,
|
||||
{
|
||||
Err(S::Error::custom("nope"))
|
||||
}
|
||||
}
|
||||
|
||||
let client = Client::new();
|
||||
let some_url = "https://google.com/";
|
||||
let r = client.post(some_url);
|
||||
let json_data = MyStruct;
|
||||
assert!(r.json(&json_data).build().unwrap_err().is_serialization());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_replace_headers() {
|
||||
use http::HeaderMap;
|
||||
|
||||
let mut headers = HeaderMap::new();
|
||||
headers.insert("foo", "bar".parse().unwrap());
|
||||
headers.append("foo", "baz".parse().unwrap());
|
||||
|
||||
let client = Client::new();
|
||||
let req = client
|
||||
.get("https://hyper.rs")
|
||||
.header("im-a", "keeper")
|
||||
.header("foo", "pop me")
|
||||
.headers(headers)
|
||||
.build()
|
||||
.expect("request build");
|
||||
|
||||
assert_eq!(req.headers()["im-a"], "keeper");
|
||||
|
||||
let foo = req.headers().get_all("foo").iter().collect::<Vec<_>>();
|
||||
assert_eq!(foo.len(), 2);
|
||||
assert_eq!(foo[0], "bar");
|
||||
assert_eq!(foo[1], "baz");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn normalize_empty_query() {
|
||||
let client = Client::new();
|
||||
let some_url = "https://google.com/";
|
||||
let empty_query: &[(&str, &str)] = &[];
|
||||
|
||||
let req = client
|
||||
.get(some_url)
|
||||
.query(empty_query)
|
||||
.build()
|
||||
.expect("request build");
|
||||
|
||||
assert_eq!(req.url().query(), None);
|
||||
assert_eq!(req.url().as_str(), "https://google.com/");
|
||||
}
|
||||
}
|
||||
385
src/blocking/response.rs
Normal file
385
src/blocking/response.rs
Normal file
@@ -0,0 +1,385 @@
|
||||
use std::fmt;
|
||||
use std::io::{self, Read};
|
||||
use std::mem;
|
||||
use std::net::SocketAddr;
|
||||
use std::pin::Pin;
|
||||
use std::time::Duration;
|
||||
|
||||
use http;
|
||||
use hyper::header::HeaderMap;
|
||||
use serde::de::DeserializeOwned;
|
||||
|
||||
use super::client::KeepCoreThreadAlive;
|
||||
use super::wait;
|
||||
use crate::cookie;
|
||||
use crate::{async_impl, StatusCode, Url, Version};
|
||||
|
||||
/// A Response to a submitted `Request`.
|
||||
pub struct Response {
|
||||
inner: async_impl::Response,
|
||||
body: Option<Pin<Box<dyn futures::io::AsyncRead + Send + Sync>>>,
|
||||
timeout: Option<Duration>,
|
||||
_thread_handle: KeepCoreThreadAlive,
|
||||
}
|
||||
|
||||
impl fmt::Debug for Response {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
fmt::Debug::fmt(&self.inner, f)
|
||||
}
|
||||
}
|
||||
|
||||
impl Response {
|
||||
pub(crate) fn new(
|
||||
res: async_impl::Response,
|
||||
timeout: Option<Duration>,
|
||||
thread: KeepCoreThreadAlive,
|
||||
) -> Response {
|
||||
Response {
|
||||
inner: res,
|
||||
body: None,
|
||||
timeout,
|
||||
_thread_handle: thread,
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the `StatusCode` of this `Response`.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// Checking for general status class:
|
||||
///
|
||||
/// ```rust
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// let resp = reqwest::blocking::get("http://httpbin.org/get")?;
|
||||
/// if resp.status().is_success() {
|
||||
/// println!("success!");
|
||||
/// } else if resp.status().is_server_error() {
|
||||
/// println!("server error!");
|
||||
/// } else {
|
||||
/// println!("Something else happened. Status: {:?}", resp.status());
|
||||
/// }
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// Checking for specific status codes:
|
||||
///
|
||||
/// ```rust
|
||||
/// use reqwest::blocking::Client;
|
||||
/// use reqwest::StatusCode;
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// let client = Client::new();
|
||||
///
|
||||
/// let resp = client.post("http://httpbin.org/post")
|
||||
/// .body("possibly too large")
|
||||
/// .send()?;
|
||||
///
|
||||
/// match resp.status() {
|
||||
/// StatusCode::OK => println!("success!"),
|
||||
/// StatusCode::PAYLOAD_TOO_LARGE => {
|
||||
/// println!("Request payload is too large!");
|
||||
/// }
|
||||
/// s => println!("Received response status: {:?}", s),
|
||||
/// };
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
#[inline]
|
||||
pub fn status(&self) -> StatusCode {
|
||||
self.inner.status()
|
||||
}
|
||||
|
||||
/// Get the `Headers` of this `Response`.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// Saving an etag when caching a file:
|
||||
///
|
||||
/// ```
|
||||
/// use reqwest::blocking::Client;
|
||||
/// use reqwest::header::ETAG;
|
||||
///
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// let client = Client::new();
|
||||
///
|
||||
/// let mut resp = client.get("http://httpbin.org/cache").send()?;
|
||||
/// if resp.status().is_success() {
|
||||
/// if let Some(etag) = resp.headers().get(ETAG) {
|
||||
/// std::fs::write("etag", etag.as_bytes());
|
||||
/// }
|
||||
/// let mut file = std::fs::File::create("file")?;
|
||||
/// resp.copy_to(&mut file)?;
|
||||
/// }
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
#[inline]
|
||||
pub fn headers(&self) -> &HeaderMap {
|
||||
self.inner.headers()
|
||||
}
|
||||
|
||||
/// Retrieve the cookies contained in the response.
|
||||
///
|
||||
/// Note that invalid 'Set-Cookie' headers will be ignored.
|
||||
pub fn cookies<'a>(&'a self) -> impl Iterator<Item = cookie::Cookie<'a>> + 'a {
|
||||
cookie::extract_response_cookies(self.headers()).filter_map(Result::ok)
|
||||
}
|
||||
|
||||
/// Get the HTTP `Version` of this `Response`.
|
||||
#[inline]
|
||||
pub fn version(&self) -> Version {
|
||||
self.inner.version()
|
||||
}
|
||||
|
||||
/// Get the final `Url` of this `Response`.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// let resp = reqwest::blocking::get("http://httpbin.org/redirect/1")?;
|
||||
/// assert_eq!(resp.url().as_str(), "http://httpbin.org/get");
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
#[inline]
|
||||
pub fn url(&self) -> &Url {
|
||||
self.inner.url()
|
||||
}
|
||||
|
||||
/// Get the remote address used to get this `Response`.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// let resp = reqwest::blocking::get("http://httpbin.org/redirect/1")?;
|
||||
/// println!("httpbin.org address: {:?}", resp.remote_addr());
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub fn remote_addr(&self) -> Option<SocketAddr> {
|
||||
self.inner.remote_addr()
|
||||
}
|
||||
|
||||
/// Get the content-length of the response, if it is known.
|
||||
///
|
||||
/// Reasons it may not be known:
|
||||
///
|
||||
/// - The server didn't send a `content-length` header.
|
||||
/// - The response is gzipped and automatically decoded (thus changing
|
||||
/// the actual decoded length).
|
||||
pub fn content_length(&self) -> Option<u64> {
|
||||
self.inner.content_length()
|
||||
}
|
||||
|
||||
/// Try and deserialize the response body as JSON using `serde`.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```rust
|
||||
/// # extern crate reqwest;
|
||||
/// # extern crate serde;
|
||||
/// #
|
||||
/// # use reqwest::Error;
|
||||
/// # use serde::Deserialize;
|
||||
/// #
|
||||
/// #[derive(Deserialize)]
|
||||
/// struct Ip {
|
||||
/// origin: String,
|
||||
/// }
|
||||
///
|
||||
/// # fn run() -> Result<(), Error> {
|
||||
/// let json: Ip = reqwest::blocking::get("http://httpbin.org/ip")?.json()?;
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// #
|
||||
/// # fn main() { }
|
||||
/// ```
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This method fails whenever the response body is not in JSON format
|
||||
/// or it cannot be properly deserialized to target type `T`. For more
|
||||
/// details please see [`serde_json::from_reader`].
|
||||
/// [`serde_json::from_reader`]: https://docs.serde.rs/serde_json/fn.from_reader.html
|
||||
#[inline]
|
||||
pub fn json<T: DeserializeOwned>(&mut self) -> crate::Result<T> {
|
||||
wait::timeout(self.inner.json(), self.timeout).map_err(|e| match e {
|
||||
wait::Waited::TimedOut => crate::error::timedout(None),
|
||||
wait::Waited::Executor(e) => crate::error::from(e),
|
||||
wait::Waited::Inner(e) => e,
|
||||
})
|
||||
}
|
||||
|
||||
/// Get the response text.
|
||||
///
|
||||
/// This method decodes the response body with BOM sniffing
|
||||
/// and with malformed sequences replaced with the REPLACEMENT CHARACTER.
|
||||
/// Encoding is determinated from the `charset` parameter of `Content-Type` header,
|
||||
/// and defaults to `utf-8` if not presented.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust
|
||||
/// # extern crate reqwest;
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// let content = reqwest::blocking::get("http://httpbin.org/range/26")?.text()?;
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// # Note
|
||||
///
|
||||
/// This consumes the body. Trying to read more, or use of `response.json()`
|
||||
/// will return empty values.
|
||||
pub fn text(&mut self) -> crate::Result<String> {
|
||||
self.text_with_charset("utf-8")
|
||||
}
|
||||
|
||||
/// Get the response text given a specific encoding.
|
||||
///
|
||||
/// This method decodes the response body with BOM sniffing
|
||||
/// and with malformed sequences replaced with the REPLACEMENT CHARACTER.
|
||||
/// You can provide a default encoding for decoding the raw message, while the
|
||||
/// `charset` parameter of `Content-Type` header is still prioritized. For more information
|
||||
/// about the possible encoding name, please go to
|
||||
/// https://docs.rs/encoding_rs/0.8.17/encoding_rs/#relationship-with-windows-code-pages
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust
|
||||
/// # extern crate reqwest;
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// let content = reqwest::blocking::get("http://httpbin.org/range/26")?
|
||||
/// .text_with_charset("utf-8")?;
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// # Note
|
||||
///
|
||||
/// This consumes the body. Trying to read more, or use of `response.json()`
|
||||
/// will return empty values.
|
||||
pub fn text_with_charset(&mut self, default_encoding: &str) -> crate::Result<String> {
|
||||
wait::timeout(self.inner.text_with_charset(default_encoding), self.timeout).map_err(|e| {
|
||||
match e {
|
||||
wait::Waited::TimedOut => crate::error::timedout(None),
|
||||
wait::Waited::Executor(e) => crate::error::from(e),
|
||||
wait::Waited::Inner(e) => e,
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// Copy the response body into a writer.
|
||||
///
|
||||
/// This function internally uses [`std::io::copy`] and hence will continuously read data from
|
||||
/// the body and then write it into writer in a streaming fashion until EOF is met.
|
||||
///
|
||||
/// On success, the total number of bytes that were copied to `writer` is returned.
|
||||
///
|
||||
/// [`std::io::copy`]: https://doc.rust-lang.org/std/io/fn.copy.html
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// let mut resp = reqwest::blocking::get("http://httpbin.org/range/5")?;
|
||||
/// let mut buf: Vec<u8> = vec![];
|
||||
/// resp.copy_to(&mut buf)?;
|
||||
/// assert_eq!(b"abcde", buf.as_slice());
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub fn copy_to<W: ?Sized>(&mut self, w: &mut W) -> crate::Result<u64>
|
||||
where
|
||||
W: io::Write,
|
||||
{
|
||||
io::copy(self, w).map_err(crate::error::from)
|
||||
}
|
||||
|
||||
/// Turn a response into an error if the server returned an error.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust,no_run
|
||||
/// # extern crate reqwest;
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// let res = reqwest::blocking::get("http://httpbin.org/status/400")?
|
||||
/// .error_for_status();
|
||||
/// if let Err(err) = res {
|
||||
/// assert_eq!(err.status(), Some(reqwest::StatusCode::BAD_REQUEST));
|
||||
/// }
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// # fn main() {}
|
||||
/// ```
|
||||
pub fn error_for_status(self) -> crate::Result<Self> {
|
||||
let Response {
|
||||
body,
|
||||
inner,
|
||||
timeout,
|
||||
_thread_handle,
|
||||
} = self;
|
||||
inner.error_for_status().map(move |inner| Response {
|
||||
inner,
|
||||
body,
|
||||
timeout,
|
||||
_thread_handle,
|
||||
})
|
||||
}
|
||||
|
||||
/// Turn a reference to a response into an error if the server returned an error.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust,no_run
|
||||
/// # extern crate reqwest;
|
||||
/// # fn run() -> Result<(), Box<std::error::Error>> {
|
||||
/// let res = reqwest::blocking::get("http://httpbin.org/status/400")?;
|
||||
/// let res = res.error_for_status_ref();
|
||||
/// if let Err(err) = res {
|
||||
/// assert_eq!(err.status(), Some(reqwest::StatusCode::BAD_REQUEST));
|
||||
/// }
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// # fn main() {}
|
||||
/// ```
|
||||
pub fn error_for_status_ref(&self) -> crate::Result<&Self> {
|
||||
self.inner.error_for_status_ref().and_then(|_| Ok(self))
|
||||
}
|
||||
|
||||
// private
|
||||
|
||||
fn body_mut(&mut self) -> Pin<&mut dyn futures::io::AsyncRead> {
|
||||
use futures::stream::TryStreamExt;
|
||||
if self.body.is_none() {
|
||||
let body = mem::replace(self.inner.body_mut(), async_impl::Decoder::empty());
|
||||
|
||||
let body = body.map_err(crate::error::into_io).into_async_read();
|
||||
|
||||
self.body = Some(Box::pin(body));
|
||||
}
|
||||
self.body.as_mut().expect("body was init").as_mut()
|
||||
}
|
||||
}
|
||||
|
||||
impl Read for Response {
|
||||
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
||||
use futures::io::AsyncReadExt;
|
||||
|
||||
let timeout = self.timeout;
|
||||
wait::timeout(self.body_mut().read(buf), timeout).map_err(|e| match e {
|
||||
wait::Waited::TimedOut => crate::error::timedout(None).into_io(),
|
||||
wait::Waited::Executor(e) => crate::error::from(e).into_io(),
|
||||
wait::Waited::Inner(e) => e,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Into<async_impl::body::Body>> From<http::Response<T>> for Response {
|
||||
fn from(r: http::Response<T>) -> Response {
|
||||
let response = async_impl::Response::from(r);
|
||||
Response::new(response, None, KeepCoreThreadAlive::empty())
|
||||
}
|
||||
}
|
||||
67
src/blocking/wait.rs
Normal file
67
src/blocking/wait.rs
Normal file
@@ -0,0 +1,67 @@
|
||||
use std::future::Future;
|
||||
use std::sync::Arc;
|
||||
use std::task::{Context, Poll};
|
||||
use std::time::Duration;
|
||||
|
||||
use tokio::clock;
|
||||
use tokio_executor::{
|
||||
enter,
|
||||
park::{Park, ParkThread, Unpark, UnparkThread},
|
||||
EnterError,
|
||||
};
|
||||
|
||||
pub(crate) fn timeout<F, I, E>(fut: F, timeout: Option<Duration>) -> Result<I, Waited<E>>
|
||||
where
|
||||
F: Future<Output = Result<I, E>>,
|
||||
{
|
||||
let _entered = enter().map_err(Waited::Executor)?;
|
||||
let deadline = timeout.map(|d| {
|
||||
log::trace!("wait at most {:?}", d);
|
||||
clock::now() + d
|
||||
});
|
||||
|
||||
let mut park = ParkThread::new();
|
||||
// Arc shouldn't be necessary, since UnparkThread is reference counted internally,
|
||||
// but let's just stay safe for now.
|
||||
let waker = futures::task::waker(Arc::new(UnparkWaker(park.unpark())));
|
||||
let mut cx = Context::from_waker(&waker);
|
||||
|
||||
futures::pin_mut!(fut);
|
||||
|
||||
loop {
|
||||
match fut.as_mut().poll(&mut cx) {
|
||||
Poll::Ready(Ok(val)) => return Ok(val),
|
||||
Poll::Ready(Err(err)) => return Err(Waited::Inner(err)),
|
||||
Poll::Pending => (), // fallthrough
|
||||
}
|
||||
|
||||
if let Some(deadline) = deadline {
|
||||
let now = clock::now();
|
||||
if now >= deadline {
|
||||
log::trace!("wait timeout exceeded");
|
||||
return Err(Waited::TimedOut);
|
||||
}
|
||||
|
||||
log::trace!("park timeout {:?}", deadline - now);
|
||||
park.park_timeout(deadline - now)
|
||||
.expect("ParkThread doesn't error");
|
||||
} else {
|
||||
park.park().expect("ParkThread doesn't error");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(crate) enum Waited<E> {
|
||||
TimedOut,
|
||||
Executor(EnterError),
|
||||
Inner(E),
|
||||
}
|
||||
|
||||
struct UnparkWaker(UnparkThread);
|
||||
|
||||
impl futures::task::ArcWake for UnparkWaker {
|
||||
fn wake_by_ref(arc_self: &Arc<Self>) {
|
||||
arc_self.0.unpark();
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user