Struct Backend

Source

pub struct Backend { /* private fields */ }

Expand description

A named backend.

This represents a backend associated with a service that we can send requests to, potentially caching the responses received.

Backends come in one of two flavors:

Static Backends: These backends are created using the Fastly UI or API, and are predefined by the user. Static backends have short names (see the precise naming rules in Backend::from_name) that are usable across every session of a service.
Dynamic Backends: These backends are created programmatically using the Backend::builder API. They are defined at runtime, and may or may not be shared across sessions depending on how they are configured.

To use a backend, pass it to the crate::Request::send method. Alternatively, the following values can be automatically coerced into a backend for you, without the need to explicitly create a Backend object, although they may all induce panics:

Any string type (&str, String, or &String) will be automatically turned into the static backend of the same name.

§Using Static Backends

As stated at the top level, the following snippet is a minimal program that resends a request to a static backend named “example_backend”:

use fastly::{Error, Request, Response};

#[fastly::main]
fn main(ds_req: Request) -> Result<Response, Error> {
    Ok(ds_req.send("example_backend")?)
}

A safer alternative to this example would be the following:

use fastly::{Backend, Error, Request, Response};

#[fastly::main]
fn main(ds_req: Request) -> Result<Response, Error> {
    match Backend::from_name("example_backend") {
       Ok(backend) => Ok(ds_req.send(backend)?),
       Err(_) => {
            // custom backend failure response
            unimplemented!()
       }
    }
}

as this version allows you to handle backend errors more cleanly.

§Validating Support for Dynamic Backends

Since dynamic backends are only enabled for some services, it may be particularly useful to ensure that dynamic backends are supported in your Compute service. The easiest way to do so is to try to create a dynamic backend, and then explicitly check for the crate::backend::BackendCreationError::Disallowed code, as follows:

use fastly::{Backend, Error, Request, Response};
use fastly::backend::BackendCreationError;

#[fastly::main]
fn main(ds_req: Request) -> Result<Response, Error> {
    match Backend::builder("custom_backend", "example.org:993").finish() {
        Ok(backend) => Ok(ds_req.send(backend)?),
        Err(BackendCreationError::Disallowed) => {
           // custom code ofr handling when dynamic backends aren't supported
           unimplemented!()
        }
        Err(err) => {
           // more specific logging/handling for backend misconfigurations
           unimplemented!()
        }
    }
}

Struct Backend Copy item path

§Using Static Backends

§Validating Support for Dynamic Backends

Implementations§

impl Backend

pub fn from_name(s: &str) -> Result<Self, BackendError>

pub fn builder(name: impl ToString, target: impl ToString) -> BackendBuilder

pub fn name(&self) -> &str

pub fn into_string(self) -> String

pub fn exists(&self) -> bool

pub fn is_dynamic(&self) -> bool

§Panics

pub fn get_host(&self) -> String

§Panics

pub fn get_host_override(&self) -> Option<HeaderValue>

§Panics

pub fn get_port(&self) -> u16

§Panics

pub fn get_connect_timeout(&self) -> Duration

§Panics

pub fn get_first_byte_timeout(&self) -> Duration

§Panics

pub fn get_between_bytes_timeout(&self) -> Duration

§Panics

pub fn get_http_keepalive_time(&self) -> Duration

§Panics

pub fn get_tcp_keepalive_enable(&self) -> bool

§Panics

pub fn get_tcp_keepalive_interval(&self) -> Duration

§Panics

pub fn get_tcp_keepalive_probes(&self) -> u32

§Panics

pub fn get_tcp_keepalive_time(&self) -> Duration

§Panics

pub fn is_ssl(&self) -> bool

§Panics

pub fn get_ssl_min_version(&self) -> Option<SslVersion>

§Panics

pub fn get_ssl_max_version(&self) -> Option<SslVersion>

§Panics

impl Backend

pub fn healthcheck_builder(host: impl ToString) -> HealthcheckBuilder

Trait Implementations§

impl BackendExt for Backend

fn is_healthy(&self) -> Result<BackendHealth, Error>

impl Clone for Backend

fn clone(&self) -> Backend

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

impl Debug for Backend

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

impl Display for Backend

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

impl Eq for Backend

impl FromStr for Backend

type Err = BackendError

fn from_str(s: &str) -> Result<Self, Self::Err>

impl Hash for Backend

fn hash<__H: Hasher>(&self, state: &mut __H)

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

impl Ord for Backend

fn cmp(&self, other: &Backend) -> Ordering

fn max(self, other: Self) -> Selfwhere Self: Sized,

fn min(self, other: Self) -> Selfwhere Self: Sized,

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized,

impl PartialEq for Backend

fn eq(&self, other: &Backend) -> bool

fn ne(&self, other: &Rhs) -> bool

impl PartialOrd for Backend

fn partial_cmp(&self, other: &Backend) -> Option<Ordering>

fn lt(&self, other: &Rhs) -> bool

fn le(&self, other: &Rhs) -> bool

fn gt(&self, other: &Rhs) -> bool

fn ge(&self, other: &Rhs) -> bool

impl StructuralPartialEq for Backend

impl ToBackend for Backend

impl<'a> ToBackend for &'a Backend

Auto Trait Implementations§

impl Freeze for Backend

impl RefUnwindSafe for Backend

impl Send for Backend

Struct Backend

fn hash<H: Hasher>(&self, state: &mut H)

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

fn max(self, other: Self) -> Self
where Self: Sized,

fn min(self, other: Self) -> Self
where Self: Sized,

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

impl<Q, K> Comparable<K> for Q
where Q: Ord + ?Sized, K: Borrow<Q> + ?Sized,

impl<T> Downcast for T
where T: Any,

impl<T> DowncastSync for T
where T: Any + Send + Sync,

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

impl<T> ErasedDestructor for T
where T: 'static,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

impl<T> ToOwned for T
where T: Clone,

impl<T> ToString for T
where T: Display + ?Sized,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,