also swap out local definition of Method for http's

Author: pchickey

examples/http_get.rs

@@ -4,7 +4,7 @@ use wstd::io::AsyncRead;
 
 #[wstd::main]
 async fn main() -> Result<(), Box<dyn Error>> {
-    let request = Request::new(Method::Get, "https://postman-echo.com/get".parse()?);
+    let request = Request::new(Method::GET, "https://postman-echo.com/get".parse()?);
     let mut response = Client::new().send(request).await?;
 
     let content_type = response

src/http/error.rs

@@ -19,6 +19,7 @@ impl fmt::Debug for Error {
             ErrorVariant::WasiHeader(e) => write!(f, "wasi header error: {e:?}"),
             ErrorVariant::HeaderName(e) => write!(f, "header name error: {e:?}"),
             ErrorVariant::HeaderValue(e) => write!(f, "header value error: {e:?}"),
+            ErrorVariant::Method(e) => write!(f, "method error: {e:?}"),
             ErrorVariant::Other(e) => write!(f, "{e}"),
         }
     }
@@ -31,6 +32,7 @@ impl fmt::Display for Error {
             ErrorVariant::WasiHeader(e) => write!(f, "wasi header error: {e}"),
             ErrorVariant::HeaderName(e) => write!(f, "header name error: {e}"),
             ErrorVariant::HeaderValue(e) => write!(f, "header value error: {e}"),
+            ErrorVariant::Method(e) => write!(f, "method error: {e}"),
             ErrorVariant::Other(e) => write!(f, "{e}"),
         }
     }
@@ -85,11 +87,18 @@ impl From<http::header::InvalidHeaderName> for Error {
     }
 }
 
+impl From<http::method::InvalidMethod> for Error {
+    fn from(e: http::method::InvalidMethod) -> Error {
+        ErrorVariant::Method(e).into()
+    }
+}
+
 #[derive(Debug)]
 pub enum ErrorVariant {
     WasiHttp(wasi::http::types::ErrorCode),
     WasiHeader(wasi::http::types::HeaderError),
     HeaderName(http::header::InvalidHeaderName),
     HeaderValue(http::header::InvalidHeaderValue),
+    Method(http::method::InvalidMethod),
     Other(String),
 }

src/http/fields.rs

@@ -15,7 +15,6 @@ pub(crate) fn header_map_from_wasi(wasi_fields: Fields) -> Result<HeaderMap> {
     Ok(output)
 }
 
-#[allow(dead_code)]
 pub(crate) fn header_map_to_wasi(header_map: &HeaderMap) -> Result<Fields> {
     let wasi_fields = Fields::new();
     for (key, value) in header_map {

src/http/method.rs

@@ -1,71 +1,36 @@
 use wasi::http::types::Method as WasiMethod;
 
-/// The method for the HTTP request
-#[derive(Debug)]
-#[non_exhaustive]
-pub enum Method {
-    /// The GET method requests transfer of a current selected representation
-    /// for the target resource.
-    Get,
-    /// The HEAD method is identical to GET except that the server MUST NOT send a message body in
-    /// the response.
-    Head,
-    /// The POST method requests that the target resource process the representation enclosed in
-    /// the request according to the resource's own specific semantics.
-    Post,
-    /// The PUT method requests that the state of the target resource be created or replaced with
-    /// the state defined by the representation enclosed in the request message payload.
-    Put,
-    /// The DELETE method requests that the origin server remove the association between the target
-    /// resource and its current functionality.
-    Delete,
-    /// The CONNECT method requests that the recipient establish a tunnel to the destination origin
-    /// server identified by the request-target and, if successful, thereafter restrict its
-    /// behavior to blind forwarding of packets, in both directions, until the tunnel is closed.
-    Connect,
-    /// The OPTIONS method requests information about the communication options available for the
-    /// target resource, at either the origin server or an intervening intermediary.
-    Options,
-    /// The TRACE method requests a remote, application-level loop-back of the request message.
-    Trace,
-    /// The PATCH method requests that a set of changes described in the request entity be applied
-    /// to the resource identified by the Request- URI.
-    ///
-    Patch,
-    /// Send a method not covered by this list.
-    Other(String),
-}
+use super::Result;
+pub use http::Method;
 
-impl From<Method> for WasiMethod {
-    fn from(value: Method) -> Self {
-        match value {
-            Method::Get => WasiMethod::Get,
-            Method::Head => WasiMethod::Head,
-            Method::Post => WasiMethod::Post,
-            Method::Put => WasiMethod::Put,
-            Method::Delete => WasiMethod::Delete,
-            Method::Connect => WasiMethod::Connect,
-            Method::Options => WasiMethod::Options,
-            Method::Trace => WasiMethod::Trace,
-            Method::Patch => WasiMethod::Patch,
-            Method::Other(s) => WasiMethod::Other(s),
-        }
+pub(crate) fn to_wasi_method(value: Method) -> WasiMethod {
+    match value {
+        Method::GET => WasiMethod::Get,
+        Method::HEAD => WasiMethod::Head,
+        Method::POST => WasiMethod::Post,
+        Method::PUT => WasiMethod::Put,
+        Method::DELETE => WasiMethod::Delete,
+        Method::CONNECT => WasiMethod::Connect,
+        Method::OPTIONS => WasiMethod::Options,
+        Method::TRACE => WasiMethod::Trace,
+        Method::PATCH => WasiMethod::Patch,
+        other => WasiMethod::Other(other.as_str().to_owned()),
     }
 }
 
-impl From<WasiMethod> for Method {
-    fn from(value: WasiMethod) -> Self {
-        match value {
-            WasiMethod::Get => Method::Get,
-            WasiMethod::Head => Method::Head,
-            WasiMethod::Post => Method::Post,
-            WasiMethod::Put => Method::Put,
-            WasiMethod::Delete => Method::Delete,
-            WasiMethod::Connect => Method::Connect,
-            WasiMethod::Options => Method::Options,
-            WasiMethod::Trace => Method::Trace,
-            WasiMethod::Patch => Method::Patch,
-            WasiMethod::Other(s) => Method::Other(s),
-        }
-    }
+// This will become useful once we support IncomingRequest
+#[allow(dead_code)]
+pub(crate) fn from_wasi_method(value: WasiMethod) -> Result<Method> {
+    Ok(match value {
+        WasiMethod::Get => Method::GET,
+        WasiMethod::Head => Method::HEAD,
+        WasiMethod::Post => Method::POST,
+        WasiMethod::Put => Method::PUT,
+        WasiMethod::Delete => Method::DELETE,
+        WasiMethod::Connect => Method::CONNECT,
+        WasiMethod::Options => Method::OPTIONS,
+        WasiMethod::Trace => Method::TRACE,
+        WasiMethod::Patch => Method::PATCH,
+        WasiMethod::Other(s) => Method::from_bytes(s.as_bytes())?,
+    })
 }

src/http/mod.rs

@@ -12,8 +12,6 @@ pub use request::Request;
 pub use response::Response;
 pub use status_code::StatusCode;
 
-pub(crate) use fields::{header_map_from_wasi, header_map_to_wasi};
-
 pub mod body;
 
 mod client;

src/http/request.rs

@@ -1,6 +1,9 @@
 use crate::io::{empty, Empty};
 
-use super::{header_map_to_wasi, Body, Error, HeaderMap, IntoBody, Method, Result};
+use super::{
+    fields::header_map_to_wasi, method::to_wasi_method, Body, Error, HeaderMap, IntoBody, Method,
+    Result,
+};
 use http::uri::Uri;
 use wasi::http::outgoing_handler::OutgoingRequest;
 use wasi::http::types::Scheme;
@@ -57,7 +60,7 @@ impl<B: Body> Request<B> {
         let wasi_req = OutgoingRequest::new(header_map_to_wasi(&self.headers)?);
 
         // Set the HTTP method
-        let method = self.method.into();
+        let method = to_wasi_method(self.method);
         wasi_req
             .set_method(&method)
             .map_err(|()| Error::other(format!("method rejected by wasi-http: {method:?}",)))?;

src/http/response.rs

@@ -1,7 +1,7 @@
 use wasi::http::types::{IncomingBody as WasiIncomingBody, IncomingResponse};
 use wasi::io::streams::{InputStream, StreamError};
 
-use super::{header_map_from_wasi, Body, HeaderMap, StatusCode};
+use super::{fields::header_map_from_wasi, Body, HeaderMap, StatusCode};
 use crate::io::AsyncRead;
 use crate::runtime::Reactor;