[−][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());
Methods
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 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.
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.
let agent = ureq::agent(); let cookie = ureq::Cookie::new("name", "value"); 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 connect(&self, path: &str) -> Request
[src]
Make a CONNECT 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,
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.
fn to_owned(&self) -> T
[src]
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.
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>,