Struct StreamingResponse 

pub struct StreamingResponse<S> {
    pub status: StatusCode,
    pub headers: HeaderMap,
    pub stream: S,
}

Streaming HTTP Response

Fields

status: StatusCode

headers: HeaderMap

stream: S

Implementations

impl<S> StreamingResponse<S>

where S: Stream<Item = Result<Bytes, Box<dyn Error + Send + Sync>>> + Send + 'static,

pub fn new(stream: S) -> Self

Create a new streaming response with OK status

Examples

use reinhardt_http::StreamingResponse;
use hyper::StatusCode;
use futures::stream;
use bytes::Bytes;

let data = vec![Ok(Bytes::from("chunk1")), Ok(Bytes::from("chunk2"))];
let stream = stream::iter(data);
let response = StreamingResponse::new(stream);

assert_eq!(response.status, StatusCode::OK);

pub fn with_status(stream: S, status: StatusCode) -> Self

Create a streaming response with a specific status code

Examples

use reinhardt_http::StreamingResponse;
use hyper::StatusCode;
use futures::stream;
use bytes::Bytes;

let data = vec![Ok(Bytes::from("data"))];
let stream = stream::iter(data);
let response = StreamingResponse::with_status(stream, StatusCode::PARTIAL_CONTENT);

assert_eq!(response.status, StatusCode::PARTIAL_CONTENT);

pub fn status(self, status: StatusCode) -> Self

Set the status code

Examples

use reinhardt_http::StreamingResponse;
use hyper::StatusCode;
use futures::stream;
use bytes::Bytes;

let data = vec![Ok(Bytes::from("data"))];
let stream = stream::iter(data);
let response = StreamingResponse::new(stream).status(StatusCode::ACCEPTED);

assert_eq!(response.status, StatusCode::ACCEPTED);

pub fn header(self, key: HeaderName, value: HeaderValue) -> Self

Add a header to the streaming response

Examples

use reinhardt_http::StreamingResponse;
use hyper::header::{HeaderName, HeaderValue, CACHE_CONTROL};
use futures::stream;
use bytes::Bytes;

let data = vec![Ok(Bytes::from("data"))];
let stream = stream::iter(data);
let response = StreamingResponse::new(stream)
    .header(CACHE_CONTROL, HeaderValue::from_static("no-cache"));

assert_eq!(
    response.headers.get(CACHE_CONTROL).unwrap().to_str().unwrap(),
    "no-cache"
);

pub fn media_type(self, media_type: &str) -> Self

Set the Content-Type header (media type)

Examples

use reinhardt_http::StreamingResponse;
use hyper::header::CONTENT_TYPE;
use futures::stream;
use bytes::Bytes;

let data = vec![Ok(Bytes::from("data"))];
let stream = stream::iter(data);
let response = StreamingResponse::new(stream).media_type("video/mp4");

assert_eq!(
    response.headers.get(CONTENT_TYPE).unwrap().to_str().unwrap(),
    "video/mp4"
);

impl<S> StreamingResponse<S>

pub fn into_stream(self) -> S

Consume the response and return the underlying stream

Examples

use reinhardt_http::StreamingResponse;
use futures::stream::{self, StreamExt};
use bytes::Bytes;

let data = vec![Ok(Bytes::from("chunk1")), Ok(Bytes::from("chunk2"))];
let stream = stream::iter(data);
let response = StreamingResponse::new(stream);

let mut extracted_stream = response.into_stream();
let first_chunk = extracted_stream.next().await.unwrap().unwrap();
assert_eq!(first_chunk, Bytes::from("chunk1"));