Skip to main content

hyprstream_core/services/oauth/xrpc/
durable_reads.rs

1//! Public reads from the configured durable writer. Never populate or fall
2//! back to the independent hosted-model snapshot cache for this repository.
3use 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    // Conservative framing bound, checked before section allocation/copy.
90    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    // Only export admission survives through body EOF/drop. Snapshot-work
163    // admission ended with the blocking task, keeping point reads available.
164    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        // Hosted selection already validated this exact host against AccountZone.
179        // Legacy model metadata must not override the native account identity.
180        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            // No trusted handle exists for some PLC/non-issuer repositories.
188            // Preserve the issuer fallback and invalid-handle sentinel policy.
189            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}