outbound redis, config, and binary bodies

Signed-off-by: Joel Dice <[email protected]>

Author: dicej

py/app.py

@@ -1,7 +1,18 @@
-from spin_http import Request, Response, send
+from spin_http import Request, Response, http_send
+from spin_redis import redis_get, redis_set
+from spin_config import config_get
 
 def handle_request(request):
     print(f"Got request URI: {request.uri}")
-    response = send(Request("GET", "https://some-random-api.ml/facts/dog", [], None))
-    print(f"Got dog fact: {response.body}")
-    return Response(200, [("content-type", "text/plain")], f"Hello from Python! Got request URI: {request.uri}")
+
+    response = http_send(Request("GET", "https://some-random-api.ml/facts/dog", [], None))
+    print(f"Got dog fact: {str(response.body, 'utf-8')}")
+
+    redis_address = config_get("redis_address")
+    redis_set(redis_address, "foo", b"bar")
+    value = redis_get(redis_address, "foo")
+    assert value == b"bar", f"expected \"bar\", got \"{str(value, 'utf-8')}\""
+
+    return Response(200,
+                    [("content-type", "text/plain")],
+                    bytes(f"Hello from Python! Got request URI: {request.uri}", "utf-8"))

spin.toml

@@ -7,6 +7,7 @@ version = "0.1.0"
 
 [[component]]
 id = "spin-webrtc"
+config = { redis_address = "redis://127.0.0.1:6379" }
 source = "target/wasm32-wasi/release/python-wasi-vfs-wizer.wasm"
 allowed_http_hosts = ["insecure:allow-all"]
 [component.trigger]

src/lib.rs

@@ -1,13 +1,19 @@
 #![deny(warnings)]
 
 use {
-    anyhow::{Error, Result},
+    anyhow::{anyhow, Error, Result},
+    bytes::Bytes,
     http::{header::HeaderName, request, HeaderValue},
     once_cell::unsync::OnceCell,
-    pyo3::{exceptions::PyAssertionError, types::PyModule, PyErr, PyObject, PyResult, Python},
+    pyo3::{
+        exceptions::PyAssertionError,
+        types::{PyBytes, PyModule},
+        Py, PyErr, PyObject, PyResult, Python,
+    },
     spin_sdk::{
+        config,
         http::{Request, Response},
-        outbound_http,
+        outbound_http, redis,
     },
     std::{ops::Deref, str},
 };
@@ -16,6 +22,14 @@ thread_local! {
     static HANDLE_REQUEST: OnceCell<PyObject> = OnceCell::new();
 }
 
+fn bytes(py: Python<'_>, src: &[u8]) -> PyResult<Py<PyBytes>> {
+    Ok(PyBytes::new_with(py, src.len(), |dst| {
+        dst.copy_from_slice(src);
+        Ok(())
+    })?
+    .into())
+}
+
 #[derive(Clone)]
 #[pyo3::pyclass]
 #[pyo3(name = "Request")]
@@ -26,9 +40,8 @@ struct HttpRequest {
     uri: String,
     #[pyo3(get, set)]
     headers: Vec<(String, String)>,
-    // todo: this should be a byte slice, but make sure it gets converted to/from Python correctly
     #[pyo3(get, set)]
-    body: Option<String>,
+    body: Option<Py<PyBytes>>,
 }
 
 #[pyo3::pymethods]
@@ -38,7 +51,7 @@ impl HttpRequest {
         method: String,
         uri: String,
         headers: Vec<(String, String)>,
-        body: Option<String>,
+        body: Option<Py<PyBytes>>,
     ) -> Self {
         Self {
             method,
@@ -57,15 +70,14 @@ struct HttpResponse {
     status: u16,
     #[pyo3(get, set)]
     headers: Vec<(String, String)>,
-    // todo: this should be a byte slice, but make sure it gets converted to/from Python correctly
     #[pyo3(get, set)]
-    body: Option<String>,
+    body: Option<Py<PyBytes>>,
 }
 
 #[pyo3::pymethods]
 impl HttpResponse {
     #[new]
-    fn new(status: u16, headers: Vec<(String, String)>, body: Option<String>) -> Self {
+    fn new(status: u16, headers: Vec<(String, String)>, body: Option<Py<PyBytes>>) -> Self {
         Self {
             status,
             headers,
@@ -89,23 +101,31 @@ impl<T: std::error::Error + Send + Sync + 'static> From<T> for Anyhow {
 }
 
 #[pyo3::pyfunction]
-fn send(request: HttpRequest) -> Result<HttpResponse, Anyhow> {
+#[pyo3(pass_module)]
+fn http_send(module: &PyModule, request: HttpRequest) -> PyResult<HttpResponse> {
     let mut builder = request::Builder::new()
         .method(request.method.deref())
         .uri(request.uri.deref());
 
     if let Some(headers) = builder.headers_mut() {
         for (key, value) in &request.headers {
             headers.insert(
-                HeaderName::from_bytes(key.as_bytes())?,
-                HeaderValue::from_bytes(value.as_bytes())?,
+                HeaderName::from_bytes(key.as_bytes()).map_err(Anyhow::from)?,
+                HeaderValue::from_bytes(value.as_bytes()).map_err(Anyhow::from)?,
             );
         }
     }
 
     let response = outbound_http::send_request(
-        builder.body(request.body.map(|buffer| buffer.into_bytes().into()))?,
-    )?;
+        builder
+            .body(
+                request
+                    .body
+                    .map(|buffer| Bytes::copy_from_slice(buffer.as_bytes(module.py()))),
+            )
+            .map_err(Anyhow::from)?,
+    )
+    .map_err(Anyhow::from)?;
 
     Ok(HttpResponse {
         status: response.status().as_u16(),
@@ -115,26 +135,66 @@ fn send(request: HttpRequest) -> Result<HttpResponse, Anyhow> {
             .map(|(key, value)| {
                 Ok((
                     key.as_str().to_owned(),
-                    str::from_utf8(value.as_bytes())?.to_owned(),
+                    str::from_utf8(value.as_bytes())
+                        .map_err(Anyhow::from)?
+                        .to_owned(),
                 ))
             })
-            .collect::<Result<_, Anyhow>>()?,
+            .collect::<PyResult<_>>()?,
         body: response
             .into_body()
-            .map(|bytes| String::from_utf8_lossy(&bytes).into_owned()),
+            .as_deref()
+            .map(|buffer| bytes(module.py(), buffer))
+            .transpose()?,
     })
 }
 
 #[pyo3::pymodule]
 #[pyo3(name = "spin_http")]
 fn spin_http_module(_py: Python<'_>, module: &PyModule) -> PyResult<()> {
-    module.add_function(pyo3::wrap_pyfunction!(send, module)?)?;
+    module.add_function(pyo3::wrap_pyfunction!(http_send, module)?)?;
     module.add_class::<HttpRequest>()?;
     module.add_class::<HttpResponse>()
 }
 
+#[pyo3::pyfunction]
+#[pyo3(pass_module)]
+fn redis_get(module: &PyModule, address: String, key: String) -> PyResult<Py<PyBytes>> {
+    bytes(
+        module.py(),
+        &redis::get(&address, &key)
+            .map_err(|_| Anyhow(anyhow!("Error executing Redis get command")))?,
+    )
+}
+
+#[pyo3::pyfunction]
+fn redis_set(address: String, key: String, value: &PyBytes) -> PyResult<()> {
+    redis::set(&address, &key, value.as_bytes())
+        .map_err(|_| PyErr::from(Anyhow(anyhow!("Error executing Redis set command"))))
+}
+
+#[pyo3::pymodule]
+#[pyo3(name = "spin_redis")]
+fn spin_redis_module(_py: Python<'_>, module: &PyModule) -> PyResult<()> {
+    module.add_function(pyo3::wrap_pyfunction!(redis_get, module)?)?;
+    module.add_function(pyo3::wrap_pyfunction!(redis_set, module)?)
+}
+
+#[pyo3::pyfunction]
+fn config_get(key: String) -> Result<String, Anyhow> {
+    config::get(&key).map_err(Anyhow::from)
+}
+
+#[pyo3::pymodule]
+#[pyo3(name = "spin_config")]
+fn spin_config_module(_py: Python<'_>, module: &PyModule) -> PyResult<()> {
+    module.add_function(pyo3::wrap_pyfunction!(config_get, module)?)
+}
+
 fn do_init() -> Result<()> {
     pyo3::append_to_inittab!(spin_http_module);
+    pyo3::append_to_inittab!(spin_redis_module);
+    pyo3::append_to_inittab!(spin_config_module);
 
     pyo3::prepare_freethreaded_python();
 
@@ -157,45 +217,57 @@ pub extern "C" fn init() {
 
 #[spin_sdk::http_component]
 fn handle(request: Request) -> Result<Response> {
-    let uri = request.uri().to_string();
-    let request = HttpRequest {
-        method: request.method().as_str().to_owned(),
-        uri,
-        headers: request
-            .headers()
-            .iter()
-            .map(|(k, v)| {
-                Ok((
-                    k.as_str().to_owned(),
-                    str::from_utf8(v.as_bytes())?.to_owned(),
-                ))
-            })
-            .collect::<Result<_>>()?,
-        body: request
-            .body()
-            .as_ref()
-            .map(|bytes| Ok::<_, Error>(str::from_utf8(bytes)?.to_owned()))
-            .transpose()?,
-    };
+    Python::with_gil(|py| {
+        let uri = request.uri().to_string();
 
-    let response = Python::with_gil(|py| {
-        HANDLE_REQUEST.with(|cell| {
+        let request = HttpRequest {
+            method: request.method().as_str().to_owned(),
+            uri,
+            headers: request
+                .headers()
+                .iter()
+                .map(|(k, v)| {
+                    Ok((
+                        k.as_str().to_owned(),
+                        str::from_utf8(v.as_bytes())
+                            .map_err(Anyhow::from)?
+                            .to_owned(),
+                    ))
+                })
+                .collect::<PyResult<_>>()?,
+            body: request
+                .body()
+                .as_deref()
+                .map(|buffer| bytes(py, buffer))
+                .transpose()?,
+        };
+
+        let response = HANDLE_REQUEST.with(|cell| {
             cell.get()
                 .unwrap()
                 .call1(py, (request,))?
                 .extract::<HttpResponse>(py)
-        })
-    })?;
+        })?;
 
-    let mut builder = http::Response::builder().status(response.status);
-    if let Some(headers) = builder.headers_mut() {
-        for (key, value) in &response.headers {
-            headers.insert(
-                HeaderName::try_from(key.deref())?,
-                HeaderValue::from_bytes(value.as_bytes())?,
-            );
+        let mut builder = http::Response::builder().status(response.status);
+        if let Some(headers) = builder.headers_mut() {
+            for (key, value) in &response.headers {
+                headers.insert(
+                    HeaderName::try_from(key.deref()).map_err(Anyhow::from)?,
+                    HeaderValue::from_bytes(value.as_bytes()).map_err(Anyhow::from)?,
+                );
+            }
         }
-    }
 
-    Ok(builder.body(response.body.map(|buffer| buffer.into()))?)
+        Ok::<_, PyErr>(
+            builder
+                .body(
+                    response
+                        .body
+                        .map(|buffer| Bytes::copy_from_slice(buffer.as_bytes(py))),
+                )
+                .map_err(Anyhow::from)?,
+        )
+    })
+    .map_err(Error::from)
 }