Adjust outbound http

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

Author: rylev

examples/http-rust-outbound-http/outbound-http/src/lib.rs

@@ -7,7 +7,7 @@ use spin_sdk::{
 /// Send an HTTP request and return the response.
 #[http_component]
 async fn send_outbound(_req: Request) -> Result<impl IntoResponse> {
-    let mut res: http::Response<()> = spin_sdk::http::send(
+    let mut res: http::Response<String> = spin_sdk::http::send(
         http::Request::builder()
             .method("GET")
             .uri("https://random-data-api.fermyon.app/animals/json")

sdk/rust/src/http.rs

@@ -107,6 +107,34 @@ impl Request {
             uri,
         )
     }
+
+    /// Whether the request is an HTTPS request
+    fn is_https(&self) -> bool {
+        self.uri
+            .0
+            .as_ref()
+            .and_then(|u| u.scheme())
+            .map(|s| s == &hyperium::uri::Scheme::HTTPS)
+            .unwrap_or(true)
+    }
+
+    /// The URI's authority
+    fn authority(&self) -> Option<&str> {
+        self.uri
+            .0
+            .as_ref()
+            .and_then(|u| u.authority())
+            .map(|a| a.as_str())
+    }
+
+    /// The request path and query combined
+    pub fn path_and_query(&self) -> Option<&str> {
+        self.uri
+            .0
+            .as_ref()
+            .and_then(|u| u.path_and_query())
+            .map(|s| s.as_str())
+    }
 }
 
 /// A request builder
@@ -454,7 +482,7 @@ impl OutgoingResponse {
     /// # Panics
     ///
     /// Panics if the body was already taken.
-    pub fn take_body(&self) -> impl futures::Sink<Vec<u8>, Error = anyhow::Error> {
+    pub fn take_body(&self) -> impl futures::Sink<Vec<u8>, Error = Error> {
         executor::outgoing_body(self.write().expect("response body was already taken"))
     }
 }
@@ -482,7 +510,7 @@ impl ResponseOutparam {
         self,
         response: OutgoingResponse,
         buffer: Vec<u8>,
-    ) -> anyhow::Result<()> {
+    ) -> Result<(), Error> {
         use futures::SinkExt;
         let mut body = response.take_body();
         self.set(response);

sdk/rust/src/http/conversions.rs

@@ -482,6 +482,28 @@ where
     }
 }
 
+impl TryFrom<Request> for OutgoingRequest {
+    type Error = std::convert::Infallible;
+
+    fn try_from(req: Request) -> Result<Self, Self::Error> {
+        let headers = req
+            .headers()
+            .map(|(k, v)| (k.to_owned(), v.as_bytes().to_owned()))
+            .collect::<Vec<_>>();
+        Ok(OutgoingRequest::new(
+            req.method(),
+            req.path_and_query(),
+            Some(if req.is_https() {
+                &super::Scheme::Https
+            } else {
+                &super::Scheme::Http
+            }),
+            req.authority(),
+            &Headers::new(&headers),
+        ))
+    }
+}
+
 #[cfg(feature = "http")]
 impl<B> TryFrom<hyperium::Request<B>> for OutgoingRequest
 where

sdk/rust/src/http/executor.rs

@@ -5,7 +5,7 @@ use crate::wit::wasi::http::types::{
 use crate::wit::wasi::io;
 use crate::wit::wasi::io::streams::{InputStream, OutputStream, StreamError};
 
-use anyhow::{anyhow, Error, Result};
+use anyhow::{anyhow, Result};
 use futures::{future, sink, stream, Sink, Stream};
 
 use std::cell::RefCell;
@@ -67,7 +67,7 @@ pub fn run<T>(future: impl Future<Output = T>) -> T {
     }
 }
 
-pub(crate) fn outgoing_body(body: OutgoingBody) -> impl Sink<Vec<u8>, Error = Error> {
+pub(crate) fn outgoing_body(body: OutgoingBody) -> impl Sink<Vec<u8>, Error = types::Error> {
     struct Outgoing(Option<(OutputStream, OutgoingBody)>);
 
     impl Drop for Outgoing {
@@ -119,11 +119,19 @@ pub(crate) fn outgoing_body(body: OutgoingBody) -> impl Sink<Vec<u8>, Error = Er
                                         Ok(()) => {
                                             offset += count;
                                         }
-                                        Err(_) => break Poll::Ready(Err(anyhow!("I/O error"))),
+                                        Err(e) => {
+                                            break Poll::Ready(Err(types::Error::ProtocolError(
+                                                format!("I/O error: {e}"),
+                                            )))
+                                        }
                                     }
                                 }
                             }
-                            Err(_) => break Poll::Ready(Err(anyhow!("I/O error"))),
+                            Err(e) => {
+                                break Poll::Ready(Err(types::Error::ProtocolError(format!(
+                                    "I/O error: {e}"
+                                ))))
+                            }
                         }
                     }
                 }