add headers to requests

and propogate some errors out instead of unwrapping

Author: pchickey

src/http/client.rs

@@ -18,7 +18,7 @@ impl Client {
 
     /// Send an HTTP request.
     pub async fn send<B: Body>(&self, req: Request<B>) -> Result<Response<IncomingBody>> {
-        let (wasi_req, body) = req.into_outgoing();
+        let (wasi_req, body) = req.into_outgoing()?;
         let wasi_body = wasi_req.body().unwrap();
         let body_stream = wasi_body.write().unwrap();
 

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::Other(e) => write!(f, "{e}"),
         }
     }
 }
@@ -30,13 +31,17 @@ 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::Other(e) => write!(f, "{e}"),
         }
     }
 }
 
 impl std::error::Error for Error {}
 
 impl Error {
+    pub(crate) fn other(s: impl Into<String>) -> Self {
+        ErrorVariant::Other(s.into()).into()
+    }
     pub(crate) fn context(self, s: impl Into<String>) -> Self {
         let mut context = self.context;
         context.push(s.into());
@@ -86,4 +91,5 @@ pub enum ErrorVariant {
     WasiHeader(wasi::http::types::HeaderError),
     HeaderName(http::header::InvalidHeaderName),
     HeaderValue(http::header::InvalidHeaderValue),
+    Other(String),
 }

src/http/mod.rs

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

src/http/request.rs

@@ -1,16 +1,16 @@
 use crate::io::{empty, Empty};
 
-use super::{Body, IntoBody, Method};
+use super::{header_map_to_wasi, Body, Error, HeaderMap, IntoBody, Method, Result};
 use http::uri::Uri;
 use wasi::http::outgoing_handler::OutgoingRequest;
-use wasi::http::types::{Headers as WasiHeaders, Scheme};
+use wasi::http::types::Scheme;
 
 /// An HTTP request
 #[derive(Debug)]
 pub struct Request<B: Body> {
     method: Method,
     uri: Uri,
-    headers: WasiHeaders,
+    headers: HeaderMap,
     body: B,
 }
 
@@ -21,12 +21,22 @@ impl Request<Empty> {
             body: empty(),
             method,
             uri,
-            headers: WasiHeaders::new(),
+            headers: HeaderMap::new(),
         }
     }
 }
 
 impl<B: Body> Request<B> {
+    /// Get the HTTP headers from the impl
+    pub fn headers(&self) -> &HeaderMap {
+        &self.headers
+    }
+
+    /// Mutably get the HTTP headers from the impl
+    pub fn headers_mut(&mut self) -> &mut HeaderMap {
+        &mut self.headers
+    }
+
     /// Set an HTTP body.
     pub fn set_body<C: IntoBody>(self, body: C) -> Request<C::IntoBody> {
         let Self {
@@ -43,13 +53,14 @@ impl<B: Body> Request<B> {
         }
     }
 
-    pub(crate) fn into_outgoing(self) -> (OutgoingRequest, B) {
-        let wasi_req = OutgoingRequest::new(self.headers);
+    pub(crate) fn into_outgoing(self) -> Result<(OutgoingRequest, B)> {
+        let wasi_req = OutgoingRequest::new(header_map_to_wasi(&self.headers)?);
 
         // Set the HTTP method
+        let method = self.method.into();
         wasi_req
-            .set_method(&self.method.into())
-            .expect("method accepted by wasi-http implementation");
+            .set_method(&method)
+            .map_err(|()| Error::other(format!("method rejected by wasi-http: {method:?}",)))?;
 
         // Set the url scheme
         let scheme = match self.uri.scheme().map(|s| s.as_str()) {
@@ -59,21 +70,24 @@ impl<B: Body> Request<B> {
         };
         wasi_req
             .set_scheme(Some(&scheme))
-            .expect("scheme accepted by wasi-http implementation");
+            .map_err(|()| Error::other(format!("scheme rejected by wasi-http: {scheme:?}")))?;
 
         // Set authority
+        let authority = self.uri.authority().map(|a| a.as_str());
         wasi_req
-            .set_authority(self.uri.authority().map(|a| a.as_str()))
-            .expect("authority accepted by wasi-http implementation");
+            .set_authority(authority)
+            .map_err(|()| Error::other(format!("authority rejected by wasi-http {authority:?}")))?;
 
         // Set the url path + query string
         if let Some(p_and_q) = self.uri.path_and_query() {
             wasi_req
                 .set_path_with_query(Some(&p_and_q.to_string()))
-                .expect("path with query accepted by wasi-http implementation")
+                .map_err(|()| {
+                    Error::other(format!("path and query rejected by wasi-http {p_and_q:?}"))
+                })?;
         }
 
         // All done; request is ready for send-off
-        (wasi_req, self.body)
+        Ok((wasi_req, self.body))
     }
 }