Refer to hyperium's http crate as hyperium

Signed-off-by: Ryan Levick <[email protected]>

Author: rylev

sdk/rust/Cargo.toml

@@ -22,12 +22,12 @@ once_cell = "1.18.0"
 futures = "0.3.28"
 serde_json = { version = "1.0.96", optional = true }
 serde = { version = "1.0.163", optional = true }
-http_types = { package = "http", version = "0.2", optional = true }
+hyperium = { package = "http", version = "0.2", optional = true }
 bytes = { version = "1", optional = true }
 
 [features]
 default = ["export-sdk-language", "http", "json"]
-http = ["dep:http_types", "dep:bytes"]
+http = ["dep:hyperium", "dep:bytes"]
 export-sdk-language = []
 json = ["dep:serde", "dep:serde_json"]
 experimental = []

sdk/rust/src/http.rs

@@ -39,21 +39,21 @@ pub enum SendError {
 }
 
 #[cfg(feature = "http")]
-impl<B> TryFrom<http_types::Request<B>> for Request
+impl<B> TryFrom<hyperium::Request<B>> for Request
 where
     B: TryIntoBody,
     B::Error: std::error::Error + Send + Sync + 'static,
 {
     type Error = anyhow::Error;
-    fn try_from(req: http_types::Request<B>) -> Result<Self, Self::Error> {
+    fn try_from(req: hyperium::Request<B>) -> Result<Self, Self::Error> {
         let method = match req.method() {
-            &http_types::Method::GET => Method::Get,
-            &http_types::Method::POST => Method::Post,
-            &http_types::Method::PUT => Method::Put,
-            &http_types::Method::DELETE => Method::Delete,
-            &http_types::Method::PATCH => Method::Patch,
-            &http_types::Method::HEAD => Method::Head,
-            &http_types::Method::OPTIONS => Method::Options,
+            &hyperium::Method::GET => Method::Get,
+            &hyperium::Method::POST => Method::Post,
+            &hyperium::Method::PUT => Method::Put,
+            &hyperium::Method::DELETE => Method::Delete,
+            &hyperium::Method::PATCH => Method::Patch,
+            &hyperium::Method::HEAD => Method::Head,
+            &hyperium::Method::OPTIONS => Method::Options,
             m => anyhow::bail!("Unsupported method: {m}"),
         };
         let headers = req
@@ -197,12 +197,10 @@ impl Display for NonUtf8BodyError {
 }
 
 #[cfg(feature = "http")]
-impl<B: TryFromBody> TryNonRequestFromRequest for http_types::Request<B> {
+impl<B: TryFromBody> TryNonRequestFromRequest for hyperium::Request<B> {
     type Error = B::Error;
     fn try_from_request(req: Request) -> Result<Self, Self::Error> {
-        let mut builder = http_types::Request::builder()
-            .uri(req.uri)
-            .method(req.method);
+        let mut builder = hyperium::Request::builder().uri(req.uri).method(req.method);
         for (n, v) in req.headers {
             builder = builder.header(n, v);
         }
@@ -211,25 +209,25 @@ impl<B: TryFromBody> TryNonRequestFromRequest for http_types::Request<B> {
 }
 
 #[cfg(feature = "http")]
-impl From<Method> for http_types::Method {
+impl From<Method> for hyperium::Method {
     fn from(method: Method) -> Self {
         match method {
-            Method::Get => http_types::Method::GET,
-            Method::Post => http_types::Method::POST,
-            Method::Put => http_types::Method::PUT,
-            Method::Delete => http_types::Method::DELETE,
-            Method::Patch => http_types::Method::PATCH,
-            Method::Head => http_types::Method::HEAD,
-            Method::Options => http_types::Method::OPTIONS,
+            Method::Get => hyperium::Method::GET,
+            Method::Post => hyperium::Method::POST,
+            Method::Put => hyperium::Method::PUT,
+            Method::Delete => hyperium::Method::DELETE,
+            Method::Patch => hyperium::Method::PATCH,
+            Method::Head => hyperium::Method::HEAD,
+            Method::Options => hyperium::Method::OPTIONS,
         }
     }
 }
 
 #[cfg(feature = "http")]
-impl<B: TryFromBody> TryFrom<Response> for http_types::Response<B> {
+impl<B: TryFromBody> TryFrom<Response> for hyperium::Response<B> {
     type Error = B::Error;
     fn try_from(resp: Response) -> Result<Self, Self::Error> {
-        let mut builder = http_types::Response::builder().status(resp.status);
+        let mut builder = hyperium::Response::builder().status(resp.status);
         for (n, v) in resp.headers.unwrap_or_default() {
             builder = builder.header(n, v);
         }
@@ -254,7 +252,7 @@ impl<R: Into<Response>> IntoResponse for R {
 }
 
 #[cfg(feature = "http")]
-impl<B> IntoResponse for http_types::Response<B>
+impl<B> IntoResponse for hyperium::Response<B>
 where
     B: IntoBody,
 {
@@ -352,7 +350,7 @@ impl IntoStatusCode for u16 {
 }
 
 #[cfg(feature = "http")]
-impl IntoStatusCode for http_types::StatusCode {
+impl IntoStatusCode for hyperium::StatusCode {
     fn into_status_code(self) -> u16 {
         self.as_u16()
     }

sdk/rust/src/http/router.rs

@@ -307,7 +307,7 @@ mod tests {
 
         let req = make_request(Method::Post, "/foobar");
         let res = router.handle(req);
-        assert_eq!(res.status, http_types::StatusCode::METHOD_NOT_ALLOWED);
+        assert_eq!(res.status, hyperium::StatusCode::METHOD_NOT_ALLOWED);
     }
 
     #[test]
@@ -321,7 +321,7 @@ mod tests {
 
         let req = make_request(Method::Get, "/h1/");
         let res = router.handle(req);
-        assert_eq!(res.status, http_types::StatusCode::NOT_FOUND);
+        assert_eq!(res.status, hyperium::StatusCode::NOT_FOUND);
     }
 
     #[test]
@@ -366,7 +366,7 @@ mod tests {
 
         let req = make_request(Method::Get, "/foo/bar");
         let res = router.handle(req);
-        assert_eq!(res.status, http_types::StatusCode::OK);
+        assert_eq!(res.status, hyperium::StatusCode::OK);
         assert_eq!(res.body.unwrap(), "foo/bar".to_owned().into_bytes());
     }