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 mut agent = ureq::agent();

agent
    .post("http://example.com/login")
    .call()?;

let secret = agent
    .get("http://example.com/my-protected-page")
    .call()?
    .into_string()?;

  println!("Secret is: {}", secret);

Agent uses an inner Arc, so cloning an Agent results in an instance that shares the same underlying connection pool and other state.

Implementations

impl Agent

pub fn new() -> Self

Creates an Agent with default settings.

Same as AgentBuilder::new().build().

pub fn request(&self, method: &str, path: &str) -> Request

Make a request with the HTTP verb as a parameter.

This allows making requests with verbs that don’t have a dedicated method.

If you’ve got an already-parsed Url, try request_url.

use ureq::Response;
let agent = ureq::agent();

let resp: Response = agent
    .request("OPTIONS", "http://example.com/")
    .call()?;

pub fn request_url(&self, method: &str, url: &Url) -> Request

Make a request using an already-parsed Url.

This is useful if you’ve got a parsed Url from some other source, or if you want to parse the URL and then modify it before making the request. If you’d just like to pass a String or a &str, try request.

use {url::Url, ureq::Response};
let agent = ureq::agent();

let mut url: Url = "http://example.com/some-page".parse().unwrap();
url.set_path("/robots.txt");
let resp: Response = agent
    .request_url("GET", &url)
    .call()?;

pub fn get(&self, path: &str) -> Request

Make a GET request from this agent.

pub fn head(&self, path: &str) -> Request

Make a HEAD request from this agent.

pub fn post(&self, path: &str) -> Request

Make a POST request from this agent.

pub fn put(&self, path: &str) -> Request

Make a PUT request from this agent.

pub fn delete(&self, path: &str) -> Request

Make a DELETE request from this agent.

pub fn cookie_store(&self) -> CookieStoreGuard<'_>

Read access to the cookie store.

Used to persist the cookies to an external writer.

use std::io::Write;
use std::fs::File;

let agent = ureq::agent();

// Cookies set by www.google.com are stored in agent.
agent.get("https://www.google.com/").call()?;

// Saves (persistent) cookies
let mut file = File::create("cookies.json")?;
agent.cookie_store().save_json(&mut file).unwrap();

Trait Implementations

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.

impl Debug for Agent

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

Formats the value using the given formatter.