[−][src]Struct ureq::Agent
Agents keep state between requests.
By default, no state, such as cookies, is kept between requests. But by creating an agent as entry point for the request, we can keep a state.
let agent = ureq::agent(); let auth = agent .post("/login") .auth("martin", "rubbermashgum") .call(); // blocks. puts auth cookies in agent. if !auth.ok() { println!("Noes!"); } let secret = agent .get("/my-protected-page") .call(); // blocks and waits for request. if !secret.ok() { println!("Wot?!"); } println!("Secret is: {}", secret.into_string().unwrap());
Implementations
impl Agent
[src]
pub fn new() -> Agent
[src]
Creates a new agent. Typically you'd use ureq::agent()
to
do this.
let agent = ureq::Agent::new() .set("X-My-Header", "Foo") // present on all requests from this agent .build(); agent.get("/foo");
pub fn build(&self) -> Self
[src]
Create a new agent after treating it as a builder. This actually clones the internal state to a new one and instantiates a new connection pool that is reused between connects.
pub fn set(&mut self, header: &str, value: &str) -> &mut Agent
[src]
Set a header field that will be present in all requests using the agent.
let agent = ureq::agent() .set("X-API-Key", "foobar") .set("Accept", "text/plain") .build(); let r = agent .get("/my-page") .call(); if r.ok() { println!("yay got {}", r.into_string().unwrap()); } else { println!("Oh no error!"); }
pub fn auth(&mut self, user: &str, pass: &str) -> &mut Agent
[src]
Basic auth that will be present in all requests using the agent.
let agent = ureq::agent() .auth("martin", "rubbermashgum") .build(); let r = agent .get("/my_page") .call(); println!("{:?}", r);
pub fn auth_kind(&mut self, kind: &str, pass: &str) -> &mut Agent
[src]
Auth of other kinds such as Digest
, Token
etc, that will be present
in all requests using the agent.
// sets a header "Authorization: token secret" let agent = ureq::agent() .auth_kind("token", "secret") .build(); let r = agent .get("/my_page") .call();
pub fn request(&self, method: &str, path: &str) -> Request
[src]
Request by providing the HTTP verb such as GET
, POST
...
let agent = ureq::agent(); let r = agent .request("GET", "/my_page") .call(); println!("{:?}", r);
pub fn set_max_pool_connections(&self, max_connections: usize)
[src]
Sets the maximum number of connections allowed in the connection pool. By default, this is set to 100. Setting this to zero would disable connection pooling.
let agent = ureq::agent(); agent.set_max_pool_connections(200);
pub fn set_max_pool_connections_per_host(&self, max_connections: usize)
[src]
Sets the maximum number of connections per host to keep in the connection pool. By default, this is set to 1. Setting this to zero would disable connection pooling.
let agent = ureq::agent(); agent.set_max_pool_connections_per_host(10);
pub fn set_resolver(&mut self, resolver: impl Resolver + 'static) -> &mut Self
[src]
Configures a custom resolver to be used by this agent. By default, address-resolution is done by std::net::ToSocketAddrs. This allows you to override that resolution with your own alternative. Useful for testing and special-cases like DNS-based load balancing.
A Fn(&str) -> io::Result<Vec<SocketAddr>>
is a valid resolver,
passing a closure is a simple way to override. Note that you might need
explicit type &str
on the closure argument for type inference to
succeed.
use std::net::ToSocketAddrs; let mut agent = ureq::agent(); agent.set_resolver(|addr: &str| match addr { "example.com" => Ok(vec![([127,0,0,1], 8096).into()]), addr => addr.to_socket_addrs().map(Iterator::collect), });
pub fn set_proxy(&mut self, proxy: Proxy) -> &mut Agent
[src]
Set the proxy server to use for all connections from this Agent.
Example:
let proxy = ureq::Proxy::new("user:password@cool.proxy:9090").unwrap(); let agent = ureq::agent() .set_proxy(proxy) .build();
pub fn cookie(&self, name: &str) -> Option<Cookie<'static>>
[src]
Gets a cookie in this agent by name. Cookies are available
either by setting it in the agent, or by making requests
that Set-Cookie
in the agent.
Note that this will return any cookie for the given name, regardless of which host and path that cookie was set on.
let agent = ureq::agent(); agent.get("http://www.google.com").call(); assert!(agent.cookie("NID").is_some());
pub fn set_cookie(&self, cookie: Cookie<'static>)
[src]
Set a cookie in this agent.
Cookies without a domain, or with a malformed domain or path, will be silently ignored.
let agent = ureq::agent(); let cookie = ureq::Cookie::build("name", "value") .domain("example.com") .path("/") .secure(true) .finish(); agent.set_cookie(cookie);
pub fn get(&self, path: &str) -> Request
[src]
Make a GET request from this agent.
pub fn head(&self, path: &str) -> Request
[src]
Make a HEAD request from this agent.
pub fn post(&self, path: &str) -> Request
[src]
Make a POST request from this agent.
pub fn put(&self, path: &str) -> Request
[src]
Make a PUT request from this agent.
pub fn delete(&self, path: &str) -> Request
[src]
Make a DELETE request from this agent.
pub fn trace(&self, path: &str) -> Request
[src]
Make a TRACE request from this agent.
pub fn options(&self, path: &str) -> Request
[src]
Make a OPTIONS request from this agent.
pub fn patch(&self, path: &str) -> Request
[src]
Make a PATCH request from this agent.
Trait Implementations
Auto Trait Implementations
impl RefUnwindSafe for Agent
impl Send for Agent
impl Sync for Agent
impl Unpin for Agent
impl UnwindSafe for Agent
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,