Update names

Signed-off-by: Mikkel Mørk Hegnhøj <[email protected]>

Author: mikkelhegn

examples/wasip3-concurrent-outbound-http-calls/Cargo.lock

@@ -1,18 +1,23 @@
 [package]
-name = "concurrent-outbound-http-calls"
-authors = ["itowlson <ivan.towlson@fermyon.com>"]
+name = "competing_outbound_http_calls"
+authors = ["mikkelhegn <mikkel.hegnhoj@fermyon.com>"]
 description = ""
 version = "0.1.0"
-rust-version = "1.90" # required for `wasm32-wasip2` target to build WASIp3
+rust-version = "1.90"
 edition = "2021"
 
 [lib]
 crate-type = ["cdylib"]
 
 [dependencies]
 anyhow = "1"
+bytes = "1.10.1"
 futures = "0.3.31"
 http = "1.3"
+http-body = "1"
+http-body-util = "0.1.3"
+serde = { version = "1.0.228", features = ["derive"] }
+serde_json = "1.0.145"
 spin-sdk = { path = "../..", features = ["wasip3-unstable"] }
 
 [workspace]

examples/wasip3-concurrent-outbound-http-calls/Cargo.toml

@@ -3,19 +3,22 @@
 spin_manifest_version = 2
 
 [application]
-name = "concurrent-outbound-http-calls"
+name = "competing-outbound-http-calls"
 version = "0.1.0"
 authors = ["The Spin project"]
-description = "Demonstrates making concurrent outbound HTTP calls in WASIp3"
+description = "Demonstrates making competing outbound HTTP calls in WASIp3, and continue handling the requests on the server, after having returned to the client."
 
 [[trigger.http]]
 route = "/..."
-component = "concurrent-outbound-http-calls"
+component = "competing-outbound-http-calls"
 executor = { type = "wasip3-unstable" }
 
-[component.concurrent-outbound-http-calls]
-source = "target/wasm32-wasip2/release/concurrent_outbound_http_calls.wasm"
-allowed_outbound_hosts = ["https://spinframework.dev", "https://component-model.bytecodealliance.org/"]
-[component.concurrent-outbound-http-calls.build]
+[component.competing-outbound-http-calls]
+source = "target/wasm32-wasip2/release/competing_outbound_http_calls.wasm"
+allowed_outbound_hosts = [
+    "https://spinframework.dev",
+    "https://component-model.bytecodealliance.org/",
+]
+[component.competing-outbound-http-calls.build]
 command = "cargo build --target wasm32-wasip2 --release"
 watch = ["src/**/*.rs", "Cargo.toml"]

examples/wasip3-concurrent-outbound-http-calls/spin.toml

@@ -1,30 +1,121 @@
 use std::pin::pin;
 
-use futures::future::Either;
+use futures::SinkExt;
 use http::Request;
-use spin_sdk::http_wasip3::{send, EmptyBody, IntoResponse};
+use serde::{Deserialize, Serialize};
 use spin_sdk::http_wasip3::http_service;
+use spin_sdk::http_wasip3::{send, EmptyBody, IntoResponse};
+
+use bytes::Bytes;
+use futures::{
+    channel::mpsc::{channel, Sender},
+    StreamExt,
+};
 
 #[http_service]
-async fn handle_concurrent_outbound_http_calls(_req: spin_sdk::http_wasip3::Request) -> anyhow::Result<impl IntoResponse> {
+async fn handle_competing_outbound_http_calls(
+    _req: spin_sdk::http_wasip3::Request,
+) -> impl IntoResponse {
+    println!("Handling reuqest");
+
+    // A lot of code taken from: https://github.com/spinframework/spin-rust-sdk/blob/main/examples/wasip3-streaming/src/lib.rs
+
+    // Create a streaming Body implementation that backs onto a `mpsc`
+    // channel. The function returns the sender side of the channel; the
+    // receiver end becomes the body. So anything written to the sender
+    // side will be sent out over the HTTP response.
+    let (mut tx, body) = bytes_stream_body();
+
+    // Use wit_bindgen::spawn to allow the async block to keep running
+    // after the handler returns.
+    spin_sdk::http_wasip3::wasip3::wit_bindgen::spawn(async move {
+        // The two outbound calls
+        let spin = pin!(get_content_length("https://spinframework.dev"));
+        let book = pin!(get_content_length(
+            "https://component-model.bytecodealliance.org"
+        ));
+
+        // Getting the first response back
+        let first_result = futures::future::select(spin, book).await.factor_first();
+
+        // We need to keep the future around to also handle the second response,
+        // hence instantiating a new variable for the ContentLength struct
+        let first_response = first_result.0.unwrap();
 
-    let spin = pin!(get_content_length("https://spinframework.dev"));
-    let book = pin!(get_content_length("https://component-model.bytecodealliance.org/"));
+        // Let's print some stats to the server console
+        println!(
+            "HEAD request done: {:?}, took {:?} ms, content-length: {:?}",
+            first_response.url, first_response.ms_taken, first_response.content_length
+        );
 
-    let (first, len) = match futures::future::select(spin, book).await {
-        Either::Left(len) => ("Spin docs", len),
-        Either::Right(len) => ("Component model book", len),
-    };
+        // Serializing the struct as JSON represented as bytes
+        let bytes: Bytes = serde_json::to_vec_pretty(&first_response)
+            .expect("Failed to serialize!")
+            .try_into()
+            .unwrap();
 
-    let response = format!("{first} site was first response with content-length {:?}\n", len.0?);
+        // Sends the bytes over the channel and closes te channel, as we're done with the client response
+        tx.send(bytes).await.unwrap();
+        tx.close_channel();
 
-    Ok(response)
+        // Handles the secons request (future) as it returns a reponse
+        let second_response = first_result.1.await.expect("Failed to get second response");
+
+        // And printing stats to the server console, as the client connection is already closed
+        println!(
+            "HEAD request done: {:?}, took {:?} ms, content-length: {:?}",
+            second_response.url, second_response.ms_taken, second_response.content_length
+        );
+
+        println!("Done");
+    });
+
+    // Returning the body, once the channel closes
+    http::Response::new(body)
 }
 
-async fn get_content_length(url: &str) -> anyhow::Result<Option<u64>> {
-    let request = Request::get(url).body(EmptyBody::new())?;
+// Getting the content length via an HTTP HEAD request
+async fn get_content_length(url: &str) -> anyhow::Result<ResponseStats> {
+    let request = Request::head(url).body(EmptyBody::new())?;
+    let start = std::time::SystemTime::now();
+    println!("HEAD request sent: {url}");
     let response = send(request).await?;
     let cl_header = response.headers().get("content-length");
-    let cl = cl_header.and_then(|hval| hval.to_str().ok()).and_then(|hval| hval.parse().ok());
-    Ok(cl)
+    let cl = cl_header
+        .and_then(|hval| hval.to_str().ok())
+        .and_then(|hval| hval.parse().ok());
+    let end = std::time::SystemTime::now()
+        .duration_since(start)
+        .expect("Failed to get time");
+    Ok(ResponseStats {
+        content_length: cl.unwrap(),
+        ms_taken: end.as_millis(),
+        url: url.to_string(),
+    })
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+struct ResponseStats {
+    content_length: u64,
+    ms_taken: u128,
+    url: String,
+}
+
+// Helper function to create a streaming body.
+fn bytes_stream_body() -> (
+    Sender<bytes::Bytes>,
+    impl http_body::Body<Data = Bytes, Error = anyhow::Error>,
+) {
+    // The send and receive sides of a channel
+    let (tx, rx) = channel::<Bytes>(1024);
+    // The receive side is a stream, so we can use combinators like `map`
+    // to transform it into a form that the response plumbing is happy
+    // with. The app logic that writes to the stream doesn't need to see
+    // any of this.
+    let stm = rx.map(|value| Ok(http_body::Frame::data(value)));
+    // Construct a Body implementation over the stream.
+    let body = http_body_util::StreamBody::new(stm);
+    // Return the send side (so that app logic can write to the body) and the
+    // body (so it can be put in a Response!).
+    (tx, body)
 }