kinetics 0.15.1

Kinetics is a hosting platform for Rust applications that allows you to deploy all types of workloads by writing **only Rust code**.
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use http_body::{Body as HttpBody, Frame, SizeHint};
use std::{borrow::Cow, mem::take, pin::Pin, task::Poll};

/// Request body supported by kinetics runtime.
/// In addition to empty bodies string and binary data are supported.
#[derive(Debug, Default, Eq, PartialEq)]
pub enum Body {
    /// An empty body
    #[default]
    Empty,
    /// A body containing string data
    Text(String),
    /// A body containing binary data
    Binary(Vec<u8>),
}

impl From<lambda_http::Body> for Body {
    fn from(value: lambda_http::Body) -> Self {
        match value {
            lambda_http::Body::Empty => Body::Empty,
            lambda_http::Body::Text(chars) => Body::Text(chars),
            lambda_http::Body::Binary(bytes) => Body::Binary(bytes),
            _ => unreachable!(),
        }
    }
}

impl TryFrom<Body> for lambda_http::Body {
    type Error = eyre::Error;

    fn try_from(value: Body) -> Result<Self, Self::Error> {
        match value {
            Body::Empty => Ok(lambda_http::Body::Empty),
            Body::Text(chars) => Ok(lambda_http::Body::Text(chars)),
            Body::Binary(bytes) => Ok(lambda_http::Body::Binary(bytes)),
        }
    }
}

impl TryFrom<Body> for () {
    type Error = eyre::Error;

    fn try_from(_value: Body) -> Result<Self, Self::Error> {
        // Unit struct usually implies no payload,
        // thus we just throw the body away.
        Ok(())
    }
}

impl TryFrom<Body> for String {
    type Error = eyre::Error;

    fn try_from(value: Body) -> Result<Self, Self::Error> {
        match value {
            Body::Empty => Ok(String::new()),
            Body::Text(chars) => Ok(chars),
            Body::Binary(bytes) => Ok(String::from_utf8(bytes)?),
        }
    }
}

impl TryFrom<Body> for Vec<u8> {
    type Error = eyre::Error;

    fn try_from(value: Body) -> Result<Self, Self::Error> {
        match value {
            Body::Empty => Ok(Vec::new()),
            Body::Text(chars) => Ok(chars.into_bytes()),
            Body::Binary(bytes) => Ok(bytes),
        }
    }
}

// The remaining implementation are copied from
// https://github.com/awslabs/aws-lambda-rust-runtime/blob/main/lambda-events/src/encodings/http.rs#L96-L144
// https://github.com/awslabs/aws-lambda-rust-runtime/blob/main/lambda-events/src/encodings/http.rs#L219-L246

impl From<()> for Body {
    fn from(_: ()) -> Self {
        Body::Empty
    }
}

impl<'a> From<&'a str> for Body {
    fn from(s: &'a str) -> Self {
        Body::Text(s.into())
    }
}

impl From<String> for Body {
    fn from(b: String) -> Self {
        Body::Text(b)
    }
}

impl From<Cow<'static, str>> for Body {
    #[inline]
    fn from(cow: Cow<'static, str>) -> Body {
        match cow {
            Cow::Borrowed(b) => Body::from(b.to_owned()),
            Cow::Owned(o) => Body::from(o),
        }
    }
}

impl From<Cow<'static, [u8]>> for Body {
    #[inline]
    fn from(cow: Cow<'static, [u8]>) -> Body {
        match cow {
            Cow::Borrowed(b) => Body::from(b),
            Cow::Owned(o) => Body::from(o),
        }
    }
}

impl From<Vec<u8>> for Body {
    fn from(b: Vec<u8>) -> Self {
        Body::Binary(b)
    }
}

impl<'a> From<&'a [u8]> for Body {
    fn from(b: &'a [u8]) -> Self {
        Body::Binary(b.to_vec())
    }
}

impl HttpBody for Body {
    type Data = bytes::Bytes;
    type Error = tower::BoxError;

    fn is_end_stream(&self) -> bool {
        matches!(self, Body::Empty)
    }

    fn size_hint(&self) -> SizeHint {
        match self {
            Body::Empty => SizeHint::default(),
            Body::Text(ref s) => SizeHint::with_exact(s.len() as u64),
            Body::Binary(ref b) => SizeHint::with_exact(b.len() as u64),
        }
    }

    fn poll_frame(
        self: Pin<&mut Self>,
        _cx: &mut std::task::Context<'_>,
    ) -> Poll<Option<Result<Frame<Self::Data>, Self::Error>>> {
        let body = take(self.get_mut());
        Poll::Ready(match body {
            Body::Empty => None,
            Body::Text(s) => Some(Ok(Frame::data(s.into()))),
            Body::Binary(b) => Some(Ok(Frame::data(b.into()))),
        })
    }
}