Struct GrpcWebBridge 

pub struct GrpcWebBridge(/* private fields */);

gRPC-web bridge module, this will convert HTTP/1.1 gRPC-web requests to H2 gRPC requests

Methods from Deref<Target = GrpcWebCtx>

pub fn init(&mut self)

pub fn request_header_filter(&mut self, req: &mut RequestHeader)

gRPC-web request is fed into this filter, if the module is initialized we attempt to convert it to a gRPC request

pub fn response_header_filter(&mut self, resp: &mut ResponseHeader)

gRPC response is fed into this filter, if the module is in the bridge state attempt to convert the response it to a gRPC-web response

pub fn response_trailer_filter( &mut self, resp_trailers: &mut HeaderMap, ) -> Result<Option<Bytes>, Box<Error>>

Used to convert gRPC trailers into gRPC-web trailers, note gRPC-web trailers are encoded into the response body so we return the encoded bytes here.

Trait Implementations

impl Default for GrpcWebBridge

fn default() -> GrpcWebBridge

Returns the “default value” for a type.

impl Deref for GrpcWebBridge

type Target = GrpcWebCtx

The resulting type after dereferencing.

fn deref(&self) -> &<GrpcWebBridge as Deref>::Target

Dereferences the value.

impl DerefMut for GrpcWebBridge

fn deref_mut(&mut self) -> &mut <GrpcWebBridge as Deref>::Target

Mutably dereferences the value.

impl HttpModule for GrpcWebBridge

fn as_any(&self) -> &(dyn Any + 'static)

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

fn request_header_filter<'life0, 'life1, 'async_trait>( &'life0 mut self, req: &'life1 mut RequestHeader, ) -> Pin<Box<dyn Future<Output = Result<(), Box<Error>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, GrpcWebBridge: 'async_trait,

fn response_header_filter<'life0, 'life1, 'async_trait>( &'life0 mut self, resp: &'life1 mut ResponseHeader, _end_of_stream: bool, ) -> Pin<Box<dyn Future<Output = Result<(), Box<Error>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, GrpcWebBridge: 'async_trait,

fn response_trailer_filter( &mut self, trailers: &mut Option<Box<HeaderMap>>, ) -> Result<Option<Bytes>, Box<Error>>

fn request_body_filter<'life0, 'life1, 'async_trait>( &'life0 mut self, _body: &'life1 mut Option<Bytes>, _end_of_stream: bool, ) -> Pin<Box<dyn Future<Output = Result<(), Box<Error>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Send + 'async_trait,

fn response_body_filter( &mut self, _body: &mut Option<Bytes>, _end_of_stream: bool, ) -> Result<(), Box<Error>>

fn response_done_filter(&mut self) -> Result<Option<Bytes>, Box<Error>>