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    pub(crate) fn delete_builder(&self, path: &str) -> Result<RequestBuilder> {
86        let url = format!("{}{}", self.baseurl, path);
87        Ok(self.client.delete(url))
88    }
89
90    /// Send a request, retrying up to 5 times on HTTP 429 responses.
91    ///
92    /// The `build` closure is called once per attempt and must produce a fresh
93    /// `RequestBuilder` each time; this lets callers with non-cloneable bodies
94    /// (e.g. multipart forms) participate in retries.
95    pub(crate) fn send_retrying<F>(&self, mut build: F) -> Result<Response>
96    where
97        F: FnMut() -> Result<RequestBuilder>,
98    {
99        let mut attempt: u32 = 0;
100        loop {
101            let rb = build()?;
102            let response = rb.send().context("sending request")?;
103            if response.status() != StatusCode::TOO_MANY_REQUESTS {
104                return Ok(response);
105            }
106            let headers = response.headers().clone();
107            let body = response
108                .text()
109                .unwrap_or_else(|_| "<failed to read 429 body>".to_string());
110            if attempt >= MAX_RATE_LIMIT_RETRIES {
111                return Err(anyhow!(
112                    "rate-limited after {} retries: {}",
113                    MAX_RATE_LIMIT_RETRIES,
114                    summarize_rate_limit_body(&body)
115                ));
116            }
117            attempt += 1;
118            let wait = parse_rate_limit_wait(&headers, &body) + RETRY_BUFFER;
119            eprintln!(
120                "Rate limited, waiting {}s (retry {}/{})",
121                wait.as_secs(),
122                attempt,
123                MAX_RATE_LIMIT_RETRIES
124            );
125            std::thread::sleep(wait);
126        }
127    }
128
129    /// Fetch the Discourse site title.
130    pub fn fetch_site_title(&self) -> Result<String> {
131        let site_json_error = match self.get("/site.json") {
132            Ok(response) => {
133                let status = response.status();
134                let text = response.text().context("reading site.json response body")?;
135                if status.is_success() {
136                    let body: SiteResponse =
137                        serde_json::from_str(&text).context("parsing site.json")?;
138                    return Ok(body.site.title);
139                }
140                anyhow!("site.json request failed with {}", status)
141            }
142            Err(err) => err,
143        };
144
145        let response = self.get("/")?;
146        let status = response.status();
147        let html = response.text().context("reading site HTML")?;
148        if !status.is_success() {
149            return Err(anyhow!(
150                "site title lookup failed (site.json error: {}; HTML request failed with {})",
151                site_json_error,
152                status
153            ));
154        }
155        if let Some(title) = extract_html_title(&html) {
156            return Ok(title);
157        }
158        Err(anyhow!(
159            "site title lookup failed (site.json error: {}; HTML missing <title>)",
160            site_json_error
161        ))
162    }
163
164    /// Fetch the current Discourse version and commit hash.
165    pub fn fetch_version_info(&self) -> Result<VersionInfo> {
166        let mut version = None;
167        let mut commit = None;
168        let mut last_err = None;
169
170        match self.get("/about.json") {
171            Ok(response) => {
172                let status = response.status();
173                match response.json::<AboutResponse>() {
174                    Ok(body) => {
175                        if status.is_success() {
176                            version = body.about.version.or(body.about.installed_version);
177                        } else {
178                            last_err = Some(anyhow!("about.json request failed with {}", status));
179                        }
180                    }
181                    Err(err) => {
182                        last_err = Some(anyhow!("reading about.json: {}", err));
183                    }
184                }
185            }
186            Err(err) => {
187                last_err = Some(err);
188            }
189        }
190
191        match self.get("/") {
192            Ok(response) => {
193                let status = response.status();
194                let html = response.text().context("reading site HTML")?;
195                if !status.is_success() {
196                    last_err = Some(anyhow!("site HTML request failed with {}", status));
197                } else if let Some(content) = extract_meta_content(&html, "generator") {
198                    let (html_version, html_commit) = parse_generator_content(&content);
199                    if version.is_none() {
200                        version = html_version;
201                    }
202                    if commit.is_none() {
203                        commit = html_commit;
204                    }
205                }
206            }
207            Err(err) => {
208                last_err = Some(err);
209            }
210        }
211
212        if version.is_none() && commit.is_none() {
213            return Err(last_err.unwrap_or_else(|| anyhow!("version fetch failed")));
214        }
215
216        Ok(VersionInfo { version, commit })
217    }
218
219    /// Fetch the current Discourse version (best-effort).
220    pub fn fetch_version(&self) -> Result<Option<String>> {
221        Ok(self.fetch_version_info()?.version)
222    }
223}
224
225fn extract_html_title(html: &str) -> Option<String> {
226    let haystack = html.as_bytes();
227    let mut lower = Vec::with_capacity(haystack.len());
228    for &byte in haystack {
229        lower.push(byte.to_ascii_lowercase());
230    }
231    let open_tag = b"<title>";
232    let close_tag = b"</title>";
233    let start = find_subslice(&lower, open_tag)? + open_tag.len();
234    let end = find_subslice(&lower[start..], close_tag)? + start;
235    let title = String::from_utf8_lossy(&haystack[start..end])
236        .trim()
237        .to_string();
238    if title.is_empty() { None } else { Some(title) }
239}
240
241fn extract_meta_content(html: &str, name: &str) -> Option<String> {
242    let lower = html.to_ascii_lowercase();
243    let name_attr = format!("name=\"{}\"", name.to_ascii_lowercase());
244    let name_attr_single = format!("name='{}'", name.to_ascii_lowercase());
245
246    let mut start = 0;
247    while let Some(pos) = lower[start..].find("<meta") {
248        let tag_start = start + pos;
249        let rest = &lower[tag_start..];
250        let tag_end = rest.find('>')? + tag_start;
251        let tag_lower = &lower[tag_start..tag_end];
252        if tag_lower.contains(&name_attr) || tag_lower.contains(&name_attr_single) {
253            let tag_original = &html[tag_start..tag_end];
254            if let Some(value) = extract_attr_value(tag_original, "content") {
255                return Some(value);
256            }
257        }
258        start = tag_end + 1;
259    }
260    None
261}
262
263fn extract_attr_value(tag: &str, attr: &str) -> Option<String> {
264    let lower = tag.to_ascii_lowercase();
265    let attr_eq = format!("{}=", attr.to_ascii_lowercase());
266    let pos = lower.find(&attr_eq)? + attr_eq.len();
267    let rest = &tag[pos..];
268    let mut chars = rest.chars();
269    let quote = chars.next()?;
270    if quote != '"' && quote != '\'' {
271        return None;
272    }
273    let value: String = chars.take_while(|c| *c != quote).collect();
274    if value.is_empty() { None } else { Some(value) }
275}
276
277fn parse_generator_content(content: &str) -> (Option<String>, Option<String>) {
278    let mut version = None;
279    let mut commit = None;
280
281    if let Some(rest) = content.strip_prefix("Discourse ") {
282        let ver = rest.split(" - ").next().map(|s| s.trim()).unwrap_or("");
283        if !ver.is_empty() {
284            version = Some(ver.to_string());
285        }
286    }
287
288    if let Some(idx) = content.find("version ") {
289        let tail = &content[idx + "version ".len()..];
290        let hash = tail.split_whitespace().next().unwrap_or("");
291        if !hash.is_empty() {
292            commit = Some(hash.to_string());
293        }
294    }
295
296    (version, commit)
297}
298
299fn find_subslice(haystack: &[u8], needle: &[u8]) -> Option<usize> {
300    if needle.is_empty() || haystack.len() < needle.len() {
301        return None;
302    }
303    haystack
304        .windows(needle.len())
305        .position(|window| window == needle)
306}
dsc/api/client.rs

dsc/api/
client.rs
