Struct serenity::http::client::HttpBuilder

pub struct HttpBuilder<'a> { /* fields omitted */ }

A builder implementing Future building a Http client to perform requests to Discord’s HTTP API. If you do not need to use a proxy or do not need to disable the rate limiter, you can use Http::new or Http::new_with_token instead.

Example

Create an instance of Http with a proxy and rate limiter disabled

let http = HttpBuilder::new("token")
    .proxy("http://127.0.0.1:3000")
    .expect("Invalid proxy URL")
    .ratelimiter_disabled(true)
    .await
    .expect("Error creating Http");

Implementations

impl<'a> HttpBuilder<'a>

pub fn new(token: impl AsRef<str>) -> Self

Construct a new builder to call methods on for the HTTP construction. The token will automatically be prefixed “Bot “ if not already.

pub fn application_id(self, application_id: u64) -> Self

Sets the application_id to use interactions.

pub fn token(self, token: impl AsRef<str>) -> Self

Sets a token for the bot. If the token is not prefixed “Bot “, this method will automatically do so.

pub fn client(self, client: Arc<Client>) -> Self

Sets the reqwest::Client. If one isn’t provided, a default one will be used.

pub fn ratelimiter(self, ratelimiter: Ratelimiter) -> Self

Sets the ratelimiter to be used. If one isn’t provided, a default one will be used.

pub fn ratelimiter_disabled(self, ratelimiter_disabled: bool) -> Self

Sets whether or not the ratelimiter is disabled. By default if this this not used, it is enabled. In most cases, this should be used in conjunction with Self::proxy.

Note: You should not disable the ratelimiter unless you have another form of rate limiting. Disabling the ratelimiter has the main purpose of delegating rate limiting to an API proxy via Self::proxy instead of the current process.

pub fn proxy(self, proxy: impl Into<String>) -> Result<Self>

Sets the proxy that Discord HTTP API requests will be passed to. This is mainly intended for something like twilight-http-proxy where multiple processes can make API requests while sharing a single ratelimiter.

The proxy should be in the form of the protocol and hostname, e.g. http://127.0.0.1:3000 or http://myproxy.example

This will simply send HTTP API requests to the proxy instead of Discord API to allow the proxy to intercept, rate limit, and forward requests. This is different than a native proxy’s behavior where it will tunnel requests that use TLS via HTTP CONNECT method (e.g. using reqwest::Proxy).

Trait Implementations

impl<'a> Future for HttpBuilder<'a>

type Output = Result<Http>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, ctx: &mut FutContext<'_>) -> Poll<Self::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.