Crate nightfly_twitchax_patch

nightfly

The nightfly crate provides a convenient, higher-level HTTP Client.

It handles many of the things that most people just expect an HTTP client to do for them.

• Reusable, cloneable and serialisable Clients
• Plain bodies, JSON, urlencoded
• Customizable redirect policy
• Uses vm-native [TLS]
• Cookies

Additional learning resources include:

• Nightfly Repository Examples

Making a GET request

For a single request, you can use the get shortcut method.

let body = nightfly::get("https://www.rust-lang.org").text();

println!("body = {:?}", body);

NOTE: If you plan to perform multiple requests, it is best to create a Client and reuse it, taking advantage of keep-alive connection pooling.

Making POST requests (or setting request bodies)

There are several ways you can set the body of a request. The basic one is by using the body() method of a RequestBuilder. This lets you set the exact raw bytes of what the body should be. It accepts various types, including String and Vec<u8>. If you wish to pass a custom type, you can use the nightfly::Body constructors.

let client = nightfly::Client::new();
let res = client.post("http://httpbin.org/post")
    .body("the exact body that is sent")
    .send();

Forms

It’s very common to want to send form data in a request body. This can be done with any type that can be serialized into form data.

This can be an array of tuples, or a HashMap, or a custom type that implements Serialize.

// This will POST a body of `foo=bar&baz=quux`
let params = [("foo", "bar"), ("baz", "quux")];
let client = nightfly::Client::new();
let res = client.post("http://httpbin.org/post")
    .form(&params)
    .send();

JSON

There is also a json method helper on the RequestBuilder that works in a similar fashion the form method. It can take any value that can be serialized into JSON. The feature json is required.

// This will POST a body of `{"lang":"rust","body":"json"}`
let mut map = HashMap::new();
map.insert("lang", "rust");
map.insert("body", "json");

let client = nightfly::Client::new();
let res = client.post("http://httpbin.org/post")
    .json(&map)
    .send();

Redirect Policies

By default, a Client will automatically handle HTTP redirects, having a maximum redirect chain of 10 hops. To customize this behavior, a redirect::Policy can be used with a ClientBuilder.

Cookies

The automatic storing and sending of session cookies can be enabled with the [cookie_store][ClientBuilder::cookie_store] method on ClientBuilder.

Optional Features

The following are a list of Cargo features that can be enabled or disabled:

• cookies: Provides cookie session support.

Modules

• cookie
  HTTP Cookies
• header
  HTTP header types
• redirect
  Redirect Handling

Structs

• Body
  Body struct
• Client
  An http Client to make Requests with.
• ClientBuilder
  A ClientBuilder can be used to create a Client with custom configuration.
• Error
  The Errors that may occur when processing a Request.
• HeaderMap
  A set of HTTP headers
• HeaderValue
  Represents an HTTP header field value.
• HttpResponse
  Response of an http request
• Method
  The Request Method (VERB)
• Request
  A request which can be executed with Client::execute().
• RequestBuilder
  A builder to construct the properties of a Request.
• SerializableResponse
  A Response to a submitted Request.
• StatusCode
  An HTTP status code (status-code in RFC 7230 et al.).
• Url
  A parsed URL record.
• Version
  Represents a version of the HTTP spec.

Traits

• IntoUrl
  A trait to try to convert some type into a Url.
• ResponseBuilderExt
  Extension trait for http::response::Builder objects

Functions

• get
  Shortcut method to quickly make a GET request.

Type Aliases

• Result
  A Result alias where the Err case is nightfly::Error.