mirror of https://github.com/http-rs/http-types
229 lines
7.3 KiB
Rust
229 lines
7.3 KiB
Rust
// This is the compat file for the "hyperium/http" crate.
|
|
|
|
use crate::headers::{HeaderName, HeaderValue, Headers};
|
|
use crate::{Body, Error, Method, Request, Response, StatusCode, Url, Version};
|
|
use std::convert::{TryFrom, TryInto};
|
|
use std::str::FromStr;
|
|
|
|
impl From<http::Method> for Method {
|
|
fn from(method: http::Method) -> Self {
|
|
Method::from_str(method.as_str()).unwrap()
|
|
}
|
|
}
|
|
|
|
impl From<Method> for http::Method {
|
|
fn from(method: Method) -> Self {
|
|
http::Method::from_str(method.as_ref()).unwrap()
|
|
}
|
|
}
|
|
|
|
impl From<http::StatusCode> for StatusCode {
|
|
fn from(status: http::StatusCode) -> Self {
|
|
StatusCode::try_from(status.as_u16()).unwrap()
|
|
}
|
|
}
|
|
|
|
impl From<StatusCode> for http::StatusCode {
|
|
fn from(status: StatusCode) -> Self {
|
|
http::StatusCode::from_u16(status.into()).unwrap()
|
|
}
|
|
}
|
|
|
|
impl From<http::Version> for Version {
|
|
fn from(version: http::Version) -> Self {
|
|
match version {
|
|
http::Version::HTTP_09 => Version::Http0_9,
|
|
http::Version::HTTP_10 => Version::Http1_0,
|
|
http::Version::HTTP_11 => Version::Http1_1,
|
|
http::Version::HTTP_2 => Version::Http2_0,
|
|
http::Version::HTTP_3 => Version::Http3_0,
|
|
_ => panic!("unknown HTTP version conversion"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<Version> for http::Version {
|
|
fn from(version: Version) -> Self {
|
|
match version {
|
|
Version::Http0_9 => http::Version::HTTP_09,
|
|
Version::Http1_0 => http::Version::HTTP_10,
|
|
Version::Http1_1 => http::Version::HTTP_11,
|
|
Version::Http2_0 => http::Version::HTTP_2,
|
|
Version::Http3_0 => http::Version::HTTP_3,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl TryFrom<http::header::HeaderName> for HeaderName {
|
|
type Error = Error;
|
|
|
|
fn try_from(name: http::header::HeaderName) -> Result<Self, Self::Error> {
|
|
let name = name.as_str().as_bytes().to_owned();
|
|
HeaderName::from_bytes(name)
|
|
}
|
|
}
|
|
|
|
impl TryFrom<HeaderName> for http::header::HeaderName {
|
|
type Error = Error;
|
|
|
|
fn try_from(name: HeaderName) -> Result<Self, Self::Error> {
|
|
let name = name.as_str().as_bytes();
|
|
http::header::HeaderName::from_bytes(name).map_err(|e| Error::new_adhoc(e))
|
|
}
|
|
}
|
|
|
|
impl TryFrom<http::header::HeaderValue> for HeaderValue {
|
|
type Error = Error;
|
|
|
|
fn try_from(value: http::header::HeaderValue) -> Result<Self, Self::Error> {
|
|
let value = value.as_bytes().to_owned();
|
|
HeaderValue::from_bytes(value)
|
|
}
|
|
}
|
|
|
|
impl TryFrom<HeaderValue> for http::header::HeaderValue {
|
|
type Error = Error;
|
|
|
|
fn try_from(value: HeaderValue) -> Result<Self, Self::Error> {
|
|
let value = value.as_str().as_bytes();
|
|
http::header::HeaderValue::from_bytes(value).map_err(|e| Error::new_adhoc(e))
|
|
}
|
|
}
|
|
|
|
impl TryFrom<http::HeaderMap> for Headers {
|
|
type Error = Error;
|
|
|
|
fn try_from(hyperium_headers: http::HeaderMap) -> Result<Self, Self::Error> {
|
|
let mut headers = Headers::new();
|
|
|
|
hyperium_headers
|
|
.into_iter()
|
|
.map(|(name, value)| {
|
|
if let Some(name) = name {
|
|
let value: HeaderValue = value.try_into()?;
|
|
let name: HeaderName = name.try_into()?;
|
|
headers.append(name, value);
|
|
}
|
|
Ok(())
|
|
})
|
|
.collect::<Result<Vec<()>, Error>>()?;
|
|
|
|
Ok(headers)
|
|
}
|
|
}
|
|
|
|
impl TryFrom<Headers> for http::HeaderMap {
|
|
type Error = Error;
|
|
|
|
fn try_from(headers: Headers) -> Result<Self, Self::Error> {
|
|
let mut hyperium_headers = http::HeaderMap::new();
|
|
|
|
headers
|
|
.into_iter()
|
|
.map(|(name, values)| {
|
|
let name: http::header::HeaderName = name.try_into()?;
|
|
|
|
values
|
|
.into_iter()
|
|
.map(|value| {
|
|
let value: http::header::HeaderValue = value.try_into()?;
|
|
hyperium_headers.append(&name, value);
|
|
Ok(())
|
|
})
|
|
.collect::<Result<Vec<()>, Error>>()?;
|
|
|
|
Ok(())
|
|
})
|
|
.collect::<Result<Vec<()>, Error>>()?;
|
|
|
|
Ok(hyperium_headers)
|
|
}
|
|
}
|
|
|
|
fn hyperium_headers_to_headers(hyperium_headers: http::HeaderMap, headers: &mut Headers) {
|
|
for (name, value) in hyperium_headers {
|
|
let value = value.as_bytes().to_owned();
|
|
let value = unsafe { HeaderValue::from_bytes_unchecked(value) };
|
|
if let Some(name) = name {
|
|
let name = name.as_str().as_bytes().to_owned();
|
|
let name = unsafe { HeaderName::from_bytes_unchecked(name) };
|
|
headers.append(name, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn headers_to_hyperium_headers(headers: &mut Headers, hyperium_headers: &mut http::HeaderMap) {
|
|
for (name, values) in headers {
|
|
let name = format!("{}", name).into_bytes();
|
|
let name = http::header::HeaderName::from_bytes(&name).unwrap();
|
|
|
|
for value in values.iter() {
|
|
let value = format!("{}", value).into_bytes();
|
|
let value = http::header::HeaderValue::from_bytes(&value).unwrap();
|
|
hyperium_headers.append(&name, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Neither type is defined in this lib, so we can't do From/Into impls
|
|
fn from_uri_to_url(uri: http::Uri) -> Result<Url, crate::url::ParseError> {
|
|
format!("{}", uri).parse()
|
|
}
|
|
|
|
// Neither type is defined in this lib, so we can't do From/Into impls
|
|
fn from_url_to_uri(url: &Url) -> http::Uri {
|
|
http::Uri::try_from(&format!("{}", url)).unwrap()
|
|
}
|
|
|
|
impl TryFrom<http::Request<Body>> for Request {
|
|
type Error = crate::url::ParseError;
|
|
|
|
fn try_from(req: http::Request<Body>) -> Result<Self, Self::Error> {
|
|
let (parts, body) = req.into_parts();
|
|
let method = parts.method.into();
|
|
let url = from_uri_to_url(parts.uri)?;
|
|
let mut req = Request::new(method, url);
|
|
req.set_body(body);
|
|
req.set_version(Some(parts.version.into()));
|
|
hyperium_headers_to_headers(parts.headers, req.as_mut());
|
|
Ok(req)
|
|
}
|
|
}
|
|
|
|
impl From<Request> for http::Request<Body> {
|
|
fn from(mut req: Request) -> Self {
|
|
let method: http::Method = req.method().into();
|
|
let version = req.version().map(|v| v.into()).unwrap_or_default();
|
|
let mut builder = http::request::Builder::new()
|
|
.method(method)
|
|
.uri(from_url_to_uri(req.url()))
|
|
.version(version);
|
|
headers_to_hyperium_headers(req.as_mut(), builder.headers_mut().unwrap());
|
|
builder.body(req.into()).unwrap()
|
|
}
|
|
}
|
|
|
|
impl From<http::Response<Body>> for Response {
|
|
fn from(res: http::Response<Body>) -> Self {
|
|
let (parts, body) = res.into_parts();
|
|
let mut res = Response::new(parts.status);
|
|
res.set_body(body);
|
|
res.set_version(Some(parts.version.into()));
|
|
hyperium_headers_to_headers(parts.headers, res.as_mut());
|
|
res
|
|
}
|
|
}
|
|
|
|
impl From<Response> for http::Response<Body> {
|
|
fn from(mut res: Response) -> Self {
|
|
let status: u16 = res.status().into();
|
|
let version = res.version().map(|v| v.into()).unwrap_or_default();
|
|
let mut builder = http::response::Builder::new()
|
|
.status(status)
|
|
.version(version);
|
|
headers_to_hyperium_headers(res.as_mut(), builder.headers_mut().unwrap());
|
|
let body = res.take_body();
|
|
builder.body(body).unwrap()
|
|
}
|
|
}
|