+4 -1

Cargo.lock

··· 4640 4640 name = "slingshot" 4641 4641 version = "0.1.0" 4642 4642 dependencies = [ 4643 4643 - "axum", 4644 4643 "clap", 4645 4644 "ctrlc", 4645 4645 + "dropshot", 4646 4646 "env_logger", 4647 4647 "foyer", 4648 4648 + "http", 4648 4649 "jetstream", 4649 4650 "log", 4650 4651 "metrics", 4651 4652 "metrics-exporter-prometheus 0.17.2", 4653 4653 + "schemars", 4654 4654 + "semver", 4652 4655 "serde", 4653 4656 "serde_json", 4654 4657 "thiserror 2.0.12",

+4

slingshot/Cargo.toml

··· 6 6 [dependencies] 7 7 clap = { version = "4.5.41", features = ["derive"] } 8 8 ctrlc = "3.4.7" 9 9 + dropshot = "0.16.2" 9 10 env_logger = "0.11.8" 10 11 foyer = { version = "0.18.0", features = ["serde"] } 12 12 + http = "1.3.1" 11 13 jetstream = { path = "../jetstream", features = ["metrics"] } 12 14 log = "0.4.27" 13 15 metrics = "0.24.2" 14 16 metrics-exporter-prometheus = { version = "0.17.1", features = ["http-listener"] } 17 17 + schemars = { version = "0.8.22", features = ["raw_value"] } 18 18 + semver = "1.0.26" 15 19 serde = { version = "1.0.219", features = ["derive"] } 16 20 serde_json = { version = "1.0.141", features = ["raw_value"] } 17 21 thiserror = "2.0.12"

+6 -2

slingshot/src/consumer.rs

··· 64 64 cache.insert(at_uri, CachedRecord::Deleted); 65 65 } else { 66 66 let Some(record) = commit.record.take() else { 67 67 - log::warn!("consumer: commit update/delete missing record, ignoring"); 67 67 + log::warn!("consumer: commit insert or update missing record, ignoring"); 68 68 + continue; 69 69 + }; 70 70 + let Some(cid) = commit.cid.take() else { 71 71 + log::warn!("consumer: commit insert or update missing CID, ignoring"); 68 72 continue; 69 73 }; 70 74 71 71 - cache.insert(at_uri, CachedRecord::Found(record.into())); 75 75 + cache.insert(at_uri, CachedRecord::Found((cid, record).into())); 72 76 } 73 77 } 74 78

+18 -2

slingshot/src/error.rs

··· 13 13 } 14 14 15 15 #[derive(Debug, Error)] 16 16 + pub enum ServerError { 17 17 + #[error("failed to configure server logger: {0}")] 18 18 + ConfigLogError(std::io::Error), 19 19 + #[error("failed to render json for openapi: {0}")] 20 20 + OpenApiJsonFail(serde_json::Error), 21 21 + #[error(transparent)] 22 22 + FailedToBuildServer(#[from] dropshot::BuildError), 23 23 + #[error("server exited: {0}")] 24 24 + ServerExited(String), 25 25 + #[error("server closed badly: {0}")] 26 26 + BadClose(String), 27 27 + #[error("blahhhahhahha")] 28 28 + OhNo(String), 29 29 + } 30 30 + 31 31 + #[derive(Debug, Error)] 16 32 pub enum MainTaskError { 17 33 #[error(transparent)] 18 34 ConsumerTaskError(#[from] ConsumerError), 19 19 - // #[error(transparent)] 20 20 - // ServerTaskError(#[from] ServerError), 35 35 + #[error(transparent)] 36 36 + ServerTaskError(#[from] ServerError), 21 37 }

+2

slingshot/src/lib.rs

··· 2 2 pub mod error; 3 3 mod firehose_cache; 4 4 mod record; 5 5 + mod server; 5 6 6 7 pub use consumer::consume; 7 8 pub use firehose_cache::firehose_cache; 8 9 pub use record::CachedRecord; 10 10 + pub use server::serve;

+8 -1

slingshot/src/main.rs

··· 1 1 // use foyer::HybridCache; 2 2 // use foyer::{Engine, DirectFsDeviceOptions, HybridCacheBuilder}; 3 3 use metrics_exporter_prometheus::PrometheusBuilder; 4 4 - use slingshot::{consume, error::MainTaskError, firehose_cache}; 4 4 + use slingshot::{consume, error::MainTaskError, firehose_cache, serve}; 5 5 6 6 use clap::Parser; 7 7 use tokio_util::sync::CancellationToken; ··· 44 44 log::info!("firehose cache ready."); 45 45 46 46 let mut tasks: tokio::task::JoinSet<Result<(), MainTaskError>> = tokio::task::JoinSet::new(); 47 47 + 48 48 + let server_shutdown = shutdown.clone(); 49 49 + let server_cache_handle = cache.clone(); 50 50 + tasks.spawn(async move { 51 51 + serve(server_cache_handle, server_shutdown).await?; 52 52 + Ok(()) 53 53 + }); 47 54 48 55 let consumer_shutdown = shutdown.clone(); 49 56 tasks.spawn(async move {

+18 -7

slingshot/src/record.rs

··· 1 1 use serde_json::value::RawValue; 2 2 use serde::{Serialize, Deserialize}; 3 3 + use jetstream::exports::Cid; 3 4 4 5 #[derive(Debug, Serialize, Deserialize)] 5 5 - pub struct RawRecord(String); 6 6 + pub struct RawRecord { 7 7 + cid: Cid, 8 8 + record: String, 9 9 + } 6 10 7 7 - impl From<Box<RawValue>> for RawRecord { 8 8 - fn from(rv: Box<RawValue>) -> Self { 9 9 - Self(rv.get().to_string()) 11 11 + // TODO: should be able to do typed CID 12 12 + impl From<(Cid, Box<RawValue>)> for RawRecord { 13 13 + fn from((cid, rv): (Cid, Box<RawValue>)) -> Self { 14 14 + Self { 15 15 + cid, 16 16 + record: rv.get().to_string(), 17 17 + } 10 18 } 11 19 } 12 20 13 21 /// only for use with stored (validated) values, not general strings 14 14 - impl From<RawRecord> for Box<RawValue> { 15 15 - fn from(RawRecord(s): RawRecord) -> Self { 16 16 - RawValue::from_string(s).expect("stored string from RawValue to be valid") 22 22 + impl From<&RawRecord> for (Cid, Box<RawValue>) { 23 23 + fn from(RawRecord { cid, record }: &RawRecord) -> Self { 24 24 + ( 25 25 + cid.clone(), 26 26 + RawValue::from_string(record.to_string()).expect("stored string from RawValue to be valid"), 27 27 + ) 17 28 } 18 29 } 19 30

+308

slingshot/src/server.rs

··· 1 1 + use serde_json::value::RawValue; 2 2 + use crate::CachedRecord; 3 3 + use foyer::HybridCache; 4 4 + use crate::error::ServerError; 5 5 + use dropshot::{ 6 6 + ApiDescription, Body, ConfigDropshot, ConfigLogging, 7 7 + ConfigLoggingLevel, HttpError, HttpResponse, Query, RequestContext, 8 8 + ServerBuilder, ServerContext, endpoint, 9 9 + ClientErrorStatusCode, 10 10 + }; 11 11 + use http::{ 12 12 + Response, StatusCode, 13 13 + header::{ORIGIN, USER_AGENT}, 14 14 + }; 15 15 + use metrics::{counter, histogram}; 16 16 + use std::sync::Arc; 17 17 + 18 18 + use schemars::JsonSchema; 19 19 + use serde::{Deserialize, Serialize}; 20 20 + use tokio::time::Instant; 21 21 + use tokio_util::sync::CancellationToken; 22 22 + 23 23 + const INDEX_HTML: &str = include_str!("../static/index.html"); 24 24 + const FAVICON: &[u8] = include_bytes!("../static/favicon.ico"); 25 25 + 26 26 + pub async fn serve( 27 27 + cache: HybridCache<String, CachedRecord>, 28 28 + shutdown: CancellationToken, 29 29 + ) -> Result<(), ServerError> { 30 30 + let config_logging = ConfigLogging::StderrTerminal { 31 31 + level: ConfigLoggingLevel::Info, 32 32 + }; 33 33 + 34 34 + let log = config_logging 35 35 + .to_logger("example-basic") 36 36 + .map_err(ServerError::ConfigLogError)?; 37 37 + 38 38 + let mut api = ApiDescription::new(); 39 39 + api.register(index).unwrap(); 40 40 + api.register(favicon).unwrap(); 41 41 + api.register(openapi).unwrap(); 42 42 + api.register(get_record).unwrap(); 43 43 + 44 44 + // TODO: put spec in a once cell / lazy lock thing? 45 45 + let spec = Arc::new( 46 46 + api.openapi( 47 47 + "Slingshot", 48 48 + env!("CARGO_PKG_VERSION") 49 49 + .parse() 50 50 + .inspect_err(|e| { 51 51 + eprintln!("failed to parse cargo package version for openapi: {e:?}") 52 52 + }) 53 53 + .unwrap_or(semver::Version::new(0, 0, 1)), 54 54 + ) 55 55 + .description("A fast edge cache for getRecord") 56 56 + .contact_name("part of @microcosm.blue") 57 57 + .contact_url("https://microcosm.blue") 58 58 + .json() 59 59 + .map_err(ServerError::OpenApiJsonFail)?, 60 60 + ); 61 61 + 62 62 + let sub_shutdown = shutdown.clone(); 63 63 + let ctx = Context { 64 64 + cache, 65 65 + spec, 66 66 + shutdown: sub_shutdown, 67 67 + }; 68 68 + 69 69 + let server = ServerBuilder::new(api, ctx, log) 70 70 + .config(ConfigDropshot { 71 71 + bind_address: "0.0.0.0:9996".parse().unwrap(), 72 72 + ..Default::default() 73 73 + }) 74 74 + .start()?; 75 75 + 76 76 + tokio::select! { 77 77 + s = server.wait_for_shutdown() => { 78 78 + s.map_err(ServerError::ServerExited)?; 79 79 + log::info!("server shut down normally."); 80 80 + }, 81 81 + _ = shutdown.cancelled() => { 82 82 + log::info!("shutting down: closing server"); 83 83 + server.close().await.map_err(ServerError::BadClose)?; 84 84 + }, 85 85 + } 86 86 + Ok(()) 87 87 + } 88 88 + 89 89 + #[derive(Debug, Clone)] 90 90 + struct Context { 91 91 + pub cache: HybridCache<String, CachedRecord>, 92 92 + pub spec: Arc<serde_json::Value>, 93 93 + pub shutdown: CancellationToken, 94 94 + } 95 95 + 96 96 + async fn instrument_handler<T, H, R>(ctx: &RequestContext<T>, handler: H) -> Result<R, HttpError> 97 97 + where 98 98 + R: HttpResponse, 99 99 + H: Future<Output = Result<R, HttpError>>, 100 100 + T: ServerContext, 101 101 + { 102 102 + let start = Instant::now(); 103 103 + let result = handler.await; 104 104 + let latency = start.elapsed(); 105 105 + let status_code = match &result { 106 106 + Ok(response) => response.status_code(), 107 107 + Err(e) => e.status_code.as_status(), 108 108 + } 109 109 + .as_str() // just the number (.to_string()'s Display does eg `200 OK`) 110 110 + .to_string(); 111 111 + let endpoint = ctx.endpoint.operation_id.clone(); 112 112 + let headers = ctx.request.headers(); 113 113 + let origin = headers 114 114 + .get(ORIGIN) 115 115 + .and_then(|v| v.to_str().ok()) 116 116 + .unwrap_or("") 117 117 + .to_string(); 118 118 + let ua = headers 119 119 + .get(USER_AGENT) 120 120 + .and_then(|v| v.to_str().ok()) 121 121 + .map(|ua| { 122 122 + if ua.starts_with("Mozilla/5.0 ") { 123 123 + "browser" 124 124 + } else { 125 125 + ua 126 126 + } 127 127 + }) 128 128 + .unwrap_or("") 129 129 + .to_string(); 130 130 + counter!("server_requests_total", 131 131 + "endpoint" => endpoint.clone(), 132 132 + "origin" => origin, 133 133 + "ua" => ua, 134 134 + "status_code" => status_code, 135 135 + ) 136 136 + .increment(1); 137 137 + histogram!("server_handler_latency", "endpoint" => endpoint).record(latency.as_micros() as f64); 138 138 + result 139 139 + } 140 140 + 141 141 + use dropshot::{HttpResponseHeaders, HttpResponseOk}; 142 142 + 143 143 + pub type OkCorsResponse<T> = Result<HttpResponseHeaders<HttpResponseOk<T>>, HttpError>; 144 144 + 145 145 + /// Helper for constructing Ok responses: return OkCors(T).into() 146 146 + /// (not happy with this yet) 147 147 + pub struct OkCors<T: Serialize + JsonSchema + Send + Sync>(pub T); 148 148 + 149 149 + impl<T> From<OkCors<T>> for OkCorsResponse<T> 150 150 + where 151 151 + T: Serialize + JsonSchema + Send + Sync, 152 152 + { 153 153 + fn from(ok: OkCors<T>) -> OkCorsResponse<T> { 154 154 + let mut res = HttpResponseHeaders::new_unnamed(HttpResponseOk(ok.0)); 155 155 + res.headers_mut() 156 156 + .insert("access-control-allow-origin", "*".parse().unwrap()); 157 157 + Ok(res) 158 158 + } 159 159 + } 160 160 + 161 161 + pub fn cors_err(e: HttpError) -> HttpError { 162 162 + e.with_header("access-control-allow-origin", "*").unwrap() 163 163 + } 164 164 + 165 165 + 166 166 + // TODO: cors for HttpError 167 167 + 168 168 + /// Serve index page as html 169 169 + #[endpoint { 170 170 + method = GET, 171 171 + path = "/", 172 172 + /* 173 173 + * not useful to have this in openapi 174 174 + */ 175 175 + unpublished = true, 176 176 + }] 177 177 + async fn index(ctx: RequestContext<Context>) -> Result<Response<Body>, HttpError> { 178 178 + instrument_handler(&ctx, async { 179 179 + Ok(Response::builder() 180 180 + .status(StatusCode::OK) 181 181 + .header(http::header::CONTENT_TYPE, "text/html") 182 182 + .body(INDEX_HTML.into())?) 183 183 + }) 184 184 + .await 185 185 + } 186 186 + 187 187 + /// Serve index page as html 188 188 + #[endpoint { 189 189 + method = GET, 190 190 + path = "/favicon.ico", 191 191 + /* 192 192 + * not useful to have this in openapi 193 193 + */ 194 194 + unpublished = true, 195 195 + }] 196 196 + async fn favicon(ctx: RequestContext<Context>) -> Result<Response<Body>, HttpError> { 197 197 + instrument_handler(&ctx, async { 198 198 + Ok(Response::builder() 199 199 + .status(StatusCode::OK) 200 200 + .header(http::header::CONTENT_TYPE, "image/x-icon") 201 201 + .body(FAVICON.to_vec().into())?) 202 202 + }) 203 203 + .await 204 204 + } 205 205 + 206 206 + /// Meta: get the openapi spec for this api 207 207 + #[endpoint { 208 208 + method = GET, 209 209 + path = "/openapi", 210 210 + /* 211 211 + * not useful to have this in openapi 212 212 + */ 213 213 + unpublished = true, 214 214 + }] 215 215 + async fn openapi(ctx: RequestContext<Context>) -> OkCorsResponse<serde_json::Value> { 216 216 + instrument_handler(&ctx, async { 217 217 + let spec = (*ctx.context().spec).clone(); 218 218 + OkCors(spec).into() 219 219 + }) 220 220 + .await 221 221 + } 222 222 + 223 223 + 224 224 + #[derive(Debug, Deserialize, JsonSchema)] 225 225 + struct GetRecordQuery { 226 226 + /// The DID of the repo 227 227 + /// 228 228 + /// NOTE: handles should be accepted here but this is still TODO in slingshot 229 229 + pub repo: String, 230 230 + /// The NSID of the record collection 231 231 + pub collection: String, 232 232 + /// The Record key 233 233 + pub rkey: String, 234 234 + /// Optional: the CID of the version of the record. 235 235 + /// 236 236 + /// If not specified, then return the most recent version. 237 237 + /// 238 238 + /// If specified and a newer version of the record exists, returns 404 not 239 239 + /// found. That is: slingshot only retains the most recent version of a 240 240 + /// record. 241 241 + #[serde(default)] 242 242 + pub cid: Option<String>, 243 243 + } 244 244 + 245 245 + #[derive(Debug, Serialize, JsonSchema)] 246 246 + struct GetRecordResponse { 247 247 + pub uri: String, 248 248 + pub cid: String, 249 249 + pub value: Box<RawValue>, 250 250 + } 251 251 + 252 252 + /// com.atproto.repo.getRecord 253 253 + /// 254 254 + /// Get a single record from a repository. Does not require auth. 255 255 + /// 256 256 + /// See https://docs.bsky.app/docs/api/com-atproto-repo-get-record for the 257 257 + /// canonical XRPC documentation that this endpoint aims to be compatible with. 258 258 + #[endpoint { 259 259 + method = GET, 260 260 + path = "/xrpc/com.atproto.repo.getRecord", 261 261 + }] 262 262 + async fn get_record( 263 263 + ctx: RequestContext<Context>, 264 264 + query: Query<GetRecordQuery>, 265 265 + ) -> OkCorsResponse<GetRecordResponse> { 266 266 + 267 267 + let Context { cache, .. } = ctx.context(); 268 268 + let GetRecordQuery { repo, collection, rkey, cid } = query.into_inner(); 269 269 + 270 270 + // TODO: yeah yeah 271 271 + let at_uri = format!( 272 272 + "at://{}/{}/{}", 273 273 + &*repo, &*collection, &*rkey 274 274 + ); 275 275 + 276 276 + instrument_handler(&ctx, async { 277 277 + let entry = cache 278 278 + .fetch(at_uri.clone(), || async move { 279 279 + Err(foyer::Error::Other(Box::new(ServerError::OhNo("booo".to_string())))) 280 280 + }) 281 281 + .await 282 282 + .unwrap(); 283 283 + 284 284 + match *entry { 285 285 + CachedRecord::Found(ref raw) => { 286 286 + let (found_cid, raw_value) = raw.into(); 287 287 + let found_cid = found_cid.as_ref().to_string(); 288 288 + if cid.map(|c| c != found_cid).unwrap_or(false) { 289 289 + Err(HttpError::for_not_found(None, "CID mismatch".to_string())) 290 290 + .map_err(cors_err)?; 291 291 + } 292 292 + OkCors(GetRecordResponse { 293 293 + uri: at_uri, 294 294 + cid: found_cid, 295 295 + value: raw_value, 296 296 + }).into() 297 297 + }, 298 298 + CachedRecord::Deleted => { 299 299 + Err(HttpError::for_client_error_with_status( 300 300 + Some("Gone".to_string()), 301 301 + ClientErrorStatusCode::GONE, 302 302 + )).map_err(cors_err) 303 303 + } 304 304 + } 305 305 + }) 306 306 + .await 307 307 + 308 308 + }

slingshot/static/favicon.ico

This is a binary file and will not be displayed.

+53

slingshot/static/index.html

··· 1 1 + <!doctype html> 2 2 + <html lang="en"> 3 3 + <head> 4 4 + <meta charset="utf-8" /> 5 5 + <title>Slingshot documentation</title> 6 6 + <meta name="viewport" content="width=device-width, initial-scale=1" /> 7 7 + <meta name="description" content="API Documentation for Slingshot, a fast edge cache for getRecord" /> 8 8 + <style> 9 9 + .custom-header { 10 10 + height: 42px; 11 11 + background-color: #221828; 12 12 + box-shadow: inset 0 -1px 0 var(--scalar-border-color); 13 13 + color: var(--scalar-color-1); 14 14 + font-size: var(--scalar-font-size-3); 15 15 + font-family: 'Iowan Old Style', 'Palatino Linotype', 'URW Palladio L', P052, serif; 16 16 + padding: 0 18px; 17 17 + justify-content: space-between; 18 18 + } 19 19 + .custom-header, 20 20 + .custom-header nav { 21 21 + display: flex; 22 22 + align-items: center; 23 23 + gap: 18px; 24 24 + } 25 25 + .custom-header a:hover { 26 26 + color: var(--scalar-color-2); 27 27 + } 28 28 + </style> 29 29 + </head> 30 30 + <body> 31 31 + <header class="custom-header scalar-app"> 32 32 + <p> 33 33 + <a href="https://microcosm.blue">todo: what link goes here?</a>: blah 34 34 + </p> 35 35 + <nav> 36 36 + <b>a <a href="https://microcosm.blue">microcosm</a> project</b> 37 37 + <a href="https://bsky.app/profile/microcosm.blue">@microcosm.blue</a> 38 38 + <a href="https://github.com/at-microcosm">github</a> 39 39 + </nav> 40 40 + </header> 41 41 + 42 42 + <script id="api-reference" type="application/json" data-url="/openapi"></script> 43 43 + 44 44 + <script> 45 45 + var configuration = { 46 46 + theme: 'purple', 47 47 + } 48 48 + document.getElementById('api-reference').dataset.configuration = JSON.stringify(configuration) 49 49 + </script> 50 50 + 51 51 + <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script> 52 52 + </body> 53 53 + </html>