silent 2.16.1

Silent Web Framework
Documentation 
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

use std::task::Poll;

use axum::body::Body as AxumBody;
use bytes::Bytes;
use futures::Stream;
use http::response::Parts;
use http_body::Body;
use pin_project_lite::pin_project;

pin_project! {
    pub(crate) struct GrpcStream{
        #[pin]
        body: AxumBody,
        parts: Parts,
    }
}

impl GrpcStream {
    pub fn new(body: AxumBody, parts: Parts) -> Self {
        Self { body, parts }
    }
}
fn title_case(dst: &mut Vec<u8>, name: &[u8]) {
    dst.reserve(name.len());

    // Ensure first character is uppercased
    let mut prev = b'-';
    for &(mut c) in name {
        if prev == b'-' {
            c.make_ascii_uppercase();
        }
        dst.push(c);
        prev = c;
    }
}
#[inline]
fn extend(dst: &mut Vec<u8>, data: &[u8]) {
    dst.extend_from_slice(data);
}
impl Stream for GrpcStream {
    type Item = crate::Result<Bytes>;

    fn poll_next(
        self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> Poll<Option<Self::Item>> {
        let mut stream = self.project();
        match stream.body.as_mut().poll_frame(cx) {
            Poll::Ready(Some(Ok(chunk))) => match chunk.into_data() {
                Ok(chunk) => Poll::Ready(Some(Ok(chunk))),
                Err(_e) => {
                    Poll::Ready(None)
                    // error!("Failed to convert chunk to bytes: {:?}", e);
                    // let mut buf = Vec::new();
                    // if e.is_trailers() {
                    //     let header_map = HeaderMap::with_capacity(3 + stream.parts.headers.len());
                    //     let mut trailers = e.into_trailers().unwrap();
                    //     trailers.extend(header_map);
                    //     for (name, value) in trailers.iter() {
                    //         title_case(&mut buf, name.as_str().as_bytes());
                    //         extend(&mut buf, b": ");
                    //         extend(&mut buf, value.as_bytes());
                    //         extend(&mut buf, b"\r\n");
                    //     }
                    // };
                    // if buf.is_empty() {
                    //     return Poll::Ready(None);
                    // }
                    // let mut trailer = Bytes::from_static(b"0\r\n").to_vec();
                    // trailer.extend_from_slice(buf.as_slice());
                    // trailer.extend_from_slice(b"\r\n");
                    // Poll::Ready(Some(Ok(Bytes::from(trailer))))
                }
            },
            Poll::Pending => Poll::Pending,
            _ => Poll::Ready(None),
        }
    }
    fn size_hint(&self) -> (usize, Option<usize>) {
        let size_hint = self.body.size_hint();
        (
            size_hint.lower() as usize,
            size_hint.upper().map(|x| x as usize),
        )
    }
}