1use futures::future::BoxFuture;
6use graphrt_core::file::{FileBytes, FileError, FileResolver};
7use graphrt_core::value::{File, FileTransfer};
8
9use crate::client::HttpClient;
10
11#[derive(Clone, Debug)]
13pub struct HttpFileResolver {
14 client: HttpClient,
15}
16
17impl HttpFileResolver {
18 pub fn new(client: HttpClient) -> Self {
19 Self { client }
20 }
21}
22
23impl FileResolver for HttpFileResolver {
24 fn read<'a>(&'a self, file: &'a File, max_bytes: u64) -> BoxFuture<'a, Result<FileBytes, FileError>> {
25 Box::pin(async move {
26 let Some(raw) = file.url.as_deref().filter(|u| u.starts_with("http://") || u.starts_with("https://"))
27 else {
28 return Err(FileError::Unsupported(file.name.clone()));
29 };
30 if file.transfer != FileTransfer::RemoteUrl && file.transfer != FileTransfer::ToolFile {
31 return Err(FileError::Unsupported(file.name.clone()));
32 }
33 let name = file.name.clone();
34 let url = reqwest::Url::parse(raw)
35 .map_err(|e| FileError::Invalid { name: name.clone(), message: format!("invalid URL: {e}") })?;
36 self.client.check_url(&url).map_err(|e| FileError::Denied { name: name.clone(), reason: e.to_string() })?;
37 let http =
38 self.client.client(true).map_err(|e| FileError::Io { name: name.clone(), message: e.to_string() })?;
39 let mut response = http
40 .get(url)
41 .send()
42 .await
43 .map_err(|e| FileError::Io { name: name.clone(), message: e.without_url().to_string() })?;
44 let status = response.status();
45 if status == reqwest::StatusCode::NOT_FOUND {
46 return Err(FileError::NotFound { name });
47 }
48 if !status.is_success() {
49 return Err(FileError::Io { name, message: format!("HTTP status {}", status.as_u16()) });
50 }
51 if response.content_length().is_some_and(|len| len > max_bytes) {
52 return Err(FileError::TooLarge { name, limit: max_bytes });
53 }
54 let mime = response
55 .headers()
56 .get(reqwest::header::CONTENT_TYPE)
57 .and_then(|v| v.to_str().ok())
58 .map(|v| v.split(';').next().unwrap_or(v).trim().to_owned())
59 .filter(|v| !v.is_empty())
60 .or_else(|| file.mime_type.clone());
61 let mut bytes = Vec::new();
62 loop {
63 match response.chunk().await {
64 Ok(Some(chunk)) => {
65 let total = u64::try_from(bytes.len().saturating_add(chunk.len())).unwrap_or(u64::MAX);
66 if total > max_bytes {
67 return Err(FileError::TooLarge { name, limit: max_bytes });
68 }
69 bytes.extend_from_slice(&chunk);
70 }
71 Ok(None) => break,
72 Err(e) => return Err(FileError::Io { name, message: e.without_url().to_string() }),
73 }
74 }
75 Ok(FileBytes { bytes, mime_type: mime })
76 })
77 }
78}
79
80#[cfg(test)]
81mod tests {
82 use super::*;
83 use crate::policy::EgressPolicy;
84
85 #[tokio::test]
86 async fn rejects_private_addresses_and_non_http() {
87 let resolver = HttpFileResolver::new(HttpClient::new(EgressPolicy::default()).unwrap());
88 let private = File { name: "x".into(), url: Some("http://127.0.0.1/x".into()), ..File::default() };
89 assert!(matches!(resolver.read(&private, 10).await, Err(FileError::Denied { .. })));
90 let data = File { name: "y".into(), url: Some("data:,hi".into()), ..File::default() };
91 assert!(matches!(resolver.read(&data, 10).await, Err(FileError::Unsupported(_))));
92 }
93}