Support for spin framework

Author: ChristianPavilonis

crates/mocktioneer-adapter-spin/.spin/logs/mocktioneer_stderr.txt

@@ -0,0 +1,23 @@
+[package]
+name = "mocktioneer-adapter-spin"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+path = "src/lib.rs"
+
+[features]
+default = ["spin"]
+spin = ["edgezero-adapter-spin/spin"]
+
+[dependencies]
+mocktioneer-core = { workspace = true }
+edgezero-adapter-spin = { workspace = true }
+anyhow = { workspace = true }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+edgezero-adapter-spin = { workspace = true, features = ["spin"] }
+edgezero-core = { workspace = true }
+spin-sdk = { workspace = true }

crates/mocktioneer-adapter-spin/.spin/logs/mocktioneer_stdout.txt

@@ -0,0 +1,16 @@
+spin_manifest_version = 2
+
+[application]
+name = "mocktioneer-adapter-spin"
+version = "0.1.0"
+
+[[trigger.http]]
+route = "/..."
+component = "mocktioneer"
+
+[component.mocktioneer]
+source = "../../target/wasm32-wasip1/release/mocktioneer_adapter_spin.wasm"
+allowed_outbound_hosts = ["https://*:*"]
+[component.mocktioneer.build]
+command = "cargo build --target wasm32-wasip1 --release"
+watch = ["src/**/*.rs", "Cargo.toml"]

crates/mocktioneer-adapter-spin/Cargo.toml

@@ -0,0 +1,12 @@
+#[cfg(target_arch = "wasm32")]
+use mocktioneer_core::MocktioneerApp;
+#[cfg(target_arch = "wasm32")]
+use spin_sdk::http::{IncomingRequest, IntoResponse};
+#[cfg(target_arch = "wasm32")]
+use spin_sdk::http_component;
+
+#[cfg(target_arch = "wasm32")]
+#[http_component]
+async fn handle(req: IncomingRequest) -> anyhow::Result<impl IntoResponse> {
+    edgezero_adapter_spin::run_app::<MocktioneerApp>(req).await
+}

crates/mocktioneer-adapter-spin/spin.toml

@@ -1,11 +1,11 @@
 use crate::aps::{ApsBidRequest, ApsBidResponse, ApsContextual, ApsSlotResponse};
+use crate::new_id;
 use crate::openrtb::{
     Bid as OpenrtbBid, Imp as OpenrtbImp, MediaType, OpenRTBRequest, OpenRTBResponse, SeatBid,
 };
 use crate::render::iframe_html;
 use phf::phf_map;
 use serde_json::json;
-use uuid::Uuid;
 
 // ============================================================================
 // Standard Ad Sizes - single source of truth for supported sizes and pricing
@@ -82,10 +82,6 @@ pub fn standard_sizes() -> impl Iterator<Item = (i64, i64)> {
     sizes.into_iter()
 }
 
-fn new_id() -> String {
-    Uuid::now_v7().simple().to_string()
-}
-
 pub fn size_from_imp(imp: &OpenrtbImp) -> (i64, i64) {
     // Prefer imp.banner.w/h; fallback to banner.format[0].w/h; default 300x250
     if let Some(banner) = &imp.banner {

crates/mocktioneer-adapter-spin/src/lib.rs

@@ -9,6 +9,13 @@ pub mod verification;
 edgezero_core::app!("../../edgezero.toml", MocktioneerApp);
 
 use edgezero_core::app::Hooks;
+use uuid::Uuid;
+
+/// Generate a new UUIDv7 identifier as a lowercase hex string.
+/// Shared across auction, mediation, and other modules that need unique IDs.
+pub(crate) fn new_id() -> String {
+    Uuid::now_v7().simple().to_string()
+}
 
 pub fn build_app() -> edgezero_core::app::App {
     MocktioneerApp::build_app()

crates/mocktioneer-core/src/auction.rs

@@ -3,17 +3,13 @@
 //! Provides a simple mediation endpoint that accepts bids from multiple bidders
 //! and selects winners based on price (highest price wins).
 
+use crate::new_id;
 use crate::openrtb::{Bid as OpenRTBBid, Imp, MediaType, OpenRTBResponse, SeatBid};
 use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
 use std::collections::HashMap;
-use uuid::Uuid;
 use validator::Validate;
 
-fn new_id() -> String {
-    Uuid::now_v7().simple().to_string()
-}
-
 /// Mediation request containing impression definitions and bidder responses
 #[derive(Debug, Clone, Serialize, Deserialize, Validate)]
 pub struct MediationRequest {

crates/mocktioneer-core/src/lib.rs

@@ -59,11 +59,11 @@ pub fn creative_html(w: i64, h: i64, pixel_html: bool, pixel_js: bool, host: &st
 const INFO_TMPL: &str = include_str!("../static/templates/info.html.hbs");
 pub fn info_html(host: &str) -> String {
     use std::env;
-    let service_id = env::var("FASTLY_SERVICE_ID").unwrap_or_else(|_| "".to_string());
-    let service_version = env::var("FASTLY_SERVICE_VERSION").unwrap_or_else(|_| "".to_string());
+    let service_id = env::var("FASTLY_SERVICE_ID").unwrap_or_default();
+    let service_version = env::var("FASTLY_SERVICE_VERSION").unwrap_or_default();
     let datacenter = env::var("FASTLY_DATACENTER")
         .or_else(|_| env::var("FASTLY_REGION"))
-        .unwrap_or_else(|_| "".to_string());
+        .unwrap_or_default();
     let pkg_version = env!("CARGO_PKG_VERSION");
     let data = serde_json::json!({
         "DATACENTER": datacenter,

crates/mocktioneer-core/src/mediation.rs

@@ -111,8 +111,6 @@ struct SizeDimensions {
     height: i64,
 }
 
-impl SizeDimensions {}
-
 struct ValidatedSize<F>(SizeDimensions, PhantomData<F>);
 
 async fn extract_size<F>(ctx: &RequestContext) -> Result<ValidatedSize<F>, EdgeError>
@@ -180,6 +178,24 @@ fn build_response(status: StatusCode, body: Body) -> Response {
         .expect("static response builder should not fail")
 }
 
+fn json_response(body: Body) -> Response {
+    let mut response = build_response(StatusCode::OK, body);
+    response.headers_mut().insert(
+        header::CONTENT_TYPE,
+        HeaderValue::from_static("application/json"),
+    );
+    response
+}
+
+fn html_response(body: Body) -> Response {
+    let mut response = build_response(StatusCode::OK, body);
+    response.headers_mut().insert(
+        header::CONTENT_TYPE,
+        HeaderValue::from_static("text/html; charset=utf-8"),
+    );
+    response
+}
+
 fn apply_cors(headers: &mut HeaderMap) {
     headers.insert("Access-Control-Allow-Origin", HeaderValue::from_static("*"));
     headers.insert(
@@ -225,12 +241,7 @@ fn options_response() -> Response {
 #[action]
 pub async fn handle_root(ForwardedHost(host): ForwardedHost) -> Response {
     let html = info_html(&host);
-    let mut response = build_response(StatusCode::OK, Body::text(html));
-    response.headers_mut().insert(
-        header::CONTENT_TYPE,
-        HeaderValue::from_static("text/html; charset=utf-8"),
-    );
-    response
+    html_response(Body::text(html))
 }
 
 #[action]
@@ -266,12 +277,7 @@ pub async fn handle_openrtb_auction(
         log::error!("Failed to serialize OpenRTB response: {}", e);
         EdgeError::internal(e)
     })?;
-    let mut response = build_response(StatusCode::OK, body);
-    response.headers_mut().insert(
-        header::CONTENT_TYPE,
-        HeaderValue::from_static("application/json"),
-    );
-    Ok(response)
+    Ok(json_response(body))
 }
 
 #[action]
@@ -305,12 +311,7 @@ pub async fn handle_static_creatives(
     let pixel_html = query.pixel_html.unwrap_or(true);
     let pixel_js = query.pixel_js.unwrap_or(false);
     let html = creative_html(w, h, pixel_html, pixel_js, &host);
-    let mut response = build_response(StatusCode::OK, Body::from(html));
-    response.headers_mut().insert(
-        header::CONTENT_TYPE,
-        HeaderValue::from_static("text/html; charset=utf-8"),
-    );
-    response
+    html_response(Body::from(html))
 }
 
 fn parse_cookie<'a>(cookie_header: &'a str, name: &str) -> Option<&'a str> {
@@ -330,13 +331,11 @@ const PIXEL_GIF: &[u8] = include_bytes!("../static/pixel.gif");
 #[action]
 pub async fn handle_pixel(
     Headers(headers): Headers,
-    ValidatedQuery(params): ValidatedQuery<PixelQueryParams>,
+    ValidatedQuery(_params): ValidatedQuery<PixelQueryParams>,
 ) -> Response {
     let cookie_name = "mtkid";
     let mut set_cookie = None;
 
-    let PixelQueryParams { pid: _ } = params;
-
     let existing = headers
         .get(header::COOKIE)
         .and_then(|c| c.to_str().ok())
@@ -353,23 +352,21 @@ pub async fn handle_pixel(
     }
 
     let mut response = build_response(StatusCode::OK, Body::from(PIXEL_GIF));
-    {
-        let headers = response.headers_mut();
-        headers.insert(header::CONTENT_TYPE, HeaderValue::from_static("image/gif"));
-        headers.insert(
-            header::CACHE_CONTROL,
-            HeaderValue::from_static("no-store, no-cache, must-revalidate, max-age=0"),
-        );
-        headers.insert("Pragma", HeaderValue::from_static("no-cache"));
-        headers.insert(
-            header::CONTENT_LENGTH,
-            HeaderValue::from_str(&PIXEL_GIF.len().to_string()).expect("length"),
-        );
-    }
+    let resp_headers = response.headers_mut();
+    resp_headers.insert(header::CONTENT_TYPE, HeaderValue::from_static("image/gif"));
+    resp_headers.insert(
+        header::CACHE_CONTROL,
+        HeaderValue::from_static("no-store, no-cache, must-revalidate, max-age=0"),
+    );
+    resp_headers.insert("Pragma", HeaderValue::from_static("no-cache"));
+    resp_headers.insert(
+        header::CONTENT_LENGTH,
+        HeaderValue::from_str(&PIXEL_GIF.len().to_string()).expect("length"),
+    );
 
     if let Some(cookie) = set_cookie {
         if let Ok(value) = HeaderValue::from_str(&cookie) {
-            response.headers_mut().append("Set-Cookie", value);
+            resp_headers.append("Set-Cookie", value);
         }
     }
 
@@ -400,12 +397,7 @@ pub async fn handle_aps_bid(
         log::error!("Failed to serialize APS response: {}", e);
         EdgeError::internal(e)
     })?;
-    let mut response = build_response(StatusCode::OK, body);
-    response.headers_mut().insert(
-        header::CONTENT_TYPE,
-        HeaderValue::from_static("application/json"),
-    );
-    Ok(response)
+    Ok(json_response(body))
 }
 
 #[action]
@@ -442,12 +434,7 @@ pub async fn handle_adserver_mediate(
         log::error!("Failed to serialize mediation response: {}", e);
         EdgeError::internal(e)
     })?;
-    let mut response = build_response(StatusCode::OK, body);
-    response.headers_mut().insert(
-        header::CONTENT_TYPE,
-        HeaderValue::from_static("application/json"),
-    );
-    Ok(response)
+    Ok(json_response(body))
 }
 
 #[action]
@@ -473,12 +460,7 @@ pub async fn handle_click(ValidatedQuery(params): ValidatedQuery<ClickQueryParam
             "EXTRA": extra_json,
         }),
     );
-    let mut response = build_response(StatusCode::OK, Body::from(html));
-    response.headers_mut().insert(
-        header::CONTENT_TYPE,
-        HeaderValue::from_static("text/html; charset=utf-8"),
-    );
-    response
+    html_response(Body::from(html))
 }
 
 /// Returns all standard ad sizes as JSON array.
@@ -509,12 +491,7 @@ pub async fn handle_sizes() -> Response {
         .collect();
 
     let body = serde_json::json!({ "sizes": sizes });
-    let mut response = build_response(StatusCode::OK, Body::from(body.to_string()));
-    response.headers_mut().insert(
-        header::CONTENT_TYPE,
-        HeaderValue::from_static("application/json"),
-    );
-    response
+    json_response(Body::from(body.to_string()))
 }
 
 #[cfg(test)]