1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
pub(crate) mod handle;
use self::handle::StreamingBodyHandle;
use super::Body;
use std::io::{BufWriter, Write};
/// A streaming HTTP body that can be written to, or appended to from another body.
///
/// The interface to this type is very similar to `Body`, however it is write-only, and can only be
/// created as a result of calling
/// [`Response::stream_to_client()`][`crate::Response::stream_to_client()`] or
/// [`Request::send_async_streaming()`][`crate::Request::send_async_streaming()`].
///
/// The most efficient way to write the body is through the [`Write`] implementation. Writes are
/// buffered, and automatically flushed, but you can call [`Write::flush()`] to explicitly flush the
/// buffer and cause a new chunk to be written to the client.
///
/// A streaming body will be automatically closed when it goes out of scope, or when it is passed to
/// [`drop()`].
pub struct StreamingBody {
writer: BufWriter<StreamingBodyHandle>,
}
impl StreamingBody {
// this is not exported, since misuse can lead to data getting dropped or appearing out of order
fn handle(&mut self) -> &mut StreamingBodyHandle {
self.writer.get_mut()
}
/// Append a body onto the end of this streaming body.
///
#[doc = include_str!("../../../docs/snippets/body-append-constant-time.md")]
///
/// # Examples
///
/// ```no_run
/// # use fastly::{Body, Response};
/// # let beresp = Response::new();
/// # let other_body = Body::new();
/// let mut streaming_body = beresp.stream_to_client();
/// streaming_body.append(other_body);
/// ```
pub fn append(&mut self, other: Body) {
// flush the write buffer of the destination body, so that we can use the append method on
// the underlying handles
self.writer.flush().expect("fastly_http_body::write failed");
self.handle().append(other.into_handle())
}
/// Write a slice of bytes to the end of this streaming body, and return the number of bytes written.
///
/// # Examples
///
/// ```no_run
/// # let resp = fastly::Response::new();
/// let mut streaming_body = resp.stream_to_client();
/// streaming_body.write_bytes(&[0, 1, 2, 3]);
/// ```
pub fn write_bytes(&mut self, bytes: &[u8]) -> usize {
self.writer
.write(bytes)
.expect("fastly_http_body::write failed")
}
/// Write a string slice to the end of this streaming body, and return the number of bytes
/// written.
///
/// # Examples
///
/// ```no_run
/// # let resp = fastly::Response::new();
/// let mut streaming_body = resp.stream_to_client();
/// streaming_body.write_str("woof woof");
/// ```
pub fn write_str(&mut self, string: &str) -> usize {
self.write_bytes(string.as_ref())
}
}
impl From<StreamingBodyHandle> for StreamingBody {
fn from(handle: StreamingBodyHandle) -> Self {
Self {
writer: BufWriter::new(handle),
}
}
}
// This trait implementation is much simpler than those of `Body`, since we don't have to manage
// multiple buffers. It's just a passthrough to the methods defined on `BufWriter`.
impl Write for StreamingBody {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
self.writer.write(buf)
}
fn write_vectored(&mut self, bufs: &[std::io::IoSlice<'_>]) -> std::io::Result<usize> {
self.writer.write_vectored(bufs)
}
fn flush(&mut self) -> std::io::Result<()> {
self.writer.flush()
}
}