Struct Session 

pub struct Session { /* private fields */ }

Stateful request executor that can hold a persistent connection.

A session is useful when you want tighter control over connection reuse and pipelining than calling Client::execute repeatedly.

Implementations

impl Session

pub fn execute(&mut self, request: Request) -> Result<Response, NanoGetError>

Executes a request, applying configured redirects, cache behavior, auth retries, and proxy routing.

Examples found in repository

examples/nano-get-bench.rs (line 54)

fn bench_get(iterations: usize) -> Duration {
    let response = b"HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nhello".to_vec();
    let (base_url, handle) = spawn_persistent_server(iterations, response);

    let client = Client::builder()
        .connection_policy(ConnectionPolicy::Reuse)
        .build();
    let mut session = client.session();

    let start = Instant::now();
    for i in 0..iterations {
        let req = Request::get(format!("{}/g{}", base_url, i)).expect("request");
        let resp = session.execute(req).expect("execute");
        assert_eq!(resp.body, b"hello");
    }
    let elapsed = start.elapsed();
    handle.join().expect("join server");
    elapsed
}

fn bench_head(iterations: usize) -> Duration {
    let response = b"HTTP/1.1 200 OK\r\nContent-Length: 5\r\nX-Bench: 1\r\n\r\n".to_vec();
    let (base_url, handle) = spawn_persistent_server(iterations, response);

    let client = Client::builder()
        .connection_policy(ConnectionPolicy::Reuse)
        .build();
    let mut session = client.session();

    let start = Instant::now();
    for i in 0..iterations {
        let req = Request::head(format!("{}/h{}", base_url, i)).expect("request");
        let resp = session.execute(req).expect("execute");
        assert!(resp.body.is_empty());
    }
    let elapsed = start.elapsed();
    handle.join().expect("join server");
    elapsed
}

examples/session-reuse-and-pipelining/main.rs (line 20)

fn main() -> Result<(), Box<dyn Error>> {
    let client = Client::builder()
        .connection_policy(ConnectionPolicy::Reuse)
        .build();
    let mut session = client.session();

    let first = session.execute(Request::get("http://example.com/")?)?;
    let second = session.execute(Request::get("http://example.com/index.html")?)?;
    let pipelined = session.execute_pipelined(&[
        Request::get("http://example.com/")?,
        Request::get("http://example.com/index.html")?,
    ])?;

    println!("This example demonstrates the Session API shape for reuse and pipelining.");
    summarize("sequential #1", &first);
    summarize("sequential #2", &second);
    summarize("pipeline #1", &pipelined[0]);
    summarize("pipeline #2", &pipelined[1]);

    Ok(())
}

pub fn execute_ref( &mut self, request: &Request, ) -> Result<Response, NanoGetError>

Executes a borrowed request by cloning it internally.

pub fn execute_pipelined( &mut self, requests: &[Request], ) -> Result<Vec<Response>, NanoGetError>

Sends multiple requests in one HTTP/1.1 pipeline.

Requirements:

• ConnectionPolicy::Reuse must be enabled
• all requests must target the same underlying connection

On success, responses are returned in request order.

Examples found in repository

examples/session-reuse-and-pipelining/main.rs (lines 22-25)

fn main() -> Result<(), Box<dyn Error>> {
    let client = Client::builder()
        .connection_policy(ConnectionPolicy::Reuse)
        .build();
    let mut session = client.session();

    let first = session.execute(Request::get("http://example.com/")?)?;
    let second = session.execute(Request::get("http://example.com/index.html")?)?;
    let pipelined = session.execute_pipelined(&[
        Request::get("http://example.com/")?,
        Request::get("http://example.com/index.html")?,
    ])?;

    println!("This example demonstrates the Session API shape for reuse and pipelining.");
    summarize("sequential #1", &first);
    summarize("sequential #2", &second);
    summarize("pipeline #1", &pipelined[0]);
    summarize("pipeline #2", &pipelined[1]);

    Ok(())
}

examples/nano-get-bench.rs (line 99)

fn bench_pipeline(total_requests: usize, pipeline_depth: usize) -> Duration {
    let response = b"HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nhello".to_vec();
    let (base_url, handle) = spawn_persistent_server(total_requests, response);

    let client = Client::builder()
        .connection_policy(ConnectionPolicy::Reuse)
        .build();
    let mut session = client.session();

    let start = Instant::now();
    let mut sent = 0usize;
    while sent < total_requests {
        let batch_size = (total_requests - sent).min(pipeline_depth);
        let mut batch = Vec::with_capacity(batch_size);
        for index in 0..batch_size {
            batch.push(Request::get(format!("{}/p{}", base_url, sent + index)).expect("request"));
        }
        let responses = session.execute_pipelined(&batch).expect("execute");
        assert_eq!(responses.len(), batch_size);
        for response in responses {
            assert_eq!(response.body, b"hello");
        }
        sent += batch_size;
    }
    let elapsed = start.elapsed();
    handle.join().expect("join server");
    elapsed
}