Struct StaticFilesHandler

pub struct StaticFilesHandler { /* private fields */ }

Static Files module handler

Trait Implementations

impl Clone for StaticFilesHandler

fn clone(&self) -> StaticFilesHandler

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StaticFilesHandler

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

Formats the value using the given formatter.

impl PartialEq for StaticFilesHandler

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl RequestFilter for StaticFilesHandler

type Conf = StaticFilesConf

Configuration type of this handler.

type CTX = ()

Per-request state of this handler, see [pingora::ProxyHttp::CTX]

fn new_ctx() -> Self::CTX

Creates a new state object, see [pingora::ProxyHttp::new_ctx]

fn request_filter<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session: &'life1 mut Session, _ctx: &'life2 mut Self::CTX, ) -> Pin<Box<dyn Future<Output = Result<RequestFilterResult, Box<Error>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handler to run during Pingora’s request_filter phase, see [pingora::ProxyHttp::request_filter]. This uses a different return type to account for the existence of multiple chained handlers.

fn new(conf: Self::Conf) -> Result<Self, Box<Error>>

where Self: Sized, Self::Conf: TryInto<Self, Error = Box<Error>>,

Creates a new instance of the handler from its configuration.

fn init_downstream_modules(_modules: &mut HttpModules)

Handler to run during Pingora’s init_downstream_modules phase, see [pingora::ProxyHttp::init_downstream_modules].

fn early_request_filter<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _session: &'life1 mut Session, _ctx: &'life2 mut Self::CTX, ) -> Pin<Box<dyn Future<Output = Result<(), Box<Error>>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handler to run during Pingora’s early_request_filter phase, see [pingora::ProxyHttp::early_request_filter].

fn handle<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session: &'life1 mut Session, ctx: &'life2 mut Self::CTX, ) -> Pin<Box<dyn Future<Output = Result<bool, Box<Error>>> + Send + 'async_trait>>

where Self::CTX: Send, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn upstream_peer<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _session: &'life1 mut Session, _ctx: &'life2 mut Self::CTX, ) -> Pin<Box<dyn Future<Output = Result<Option<Box<HttpPeer>>, Box<Error>>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handler to run during Pingora’s upstream_peer phase, see [pingora::ProxyHttp::upstream_peer]. Unlike Pingora’s method, here returning a result is optional. If None is returned, other handlers in the chain will be called. If all of them return None, an error will be returned to Pingora.

fn logging<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _session: &'life1 mut Session, _e: Option<&'life2 Error>, _ctx: &'life3 mut Self::CTX, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handler to run during Pingora’s logging phase, see [pingora::ProxyHttp::logging].

impl TryFrom<StaticFilesConf> for StaticFilesHandler

type Error = Box<Error>

The type returned in the event of a conversion error.

fn try_from(conf: StaticFilesConf) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for StaticFilesHandler

impl StructuralPartialEq for StaticFilesHandler