Struct ResponseWriterService 

pub struct ResponseWriterService<S, W> { /* private fields */ }

Available on crate features http and std only.

Middleware to print Http responses in std format.

Response bodies are observed while they stream to the caller. The writer receives an owned body stream and processes frames concurrently.

See the module docs for more details.

Implementations

impl<S, W> ResponseWriterService<S, W>

pub fn new(writer: W, inner: S) -> ResponseWriterService<S, W>

Create a new ResponseWriterService with a custom ResponseWriter.

Use Self::new_with_executor when streaming writer tasks must participate in graceful shutdown.

pub fn new_with_executor( writer: W, inner: S, executor: Executor, ) -> ResponseWriterService<S, W>

Create a new ResponseWriterService with a custom ResponseWriter and executor for streaming writer tasks.

pub fn get_ref(&self) -> &S

Gets a reference to the underlying service.

pub fn into_inner(self) -> S

Consumes self, returning the underlying service.

impl<S> ResponseWriterService<S, UnboundedSender<Response>>

pub fn writer_unbounded<W>( executor: &Executor, writer: W, mode: Option<WriterMode>, inner: S, ) -> ResponseWriterService<S, UnboundedSender<Response>>

where W: AsyncWrite + Unpin + Send + Sync + 'static,

Create a new ResponseWriterService that prints responses to an [AsyncWrite]r over an unbounded channel

pub fn stdout_unbounded( executor: &Executor, mode: Option<WriterMode>, inner: S, ) -> ResponseWriterService<S, UnboundedSender<Response>>

Create a new ResponseWriterService that prints responses to stdout over an unbounded channel.

pub fn stderr_unbounded( executor: &Executor, mode: Option<WriterMode>, inner: S, ) -> ResponseWriterService<S, UnboundedSender<Response>>

Create a new ResponseWriterService that prints responses to stderr over an unbounded channel.

impl<S> ResponseWriterService<S, PerMessageFileWriter>

pub async fn file_per_response( executor: &Executor, directory: impl Into<PathBuf>, prefix: impl AsRef<str>, mode: Option<WriterMode>, inner: S, ) -> Result<ResponseWriterService<S, PerMessageFileWriter>, Error>

Create a service that streams every response into a unique file below directory using the portable filename prefix.

impl<S> ResponseWriterService<S, Sender<Response>>

pub fn writer<W>( executor: &Executor, writer: W, buffer_size: usize, mode: Option<WriterMode>, inner: S, ) -> ResponseWriterService<S, Sender<Response>>

where W: AsyncWrite + Unpin + Send + Sync + 'static,

Create a new ResponseWriterService that prints responses to an [AsyncWrite]r over a bounded channel with a fixed buffer size.

pub fn stdout( executor: &Executor, buffer_size: usize, mode: Option<WriterMode>, inner: S, ) -> ResponseWriterService<S, Sender<Response>>

Create a new ResponseWriterService that prints responses to stdout over a bounded channel with a fixed buffer size.

pub fn stderr( executor: &Executor, buffer_size: usize, mode: Option<WriterMode>, inner: S, ) -> ResponseWriterService<S, Sender<Response>>

Create a new ResponseWriterService that prints responses to stderr over a bounded channel with a fixed buffer size.

Trait Implementations

impl<S, W> Clone for ResponseWriterService<S, W>

where S: Clone, W: Clone,

fn clone(&self) -> ResponseWriterService<S, W>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S, W> Debug for ResponseWriterService<S, W>

where S: Debug,

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

Formats the value using the given formatter.

impl<S, W, ReqBody, ResBody> Service<Request<ReqBody>> for ResponseWriterService<S, W>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, <S as Service<Request<ReqBody>>>::Error: Into<Box<dyn Error + Sync + Send>>, W: ResponseWriter, ReqBody: Send + 'static, ResBody: Body<Data = Bytes> + Send + Sync + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Sync + Send>>,

type Output = Response

The type of the output returned by the service.

type Error = Box<dyn Error + Sync + Send>

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<<ResponseWriterService<S, W> as Service<Request<ReqBody>>>::Output, <ResponseWriterService<S, W> as Service<Request<ReqBody>>>::Error>

Serve an output or an error for the given input

fn boxed(self) -> BoxService<Input, Self::Output, Self::Error>

Box this service to allow for dynamic dispatch.