add streaming-p3 example

Signed-off-by: Joel Dice <joel.dice@akamai.com>

Author: dicej

examples/streaming-p3/README.md

@@ -0,0 +1,53 @@
+# Example: Streaming with WASIp3
+
+This is an example showcasing the use of HTTP request and response body
+streaming within a guest component using WASIp3.
+
+## Preparing the Environment
+
+Run the following commands to setup a virtual environment with Python.
+
+```bash
+python3 -m venv venv
+source venv/bin/activate
+```
+
+Install the required packages specified in the `requirements.txt` using the
+command:
+
+```bash
+pip3 install -r requirements.txt
+```
+
+## Building and Running the Examples
+
+```bash
+spin build --up
+```
+
+## Testing the App
+
+```
+curl -i -H 'content-type: text/plain' --data-binary @- http://127.0.0.1:8080/echo <<EOF
+’Twas brillig, and the slithy toves
+      Did gyre and gimble in the wabe:
+All mimsy were the borogoves,
+      And the mome raths outgrabe.
+EOF
+```
+
+The above should echo the request body in the response.
+
+In addition to the `/echo` endpoint, the app supports a `/hash-all` endpoint
+which concurrently downloads one or more URLs and streams the SHA-256 hashes of
+their contents.  You can test it with e.g.:
+
+```
+curl -i \
+    -H 'url: https://webassembly.github.io/spec/core/' \
+    -H 'url: https://www.w3.org/groups/wg/wasm/' \
+    -H 'url: https://bytecodealliance.org/' \
+    http://127.0.0.1:8080/hash-all
+```
+
+If you run into any problems, please file an issue!

examples/streaming-p3/app.py

@@ -0,0 +1,134 @@
+"""Demo of a serverless app using `wasi-http` to handle inbound HTTP requests.
+
+This demonstrates how to use WASI's asynchronous capabilities to manage multiple
+concurrent requests and streaming bodies.  It uses a custom `asyncio` event loop
+to thread I/O through coroutines.
+"""
+
+import asyncio
+import hashlib
+import componentize_py_async_support
+
+from typing import Optional
+from componentize_py_types import Ok, Result
+from componentize_py_async_support.streams import ByteStreamWriter
+from componentize_py_async_support.futures import FutureReader
+from spin_sdk import wit
+from spin_sdk.wit import exports
+from spin_sdk.wit.imports import wasi_http_client_0_3_0_rc_2026_03_15 as client
+from spin_sdk.wit.imports.wasi_http_types_0_3_0_rc_2026_03_15 import (
+    Method_Get,
+    Method_Post,
+    Scheme,
+    Scheme_Http,
+    Scheme_Https,
+    Scheme_Other,
+    Request,
+    Response,
+    Fields,
+    ErrorCode
+)
+from urllib import parse
+
+
+class WasiHttpHandler030Rc20260315(exports.WasiHttpHandler030Rc20260315):
+    """Implements the `export`ed portion of the `wasi-http` `proxy` world."""
+
+    async def handle(self, request: Request) -> Response:
+        """Handle the specified `request`, returning a `Response`."""
+        
+        method = request.get_method()
+        path = request.get_path_with_query()
+        headers = request.get_headers().copy_all()
+
+        if isinstance(method, Method_Get) and path == "/hash-all":
+            # Collect one or more "url" headers, download their contents
+            # concurrently, compute their SHA-256 hashes incrementally (i.e. without
+            # buffering the response bodies), and stream the results back to the
+            # client as they become available.
+
+            urls = list(map(
+                lambda pair: str(pair[1], "utf-8"),
+                filter(lambda pair: pair[0] == "url", headers),
+            ))
+
+            tx, rx = wit.byte_stream()
+            componentize_py_async_support.spawn(hash_all(urls, tx))
+
+            return Response.new(
+                Fields.from_list([("content-type", b"text/plain")]),
+                rx,
+                trailers_future()
+            )[0]
+
+        elif isinstance(method, Method_Post) and path == "/echo":
+            # Echo the request body back to the client without buffering.
+
+            rx, trailers = Request.consume_body(request, unit_future())
+
+            return Response.new(
+                Fields.from_list(
+                    list(filter(lambda pair: pair[0] == "content-type", headers))
+                ),
+                rx,
+                trailers
+            )[0]
+
+        else:
+            response = Response.new(Fields(), None, trailers_future())[0]
+            response.set_status_code(400)
+            return response
+
+
+async def hash_all(urls: list[str], tx: ByteStreamWriter) -> None:
+    with tx:
+        for result in asyncio.as_completed(map(sha256, urls)):
+            url, sha = await result
+            await tx.write_all(bytes(f"{url}: {sha}\n", "utf-8"))
+            
+            
+async def sha256(url: str) -> tuple[str, str]:
+    """Download the contents of the specified URL, computing the SHA-256
+    incrementally as the response body arrives.
+
+    This returns a tuple of the original URL and either the hex-encoded hash or
+    an error message.
+    """
+
+    url_parsed = parse.urlparse(url)
+
+    match url_parsed.scheme:
+        case "http":
+            scheme: Scheme = Scheme_Http()
+        case "https":
+            scheme = Scheme_Https()
+        case _:
+            scheme = Scheme_Other(url_parsed.scheme)
+
+    request = Request.new(Fields(), None, trailers_future(), None)[0]
+    request.set_scheme(scheme)
+    request.set_authority(url_parsed.netloc)
+    request.set_path_with_query(url_parsed.path)
+
+    response = await client.send(request)
+    status = response.get_status_code()
+    if status < 200 or status > 299:
+        return url, f"unexpected status: {status}"
+
+    rx = Response.consume_body(response, unit_future())[0]
+    
+    hasher = hashlib.sha256()
+    with rx:
+        while not rx.writer_dropped:
+            chunk = await rx.read(16 * 1024)
+            hasher.update(chunk)
+
+    return url, hasher.hexdigest()
+
+
+def trailers_future() -> FutureReader[Result[Optional[Fields], ErrorCode]]:
+    return wit.result_option_wasi_http_types_0_3_0_rc_2026_03_15_fields_wasi_http_types_0_3_0_rc_2026_03_15_error_code_future(lambda: Ok(None))[1]
+
+
+def unit_future() -> FutureReader[Result[None, ErrorCode]]:
+    return wit.result_unit_wasi_http_types_0_3_0_rc_2026_03_15_error_code_future(lambda: Ok(None))[1]

examples/streaming-p3/requirements.txt

@@ -0,0 +1,2 @@
+spin-sdk == 4.0.0
+componentize-py == 0.22.0

examples/streaming-p3/spin.toml

@@ -0,0 +1,17 @@
+spin_manifest_version = 2
+
+[application]
+name = "test"
+version = "0.1.0"
+authors = ["Fermyon Engineering <engineering@fermyon.com>"]
+description = ""
+
+[[trigger.http]]
+route = "/..."
+component = "test"
+
+[component.test]
+source = "app.wasm"
+allowed_outbound_hosts = ["http://*:*", "https://*:*"]
+[component.test.build]
+command = "componentize-py -w wasi:http/service@0.3.0-rc-2026-03-15 componentize app -o app.wasm"

run_tests.sh

@@ -38,4 +38,30 @@ then
 fi
 popd
 
+for example in examples/streaming examples/streaming-p3
+do
+  pushd $example
+  spin up &
+  spin_pid=$!
+
+  for x in $(seq 1 10)
+  do
+    message="$(curl -s -d 'Hello from Python!' localhost:3000/echo)"
+    if [ "$message" = "Hello from Python!" ]
+    then
+      result=success
+      break
+    fi
+    sleep 1
+  done
+
+  kill "$spin_pid"
+
+  if [ "$result" != "success" ]
+  then
+    exit 1
+  fi
+  popd
+done
+
 # TODO: run more examples