swap out local definitions of Fields, FieldName, FieldValue for http crate

Closes #9

Author: pchickey

examples/http_get.rs

@@ -9,10 +9,9 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     let content_type = response
         .headers()
-        .get(&"content-type".into())
-        .ok_or_else(|| "response expected to have content-type header")?;
-    assert_eq!(content_type.len(), 1, "one header value for content-type");
-    assert_eq!(content_type[0], b"application/json; charset=utf-8");
+        .get("Content-Type")
+        .ok_or_else(|| "response expected to have Content-Type header")?;
+    assert_eq!(content_type, "application/json; charset=utf-8");
 
     // Would much prefer read_to_end here:
     let mut body_buf = vec![0; 4096];

src/http/error.rs

@@ -1,5 +1,89 @@
-/// The `http` error type.
-pub type Error = wasi::http::types::ErrorCode;
+use std::fmt;
 
 /// The `http` result type.
 pub type Result<T> = std::result::Result<T, Error>;
+
+/// The `http` error type.
+pub struct Error {
+    variant: ErrorVariant,
+    context: Vec<String>,
+}
+
+impl fmt::Debug for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for c in self.context.iter() {
+            write!(f, "in {c}:\n")?;
+        }
+        match &self.variant {
+            ErrorVariant::WasiHttp(e) => write!(f, "wasi http error: {e:?}"),
+            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:?}"),
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self.variant {
+            ErrorVariant::WasiHttp(e) => write!(f, "wasi http error: {e}"),
+            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}"),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
+impl Error {
+    pub(crate) fn context(self, s: impl Into<String>) -> Self {
+        let mut context = self.context;
+        context.push(s.into());
+        Self {
+            variant: self.variant,
+            context,
+        }
+    }
+}
+
+impl From<ErrorVariant> for Error {
+    fn from(variant: ErrorVariant) -> Error {
+        Error {
+            variant,
+            context: Vec::new(),
+        }
+    }
+}
+
+impl From<wasi::http::types::ErrorCode> for Error {
+    fn from(e: wasi::http::types::ErrorCode) -> Error {
+        ErrorVariant::WasiHttp(e).into()
+    }
+}
+
+impl From<wasi::http::types::HeaderError> for Error {
+    fn from(e: wasi::http::types::HeaderError) -> Error {
+        ErrorVariant::WasiHeader(e).into()
+    }
+}
+
+impl From<http::header::InvalidHeaderValue> for Error {
+    fn from(e: http::header::InvalidHeaderValue) -> Error {
+        ErrorVariant::HeaderValue(e).into()
+    }
+}
+
+impl From<http::header::InvalidHeaderName> for Error {
+    fn from(e: http::header::InvalidHeaderName) -> Error {
+        ErrorVariant::HeaderName(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),
+}

src/http/fields.rs

@@ -1,75 +1,28 @@
-use std::{borrow::Cow, collections::HashMap, ops::Deref};
-use wasi::http::types::{Fields as WasiFields, HeaderError};
-
-/// A type alias for [`Fields`] when used as HTTP headers.
+pub use http::header::{HeaderMap as Fields, HeaderName as FieldName, HeaderValue as FieldValue};
 pub type Headers = Fields;
-
-/// A type alias for [`Fields`] when used as HTTP trailers.
 pub type Trailers = Fields;
 
-/// An HTTP Field name.
-pub type FieldName = Cow<'static, str>;
-
-/// An HTTP Field value.
-pub type FieldValue = Vec<u8>;
-
-/// HTTP Fields which can be used as either trailers or headers.
-#[derive(Clone, PartialEq, Eq)]
-pub struct Fields(pub(crate) HashMap<FieldName, Vec<FieldValue>>);
-
-impl Fields {
-    pub fn get(&self, k: &FieldName) -> Option<&[FieldValue]> {
-        self.0.get(k).map(|f| f.deref())
-    }
-}
-
-impl std::fmt::Debug for Fields {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let mut map = f.debug_map();
-        let mut entries: Vec<_> = self.0.iter().collect();
-        entries.sort_by_cached_key(|(k, _)| k.to_owned());
-        for (key, values) in entries {
-            match values.len() {
-                0 => {
-                    map.entry(key, &"");
-                }
-                1 => {
-                    let value = values.iter().next().unwrap();
-                    let value = String::from_utf8_lossy(value);
-                    map.entry(key, &value);
-                }
-                _ => {
-                    let values: Vec<_> =
-                        values.iter().map(|v| String::from_utf8_lossy(v)).collect();
-                    map.entry(key, &values);
-                }
-            }
-        }
-        map.finish()
-    }
-}
-
-impl From<WasiFields> for Fields {
-    fn from(wasi_fields: WasiFields) -> Self {
-        let mut output = HashMap::new();
-        for (key, value) in wasi_fields.entries() {
-            let field_name = key.into();
-            let field_list: &mut Vec<_> = output.entry(field_name).or_default();
-            field_list.push(value);
-        }
-        Self(output)
+use super::{Error, Result};
+use wasi::http::types::Fields as WasiFields;
+
+pub(crate) fn fields_from_wasi(wasi_fields: WasiFields) -> Result<Fields> {
+    let mut output = Fields::new();
+    for (key, value) in wasi_fields.entries() {
+        let key = FieldName::from_bytes(key.as_bytes())
+            .map_err(|e| Error::from(e).context("header name {key}"))?;
+        let value = FieldValue::from_bytes(&value)
+            .map_err(|e| Error::from(e).context("header value for {key}"))?;
+        output.append(key, value);
     }
+    Ok(output)
 }
 
-impl TryFrom<Fields> for WasiFields {
-    type Error = HeaderError;
-    fn try_from(fields: Fields) -> Result<Self, Self::Error> {
-        let mut list = Vec::with_capacity(fields.0.capacity());
-        for (name, values) in fields.0.into_iter() {
-            for value in values {
-                list.push((name.clone().into_owned(), value));
-            }
-        }
-        Ok(WasiFields::from_list(&list)?)
+pub(crate) fn fields_to_wasi(fields: &Fields) -> Result<WasiFields> {
+    let wasi_fields = WasiFields::new();
+    for (key, value) in fields {
+        wasi_fields
+            .append(&key.as_str().to_owned(), &value.as_bytes().to_owned())
+            .map_err(|e| Error::from(e).context("header named {key}"))?;
     }
+    Ok(wasi_fields)
 }

src/http/mod.rs

@@ -1,5 +1,5 @@
 //! HTTP networking support
-
+//!
 pub use http::uri::Uri;
 
 #[doc(inline)]
@@ -12,6 +12,8 @@ pub use request::Request;
 pub use response::Response;
 pub use status_code::StatusCode;
 
+pub(crate) use fields::fields_from_wasi;
+
 pub mod body;
 
 mod client;

src/http/response.rs

@@ -1,7 +1,7 @@
 use wasi::http::types::{IncomingBody as WasiIncomingBody, IncomingResponse};
 use wasi::io::streams::{InputStream, StreamError};
 
-use super::{Body, Headers, StatusCode};
+use super::{fields_from_wasi, Body, Headers, StatusCode};
 use crate::io::AsyncRead;
 use crate::runtime::Reactor;
 
@@ -46,7 +46,7 @@ pub struct Response<B: Body> {
 
 impl Response<IncomingBody> {
     pub(crate) fn try_from_incoming_response(incoming: IncomingResponse) -> super::Result<Self> {
-        let headers: Headers = incoming.headers().into();
+        let headers: Headers = fields_from_wasi(incoming.headers())?;
         let status = incoming.status().into();
 
         // `body_stream` is a child of `incoming_body` which means we cannot