Struct ureq::Agent

pub struct Agent { /* fields omitted */ }

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().build();

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

pub fn new() -> Agent

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

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<K, V>(&mut self, header: K, value: V) -> &mut Agent where     K: Into<String>,     V: Into<String>,

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", "application/json")
    .build();

let r = agent
    .get("/my-page")
    .call();

 if r.ok() {
     println!("yay got {}", r.into_json().unwrap());
 } else {
     println!("Oh no error!");
 }

pub fn set_map<K, V, I>(&mut self, headers: I) -> &mut Agent where     K: Into<String>,     V: Into<String>,     I: IntoIterator<Item = (K, V)>,

Set many headers that will be present in all requests using the agent.

#[macro_use]
extern crate ureq;

fn main() {
let agent = ureq::agent()
    .set_map(map! {
        "X-API-Key" => "foobar",
        "Accept" => "application/json"
    })
    .build();

let r = agent
    .get("/my_page")
    .call();

if r.ok() {
    println!("yay got {}", r.into_json().unwrap());
}
}

pub fn auth<S, T>(&mut self, user: S, pass: T) -> &mut Agent where     S: Into<String>,     T: Into<String>,

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<S, T>(&mut self, kind: S, pass: T) -> &mut Agent where     S: Into<String>,     T: Into<String>,

Auth of other kinds such as Digest, Token etc, that will be present in all requests using the agent.

let agent = ureq::agent()
    .auth_kind("token", "secret")
    .build();

let r = agent
    .get("/my_page")
    .call();

pub fn request<M, S>(&self, method: M, path: S) -> Request where     M: Into<String>,     S: Into<String>,

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>>

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().build();

agent.get("http://www.google.com").call();

assert!(agent.cookie("NID").is_some());

pub fn set_cookie(&self, cookie: Cookie<'static>)

Set a cookie in this agent.

let agent = ureq::agent().build();

let cookie = ureq::Cookie::new("name", "value");
agent.set_cookie(cookie);

pub fn get<S>(&self, path: S) -> Request where     S: Into<String>,

Make a GET request from this agent.

pub fn head<S>(&self, path: S) -> Request where     S: Into<String>,

Make a HEAD request from this agent.

pub fn post<S>(&self, path: S) -> Request where     S: Into<String>,

Make a POST request from this agent.

pub fn put<S>(&self, path: S) -> Request where     S: Into<String>,

Make a PUT request from this agent.

pub fn delete<S>(&self, path: S) -> Request where     S: Into<String>,

Make a DELETE request from this agent.

pub fn trace<S>(&self, path: S) -> Request where     S: Into<String>,

Make a TRACE request from this agent.

pub fn options<S>(&self, path: S) -> Request where     S: Into<String>,

Make a OPTIONS request from this agent.

pub fn connect<S>(&self, path: S) -> Request where     S: Into<String>,

Make a CONNECT request from this agent.

pub fn patch<S>(&self, path: S) -> Request where     S: Into<String>,

Make a PATCH request from this agent.

Trait Implementations

impl Debug for Agent

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Default for Agent

fn default() -> Agent

Returns the "default value" for a type.

impl Clone for Agent

fn clone(&self) -> Agent

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.