Struct surf_cookie_middleware::CookieMiddleware

pub struct CookieMiddleware { /* fields omitted */ }

A middleware for sending received cookies in surf

File system persistence

This middleware can optionally be constructed with a file or path to enable writing "persistent cookies" to disk after every received response.

Cloning semantics

All clones of this middleware will refer to the same data and fd (if persistence is enabled).

Usage example

use surf::Client;
use surf_cookie_middleware::CookieMiddleware;
let client = Client::new().with(CookieMiddleware::new());
// client.get(...).await?;
// client.get(...).await?; <- this request will send any appropriate
//                            cookies received from the first request,
//                            based on request url

Implementations

impl CookieMiddleware

pub fn new() -> Self

Builds a new CookieMiddleware

Example

use surf_cookie_middleware::CookieMiddleware;

let client = surf::Client::new().with(CookieMiddleware::new());

// client.get(...).await?;
// client.get(...).await?; <- this request will send any appropriate
//                            cookies received from the first request,
//                            based on request url

pub fn with_cookie_store(cookie_store: CookieStore) -> Self

Builds a CookieMiddleware with an existing cookie_store::CookieStore

Example

use surf_cookie_middleware::{CookieStore, CookieMiddleware};

let cookie_store = CookieStore::default();
let client = surf::Client::new()
    .with(CookieMiddleware::with_cookie_store(cookie_store));

pub async fn from_path(path: impl Into<PathBuf>) -> Result<Self>

Builds a CookieMiddleware from a path to a filesystem cookie jar. These jars are stored in ndjson format. If the file does not exist, it will be created. If the file does exist, the cookie jar will be initialized with those cookies.

Currently this only persists "persistent cookies" -- cookies with an expiry. "Session cookies" (without an expiry) are not persisted to disk, nor are expired cookies.

Example

use surf_cookie_middleware::{CookieStore, CookieMiddleware};

let cookie_store = CookieStore::default();
let client = surf::Client::new()
    .with(CookieMiddleware::from_path("./cookies.ndjson").await?);

pub async fn from_file(file: impl Into<File>) -> Result<Self>

Builds a CookieMiddleware from a File (either async_std::fs::File or std::fs::File) that represents a filesystem cookie jar. These jars are stored in ndjson format. The cookie jar will be initialized with any cookies contained in this file, and persisted to the file after every request.

Currently this only persists "persistent cookies" -- cookies with an expiry. "Session cookies" (without an expiry) are not persisted to disk, nor are expired cookies.

Example

use surf::Client;
use surf_cookie_middleware::{CookieStore, CookieMiddleware};
let cookie_store = CookieStore::default();
let file = std::fs::File::create("./cookies.ndjson")?;
let client = Client::new()
    .with(CookieMiddleware::from_file(file).await?);

Trait Implementations

impl Clone for CookieMiddleware

fn clone(&self) -> CookieMiddleware

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CookieMiddleware

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

Formats the value using the given formatter.

impl Default for CookieMiddleware

fn default() -> CookieMiddleware

Returns the "default value" for a type.

impl Middleware for CookieMiddleware

fn handle<'life0, 'life1, 'async_trait>(
    &'life0 self,
    req: Request,
    client: Client,
    next: Next<'life1>
) -> Pin<Box<dyn Future<Output = Result<Response>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Asynchronously handle the request, and return a response.