hyprstream_core/services/oauth/xrpc/
durable_reads.rs1use super::*;
4use crate::services::public_repo::{PublicRepoReader, PublicRepoSnapshot};
5use hyprstream_pds::dag_cbor::DagCbor;
6
7fn internal_error() -> Response {
8 xrpc_error(
9 StatusCode::INTERNAL_SERVER_ERROR,
10 errors::INTERNAL_SERVER_ERROR,
11 "public repository read failed",
12 )
13}
14fn missing_repo() -> Response {
15 xrpc_error(
16 StatusCode::BAD_REQUEST,
17 errors::REPO_NOT_FOUND,
18 "public repository is not available",
19 )
20}
21
22fn record_json(value: &DagCbor) -> anyhow::Result<Value> {
23 Ok(match value {
24 DagCbor::Null => Value::Null,
25 DagCbor::Bool(v) => json!(v),
26 DagCbor::Unsigned(v) => json!(v),
27 DagCbor::Negative(v) => json!(i64::try_from(*v)?),
28 DagCbor::Text(v) => json!(v),
29 DagCbor::Bytes(v) => json!({"$bytes":base64::engine::general_purpose::STANDARD.encode(v)}),
30 DagCbor::Link(v) => json!({"$link":v.to_string()}),
31 DagCbor::List(v) => Value::Array(v.iter().map(record_json).collect::<anyhow::Result<_>>()?),
32 DagCbor::Map(entries) => {
33 let mut object = serde_json::Map::new();
34 for (key, value) in entries {
35 let DagCbor::Text(key) = key else {
36 anyhow::bail!("invalid public map key");
37 };
38 object.insert(key.clone(), record_json(value)?);
39 }
40 Value::Object(object)
41 }
42 })
43}
44
45pub(super) async fn get_record(
46 store: &XrpcRepoStore,
47 writer: PublicRepoReader,
48 collection: &str,
49 rkey: &str,
50 cid: Option<&str>,
51) -> Response {
52 if collection.is_empty() || rkey.is_empty() {
53 return xrpc_error(
54 StatusCode::BAD_REQUEST,
55 errors::INVALID_REQUEST,
56 "collection and rkey are required",
57 );
58 }
59 let permit = match store.acquire_snapshot_work_owned().await {
60 Ok(permit) => permit,
61 Err(_) => return internal_error(),
62 };
63 let collection = collection.to_owned();
64 let rkey = rkey.to_owned();
65 let cid = cid.map(str::to_owned);
66 let result=writer.read(move |snapshot| -> anyhow::Result<Option<Option<Value>>> {
67 let _permit = permit;
68 let Some((snapshot,_))=snapshot else { return Ok(None); };
69 let key=match AtprotoRecordKey::new(rkey) { Ok(key)=>key, Err(_)=>return Ok(Some(None)) };
70 let Some(record)=snapshot.records.get(&(collection,key)) else { return Ok(Some(None)); };
71 if cid.is_some_and(|cid| cid != record.cid().to_string()) { return Ok(Some(None)); }
72 Ok(Some(Some(json!({"uri":record.uri(&snapshot.did),"cid":record.cid().to_string(),"value":record_json(record.value())?}))))
73 }).await;
74 match result {
75 Ok(Some(Some(value))) => axum::Json(value).into_response(),
76 Ok(Some(None)) => xrpc_error(
77 StatusCode::BAD_REQUEST,
78 errors::RECORD_NOT_FOUND,
79 "public record not found",
80 ),
81 Ok(None) => missing_repo(),
82 _ => internal_error(),
83 }
84}
85
86const MAX_PUBLIC_CAR_BYTES: usize = 2 * 1024 * 1024;
87
88fn append_car_block(car: &mut Vec<u8>, cid: Cid, bytes: &[u8]) -> anyhow::Result<()> {
89 let extra = bytes
91 .len()
92 .checked_add(cid.as_bytes().len() + 10)
93 .ok_or_else(|| anyhow::anyhow!("public CAR length overflow"))?;
94 anyhow::ensure!(
95 car.len()
96 .checked_add(extra)
97 .is_some_and(|size| size <= MAX_PUBLIC_CAR_BYTES),
98 "public CAR exceeds byte budget"
99 );
100 car.try_reserve_exact(extra)?;
101 car.extend_from_slice(&hyprstream_pds::car::car_block_bytes(cid, bytes));
102 Ok(())
103}
104
105fn repo_car(snapshot: &PublicRepoSnapshot) -> anyhow::Result<Vec<u8>> {
106 let keyed = snapshot
107 .records
108 .iter()
109 .map(|((collection, key), record)| (format!("{collection}/{}", key.as_str()), record.cid()))
110 .collect();
111 let (_, nodes) = Node::from_keyed_records(&keyed).to_node_data_with_blocks_atproto()?;
112 let commit_cid = snapshot.commit.cid_atproto()?;
113 let mut car = hyprstream_pds::car::build_car_v1_atproto(&[commit_cid], &[])?;
114 append_car_block(
115 &mut car,
116 commit_cid,
117 &snapshot.commit.to_atproto_dag_cbor()?,
118 )?;
119 for (cid, node) in nodes {
120 append_car_block(&mut car, cid, &node.encode_atproto()?)?;
121 }
122 for record in snapshot.records.values() {
123 append_car_block(&mut car, record.cid(), record.bytes())?;
124 }
125 Ok(car)
126}
127
128pub(super) async fn get_repo(
129 store: &XrpcRepoStore,
130 writer: PublicRepoReader,
131 since_present: bool,
132) -> Response {
133 if since_present {
134 return xrpc_error(
135 StatusCode::BAD_REQUEST,
136 errors::INVALID_REQUEST,
137 "since (revision delta) is not yet supported; omit for full export",
138 );
139 }
140 let permit = match store.acquire_get_repo_owned().await {
141 Ok(permit) => permit,
142 Err(_) => return internal_error(),
143 };
144 let work_permit = match store.acquire_snapshot_work_owned().await {
145 Ok(permit) => permit,
146 Err(_) => return internal_error(),
147 };
148 let result = writer
149 .read(move |snapshot| -> anyhow::Result<_> {
150 let _work_permit = work_permit;
151 let bytes = snapshot
152 .map(|(snapshot, _)| repo_car(&snapshot))
153 .transpose()?;
154 Ok((bytes, permit))
155 })
156 .await;
157 let (bytes, permit) = match result {
158 Ok((Some(bytes), permit)) => (bytes, permit),
159 Ok((None, _)) => return missing_repo(),
160 _ => return internal_error(),
161 };
162 let stream = stream::unfold((Some(Bytes::from(bytes)), permit), |mut state| async move {
165 let bytes = state.0.take()?;
166 Some((Ok::<_, std::io::Error>(bytes), state))
167 });
168 (
169 StatusCode::OK,
170 [(header::CONTENT_TYPE, "application/vnd.ipld.car")],
171 axum::body::Body::from_stream(stream),
172 )
173 .into_response()
174}
175
176pub(super) async fn describe_repo(state: &OAuthState, writer: PublicRepoReader) -> Response {
177 let handle = match &writer {
178 PublicRepoReader::Hosted { did, .. } => did.strip_prefix("did:web:").map(str::to_owned),
181 PublicRepoReader::Local(_) => {
182 let handle = state
183 .xrpc_repos
184 .get_public(writer.did())
185 .await
186 .map(|snapshot| snapshot.handle.clone());
187 handle.or_else(|| {
190 (state.atproto_service_did().as_deref() == Some(writer.did()))
191 .then(|| {
192 url::Url::parse(&state.issuer_url)
193 .ok()
194 .and_then(|url| url.host_str().map(str::to_owned))
195 })
196 .flatten()
197 })
198 }
199 };
200 let handle_is_correct = handle.is_some();
201 let handle = handle.unwrap_or_else(|| "handle.invalid".to_owned());
202 let permit = match state.xrpc_repos.acquire_snapshot_work_owned().await {
203 Ok(permit) => permit,
204 Err(_) => return internal_error(),
205 };
206 let issuer = state.issuer_url.clone();
207 let result=writer.read(move |snapshot| -> anyhow::Result<_> {
208 let _permit = permit;
209 let Some((snapshot,key))=snapshot else { return Ok(None); };
210 let collections:std::collections::BTreeSet<_>=snapshot.records.keys().map(|(collection,_)|collection.as_str()).collect();
211 let identity=AtprotoIdentity {p256_vk:&key,handle:&handle,drain:None,lead:None};
212 let mut did_doc=build_did_document(&snapshot.did,&issuer,&[],Some(&identity),&[],None,None);
213 if !handle_is_correct {
214 if let Some(document) = did_doc.as_object_mut() { document.remove("alsoKnownAs"); }
215 }
216 Ok(Some(json!({"handle":handle,"did":snapshot.did,"didDoc":did_doc,"collections":collections,"handleIsCorrect":handle_is_correct})))
217 }).await;
218 match result {
219 Ok(Some(value)) => axum::Json(value).into_response(),
220 Ok(None) => missing_repo(),
221 _ => internal_error(),
222 }
223}
224
225#[cfg(test)]
226mod tests {
227 use super::*;
228
229 #[test]
230 fn car_budget_rejects_before_appending_an_excess_section() {
231 let block = vec![0; 64 * 1024];
232 let cid = Cid::from_dag_cbor(&block);
233 let mut car = Vec::new();
234 loop {
235 let before = car.len();
236 if append_car_block(&mut car, cid, &block).is_err() {
237 assert_eq!(car.len(), before);
238 assert!(car.len() <= MAX_PUBLIC_CAR_BYTES);
239 break;
240 }
241 }
242 }
243}