attohttpc

The BodyKind enum describes how the request body is transmitted. This information is used to determine if the body has a known length or requires chunked encoding.

• Empty: No body content.
• KnownLength(u64): A body with a specific, pre-determined size.
• Chunked: A body transferred using chunked encoding (common for streaming data).

A Session is a container for settings that are applied to every request created from it. This allows you to define common headers, timeouts, proxy settings, and TLS configurations once and reuse them across multiple requests.

Session can be cloned cheaply and sent to other threads because it uses std::sync::Arc internally.

To use a session, create a new one with Session::new() and then use its HTTP method helpers (like .get(), .post(), etc.) to generate RequestBuilder instances that inherit the session's configuration.

use attohttpc::Session;
use std::time::Duration;

let mut session = Session::new();

// Configure the session
session.header("Authorization", "Bearer my_token");
session.connect_timeout(Duration::from_secs(5));

// Create requests using the session's settings
let response = session.get("https://api.example.com/data")
    .send()?
    .text()?;

The Body trait is the core abstraction for request payloads in attohttpc. Any type implementing Body can be used as a request body. The trait is designed to be rewindable, meaning the write method can be called multiple times (e.g., during HTTP redirects).

Key methods:

• kind(): Returns a BodyKind indicating if the length is known or if it is chunked.
• write<W: Write>(&mut self, writer: W): Writes the body content into the provided writer.
• content_type(): Returns an optional String representing the MIME type of the body.

The Multipart struct is the result of calling MultipartBuilder::build(). It implements the Body trait, meaning it can be passed directly into attohttpc request methods.

When used as a body:

• The Content-Type header is automatically set to multipart/form-data including the required boundary parameter.
• The body is streamed using Chunked encoding.

// Assuming 'client' is an attohttpc client
let body = MultipartBuilder::new()
    .with_text("field", "value")
    .build()?;

let response = client.post("https://example.com/upload")
    .body(body)
    .send()?;

attohttpc uses feature flags to keep the crate small. You can enable specific functionality by adding them to your Cargo.toml file.

Example:

attohttpc = { version = "...", features = ["json", "form", "multipart-form"] }

attohttpc = { version = "...", features = ["json", "form", ...] }

You can perform a POST request with a JSON body and deserialize the response using the .json() method. This requires the json feature flag to be enabled.

let resp = attohttpc::post("https://my-api.com/do/something")
    .json(&request)?
    .send()?;

if resp.is_success() {
    let response = resp.json()?;
    // ...
}

let resp = attohttpc::post("https://my-api.com/do/something").json(&request)?.send()?;
if resp.is_success() {
    let response = resp.json()?;
    // ...
}

The current feature set includes:

• Query parameters, Request headers, and Bodies.
• TLS management: adding trusted certificates and disabling verification (supported for both native-tls and rustls).
• Automatic redirection.
• Streaming response bodies.
• Multiple text encodings.
• Automatic compression/decompression (gzip or deflate).
• Transfer-Encoding: chunked support.
• serde/json support.
• HTTP Proxies: Supports proxying via configuration and the HTTP_PROXY, HTTPS_PROXY, and NO_PROXY environment variables.
• Happy Eyeballs implementation.
• Partial support for Authentication.

The ProxySettings::from_env() method initializes proxy settings following standard curl/Unix conventions. It looks for the following environment variables (case-insensitive):

• ALL_PROXY: A fallback proxy for all schemes.
• HTTP_PROXY: Proxy for http requests. Takes precedence over ALL_PROXY for HTTP.
• HTTPS_PROXY: Proxy for https requests. Takes precedence over ALL_PROXY for HTTPS.
• NO_PROXY: A comma-separated list of hostnames or domains that should bypass the proxy. If set to *, all proxies are disabled.

Note: HTTP_PROXY or HTTPS_PROXY will override the values set by ALL_PROXY for their respective schemes.

use attohttpc::request::proxy::ProxySettings;

// Loads settings from ALL_PROXY, HTTP_PROXY, HTTPS_PROXY, and NO_PROXY
let settings = ProxySettings::from_env();