dsc/api/
client.rs

1use super::models::{AboutResponse, SiteResponse};
2use super::rate_limit::{
3    RETRY_BUFFER, parse_rate_limit_wait, summarize_rate_limit_body,
4};
5use crate::config::DiscourseConfig;
6use crate::utils::normalize_baseurl;
7use anyhow::{Context, Result, anyhow};
8use reqwest::StatusCode;
9use reqwest::blocking::{Client, RequestBuilder, Response};
10use reqwest::header::{HeaderMap, HeaderValue};
11
12const MAX_RATE_LIMIT_RETRIES: u32 = 5;
13
14#[derive(Debug, Clone)]
15pub struct VersionInfo {
16    pub version: Option<String>,
17    pub commit: Option<String>,
18}
19
20/// HTTP client for the Discourse API.
21#[derive(Clone)]
22pub struct DiscourseClient {
23    baseurl: String,
24    client: Client,
25}
26
27impl DiscourseClient {
28    /// Create a new Discourse API client.
29    pub fn new(config: &DiscourseConfig) -> Result<Self> {
30        let baseurl = normalize_baseurl(&config.baseurl);
31        if baseurl.is_empty() {
32            return Err(anyhow!(
33                "missing baseurl for discourse {}; please set baseurl or check your config",
34                config.name
35            ));
36        }
37
38        let mut headers = HeaderMap::new();
39        if let (Some(apikey), Some(api_username)) =
40            (config.apikey.as_ref(), config.api_username.as_ref())
41        {
42            headers.insert(
43                "Api-Key",
44                HeaderValue::from_str(apikey).context("invalid api key")?,
45            );
46            headers.insert(
47                "Api-Username",
48                HeaderValue::from_str(api_username).context("invalid api username")?,
49            );
50        }
51
52        let client = Client::builder()
53            .default_headers(headers)
54            .build()
55            .context("building http client")?;
56
57        Ok(Self { baseurl, client })
58    }
59
60    /// Return the configured base URL.
61    pub fn baseurl(&self) -> &str {
62        &self.baseurl
63    }
64
65    pub(crate) fn get(&self, path: &str) -> Result<Response> {
66        let url = format!("{}{}", self.baseurl, path);
67        self.client.get(url).send().context("sending request")
68    }
69
70    pub(crate) fn post(&self, path: &str) -> Result<reqwest::blocking::RequestBuilder> {
71        let url = format!("{}{}", self.baseurl, path);
72        Ok(self.client.post(url))
73    }
74
75    pub(crate) fn put(&self, path: &str) -> Result<reqwest::blocking::RequestBuilder> {
76        let url = format!("{}{}", self.baseurl, path);
77        Ok(self.client.put(url))
78    }
79
80    pub(crate) fn delete(&self, path: &str) -> Result<reqwest::blocking::Response> {
81        let url = format!("{}{}", self.baseurl, path);
82        self.client.delete(url).send().context("sending delete request")
83    }
84
85    /// Send a request, retrying up to 5 times on HTTP 429 responses.
86    ///
87    /// The `build` closure is called once per attempt and must produce a fresh
88    /// `RequestBuilder` each time; this lets callers with non-cloneable bodies
89    /// (e.g. multipart forms) participate in retries.
90    pub(crate) fn send_retrying<F>(&self, mut build: F) -> Result<Response>
91    where
92        F: FnMut() -> Result<RequestBuilder>,
93    {
94        let mut attempt: u32 = 0;
95        loop {
96            let rb = build()?;
97            let response = rb.send().context("sending request")?;
98            if response.status() != StatusCode::TOO_MANY_REQUESTS {
99                return Ok(response);
100            }
101            let headers = response.headers().clone();
102            let body = response
103                .text()
104                .unwrap_or_else(|_| "<failed to read 429 body>".to_string());
105            if attempt >= MAX_RATE_LIMIT_RETRIES {
106                return Err(anyhow!(
107                    "rate-limited after {} retries: {}",
108                    MAX_RATE_LIMIT_RETRIES,
109                    summarize_rate_limit_body(&body)
110                ));
111            }
112            attempt += 1;
113            let wait = parse_rate_limit_wait(&headers, &body) + RETRY_BUFFER;
114            eprintln!(
115                "Rate limited, waiting {}s (retry {}/{})",
116                wait.as_secs(),
117                attempt,
118                MAX_RATE_LIMIT_RETRIES
119            );
120            std::thread::sleep(wait);
121        }
122    }
123
124    /// Fetch the Discourse site title.
125    pub fn fetch_site_title(&self) -> Result<String> {
126        let site_json_error = match self.get("/site.json") {
127            Ok(response) => {
128                let status = response.status();
129                let text = response.text().context("reading site.json response body")?;
130                if status.is_success() {
131                    let body: SiteResponse =
132                        serde_json::from_str(&text).context("parsing site.json")?;
133                    return Ok(body.site.title);
134                }
135                anyhow!("site.json request failed with {}", status)
136            }
137            Err(err) => err,
138        };
139
140        let response = self.get("/")?;
141        let status = response.status();
142        let html = response.text().context("reading site HTML")?;
143        if !status.is_success() {
144            return Err(anyhow!(
145                "site title lookup failed (site.json error: {}; HTML request failed with {})",
146                site_json_error,
147                status
148            ));
149        }
150        if let Some(title) = extract_html_title(&html) {
151            return Ok(title);
152        }
153        Err(anyhow!(
154            "site title lookup failed (site.json error: {}; HTML missing <title>)",
155            site_json_error
156        ))
157    }
158
159    /// Fetch the current Discourse version and commit hash.
160    pub fn fetch_version_info(&self) -> Result<VersionInfo> {
161        let mut version = None;
162        let mut commit = None;
163        let mut last_err = None;
164
165        match self.get("/about.json") {
166            Ok(response) => {
167                let status = response.status();
168                match response.json::<AboutResponse>() {
169                    Ok(body) => {
170                        if status.is_success() {
171                            version = body.about.version.or(body.about.installed_version);
172                        } else {
173                            last_err = Some(anyhow!("about.json request failed with {}", status));
174                        }
175                    }
176                    Err(err) => {
177                        last_err = Some(anyhow!("reading about.json: {}", err));
178                    }
179                }
180            }
181            Err(err) => {
182                last_err = Some(err);
183            }
184        }
185
186        match self.get("/") {
187            Ok(response) => {
188                let status = response.status();
189                let html = response.text().context("reading site HTML")?;
190                if !status.is_success() {
191                    last_err = Some(anyhow!("site HTML request failed with {}", status));
192                } else if let Some(content) = extract_meta_content(&html, "generator") {
193                    let (html_version, html_commit) = parse_generator_content(&content);
194                    if version.is_none() {
195                        version = html_version;
196                    }
197                    if commit.is_none() {
198                        commit = html_commit;
199                    }
200                }
201            }
202            Err(err) => {
203                last_err = Some(err);
204            }
205        }
206
207        if version.is_none() && commit.is_none() {
208            return Err(last_err.unwrap_or_else(|| anyhow!("version fetch failed")));
209        }
210
211        Ok(VersionInfo { version, commit })
212    }
213
214    /// Fetch the current Discourse version (best-effort).
215    pub fn fetch_version(&self) -> Result<Option<String>> {
216        Ok(self.fetch_version_info()?.version)
217    }
218}
219
220fn extract_html_title(html: &str) -> Option<String> {
221    let haystack = html.as_bytes();
222    let mut lower = Vec::with_capacity(haystack.len());
223    for &byte in haystack {
224        lower.push(byte.to_ascii_lowercase());
225    }
226    let open_tag = b"<title>";
227    let close_tag = b"</title>";
228    let start = find_subslice(&lower, open_tag)? + open_tag.len();
229    let end = find_subslice(&lower[start..], close_tag)? + start;
230    let title = String::from_utf8_lossy(&haystack[start..end])
231        .trim()
232        .to_string();
233    if title.is_empty() { None } else { Some(title) }
234}
235
236fn extract_meta_content(html: &str, name: &str) -> Option<String> {
237    let lower = html.to_ascii_lowercase();
238    let name_attr = format!("name=\"{}\"", name.to_ascii_lowercase());
239    let name_attr_single = format!("name='{}'", name.to_ascii_lowercase());
240
241    let mut start = 0;
242    while let Some(pos) = lower[start..].find("<meta") {
243        let tag_start = start + pos;
244        let rest = &lower[tag_start..];
245        let tag_end = rest.find('>')? + tag_start;
246        let tag_lower = &lower[tag_start..tag_end];
247        if tag_lower.contains(&name_attr) || tag_lower.contains(&name_attr_single) {
248            let tag_original = &html[tag_start..tag_end];
249            if let Some(value) = extract_attr_value(tag_original, "content") {
250                return Some(value);
251            }
252        }
253        start = tag_end + 1;
254    }
255    None
256}
257
258fn extract_attr_value(tag: &str, attr: &str) -> Option<String> {
259    let lower = tag.to_ascii_lowercase();
260    let attr_eq = format!("{}=", attr.to_ascii_lowercase());
261    let pos = lower.find(&attr_eq)? + attr_eq.len();
262    let rest = &tag[pos..];
263    let mut chars = rest.chars();
264    let quote = chars.next()?;
265    if quote != '"' && quote != '\'' {
266        return None;
267    }
268    let value: String = chars.take_while(|c| *c != quote).collect();
269    if value.is_empty() { None } else { Some(value) }
270}
271
272fn parse_generator_content(content: &str) -> (Option<String>, Option<String>) {
273    let mut version = None;
274    let mut commit = None;
275
276    if let Some(rest) = content.strip_prefix("Discourse ") {
277        let ver = rest.split(" - ").next().map(|s| s.trim()).unwrap_or("");
278        if !ver.is_empty() {
279            version = Some(ver.to_string());
280        }
281    }
282
283    if let Some(idx) = content.find("version ") {
284        let tail = &content[idx + "version ".len()..];
285        let hash = tail.split_whitespace().next().unwrap_or("");
286        if !hash.is_empty() {
287            commit = Some(hash.to_string());
288        }
289    }
290
291    (version, commit)
292}
293
294fn find_subslice(haystack: &[u8], needle: &[u8]) -> Option<usize> {
295    if needle.is_empty() || haystack.len() < needle.len() {
296        return None;
297    }
298    haystack
299        .windows(needle.len())
300        .position(|window| window == needle)
301}
dsc/api/client.rs

dsc/api/
client.rs
