Skip to main content

koji_diff/
xmlrpc.rs

1// SPDX-License-Identifier: Apache-2.0 OR MIT
2
3//! Minimal XML-RPC client using reqwest + quick-xml.
4
5use std::collections::HashMap;
6use std::fmt;
7
8use quick_xml::Reader;
9use quick_xml::events::{BytesText, Event};
10
11/// An XML-RPC value.
12#[derive(Debug, Clone)]
13pub enum Value {
14    Int(i64),
15    String(String),
16    Boolean(bool),
17    Double(f64),
18    Array(Vec<Value>),
19    Struct(HashMap<String, Value>),
20    Nil,
21}
22
23impl Value {
24    pub fn as_int(&self) -> Option<i64> {
25        match self {
26            Value::Int(i) => Some(*i),
27            _ => None,
28        }
29    }
30
31    pub fn as_str(&self) -> Option<&str> {
32        match self {
33            Value::String(s) => Some(s),
34            _ => None,
35        }
36    }
37
38    pub fn as_array(&self) -> Option<&[Value]> {
39        match self {
40            Value::Array(a) => Some(a),
41            _ => None,
42        }
43    }
44
45    pub fn as_struct(&self) -> Option<&HashMap<String, Value>> {
46        match self {
47            Value::Struct(s) => Some(s),
48            _ => None,
49        }
50    }
51
52    /// Look up a field in a struct value.
53    pub fn get(&self, key: &str) -> Option<&Value> {
54        self.as_struct()?.get(key)
55    }
56}
57
58#[derive(Debug)]
59pub enum Error {
60    Http(reqwest::Error),
61    Xml(String),
62    Fault { code: i64, message: String },
63    Parse(String),
64}
65
66impl fmt::Display for Error {
67    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
68        match self {
69            Error::Http(e) => write!(f, "HTTP error: {e}"),
70            Error::Xml(e) => write!(f, "XML error: {e}"),
71            Error::Fault { code, message } => {
72                write!(f, "XML-RPC fault {code}: {message}")
73            }
74            Error::Parse(e) => write!(f, "parse error: {e}"),
75        }
76    }
77}
78
79impl std::error::Error for Error {}
80
81impl Error {
82    /// Return `true` if this error is likely transient and the
83    /// operation should be retried (e.g. HTTP 502/503/504).
84    pub fn is_retriable(&self) -> bool {
85        match self {
86            // Connection or transport failures are often transient.
87            Error::Http(_) => true,
88            // XML parse failures after a successful HTTP request
89            // usually mean we got an HTML error page instead of XML
90            // (e.g. a 502 gateway error page).
91            Error::Xml(_) => true,
92            // Koji CLI errors mentioning server errors.
93            Error::Parse(msg) => {
94                msg.contains("502")
95                    || msg.contains("503")
96                    || msg.contains("504")
97                    || msg.contains("Bad Gateway")
98                    || msg.contains("Service Unavailable")
99                    || msg.contains("Gateway Timeout")
100            }
101            // XML-RPC faults are legitimate API errors.
102            Error::Fault { .. } => false,
103        }
104    }
105}
106
107impl From<reqwest::Error> for Error {
108    fn from(e: reqwest::Error) -> Self {
109        Error::Http(e)
110    }
111}
112
113impl From<quick_xml::Error> for Error {
114    fn from(e: quick_xml::Error) -> Self {
115        Error::Xml(e.to_string())
116    }
117}
118
119/// XML-RPC client that communicates with a hub endpoint.
120pub struct Client {
121    http: reqwest::blocking::Client,
122    hub_url: String,
123}
124
125impl Client {
126    pub fn new(hub_url: &str) -> Self {
127        sandogasa_cli::install_crypto_provider();
128        Self {
129            http: reqwest::blocking::Client::new(),
130            hub_url: hub_url.to_string(),
131        }
132    }
133
134    /// Call an XML-RPC method with the given parameters.
135    pub fn call(&self, method: &str, params: &[Value]) -> Result<Value, Error> {
136        let body = build_request(method, params);
137        let resp = self
138            .http
139            .post(&self.hub_url)
140            .header("Content-Type", "text/xml")
141            .body(body)
142            .send()?
143            .text()?;
144        parse_response(&resp)
145    }
146}
147
148// --- Request building ---
149
150fn build_request(method: &str, params: &[Value]) -> String {
151    let mut xml = format!(
152        "<?xml version=\"1.0\"?>\n\
153         <methodCall>\n\
154         <methodName>{method}</methodName>\n\
155         <params>\n"
156    );
157    for param in params {
158        xml.push_str("<param>");
159        write_value(&mut xml, param);
160        xml.push_str("</param>\n");
161    }
162    xml.push_str("</params>\n</methodCall>");
163    xml
164}
165
166fn write_value(xml: &mut String, value: &Value) {
167    xml.push_str("<value>");
168    match value {
169        Value::Int(i) => {
170            xml.push_str(&format!("<int>{i}</int>"));
171        }
172        Value::String(s) => {
173            xml.push_str("<string>");
174            for ch in s.chars() {
175                match ch {
176                    '<' => xml.push_str("&lt;"),
177                    '>' => xml.push_str("&gt;"),
178                    '&' => xml.push_str("&amp;"),
179                    _ => xml.push(ch),
180                }
181            }
182            xml.push_str("</string>");
183        }
184        Value::Boolean(b) => {
185            xml.push_str(&format!("<boolean>{}</boolean>", if *b { 1 } else { 0 }));
186        }
187        Value::Double(d) => {
188            xml.push_str(&format!("<double>{d}</double>"));
189        }
190        Value::Array(items) => {
191            xml.push_str("<array><data>");
192            for item in items {
193                write_value(xml, item);
194            }
195            xml.push_str("</data></array>");
196        }
197        Value::Struct(map) => {
198            xml.push_str("<struct>");
199            for (key, val) in map {
200                xml.push_str(&format!("<member><name>{key}</name>"));
201                write_value(xml, val);
202                xml.push_str("</member>");
203            }
204            xml.push_str("</struct>");
205        }
206        Value::Nil => {
207            xml.push_str("<nil/>");
208        }
209    }
210    xml.push_str("</value>");
211}
212
213// --- Response parsing ---
214
215pub fn parse_response(xml: &str) -> Result<Value, Error> {
216    let mut reader = Reader::from_str(xml);
217    reader.config_mut().trim_text(true);
218
219    loop {
220        match reader.read_event() {
221            Ok(Event::Start(e)) => match e.name().as_ref() {
222                b"params" => return parse_params(&mut reader),
223                b"fault" => return parse_fault(&mut reader),
224                _ => {}
225            },
226            Ok(Event::Eof) => {
227                return Err(Error::Parse("unexpected EOF before params or fault".into()));
228            }
229            Err(e) => return Err(Error::Xml(e.to_string())),
230            _ => {}
231        }
232    }
233}
234
235fn parse_params(reader: &mut Reader<&[u8]>) -> Result<Value, Error> {
236    loop {
237        match reader.read_event() {
238            Ok(Event::Start(e)) if e.name().as_ref() == b"value" => {
239                return parse_value_content(reader);
240            }
241            Ok(Event::End(e)) if e.name().as_ref() == b"params" => {
242                return Ok(Value::Nil);
243            }
244            Ok(Event::Eof) => {
245                return Err(Error::Parse("unexpected EOF in params".into()));
246            }
247            Err(e) => return Err(e.into()),
248            _ => {}
249        }
250    }
251}
252
253fn parse_fault(reader: &mut Reader<&[u8]>) -> Result<Value, Error> {
254    loop {
255        match reader.read_event() {
256            Ok(Event::Start(e)) if e.name().as_ref() == b"value" => {
257                let value = parse_value_content(reader)?;
258                let code = value
259                    .get("faultCode")
260                    .and_then(|v| v.as_int())
261                    .unwrap_or(-1);
262                let message = value
263                    .get("faultString")
264                    .and_then(|v| v.as_str())
265                    .unwrap_or("unknown fault")
266                    .to_string();
267                return Err(Error::Fault { code, message });
268            }
269            Ok(Event::Eof) => {
270                return Err(Error::Parse("unexpected EOF in fault".into()));
271            }
272            Err(e) => return Err(e.into()),
273            _ => {}
274        }
275    }
276}
277
278/// Parse the content inside a `<value>` tag (opening `<value>` already consumed).
279fn parse_value_content(reader: &mut Reader<&[u8]>) -> Result<Value, Error> {
280    loop {
281        match reader.read_event() {
282            Ok(Event::Start(e)) => {
283                let tag = e.name().as_ref().to_vec();
284                match tag.as_slice() {
285                    b"int" | b"i4" | b"i8" => {
286                        let text = read_text_content(reader)?;
287                        skip_to_end(reader, b"value")?;
288                        return Ok(Value::Int(text.parse::<i64>().map_err(|e| {
289                            Error::Parse(format!("invalid int '{text}': {e}"))
290                        })?));
291                    }
292                    b"string" => {
293                        let text = read_text_content(reader)?;
294                        skip_to_end(reader, b"value")?;
295                        return Ok(Value::String(text));
296                    }
297                    b"boolean" => {
298                        let text = read_text_content(reader)?;
299                        skip_to_end(reader, b"value")?;
300                        return Ok(Value::Boolean(text == "1" || text == "true"));
301                    }
302                    b"double" => {
303                        let text = read_text_content(reader)?;
304                        skip_to_end(reader, b"value")?;
305                        return Ok(Value::Double(text.parse::<f64>().map_err(|e| {
306                            Error::Parse(format!("invalid double '{text}': {e}"))
307                        })?));
308                    }
309                    b"struct" => {
310                        let s = parse_struct_content(reader)?;
311                        skip_to_end(reader, b"value")?;
312                        return Ok(s);
313                    }
314                    b"array" => {
315                        let a = parse_array_content(reader)?;
316                        skip_to_end(reader, b"value")?;
317                        return Ok(a);
318                    }
319                    _ => {
320                        // Unknown type tag — treat content as string.
321                        let text = read_text_content(reader)?;
322                        skip_to_end(reader, b"value")?;
323                        return Ok(Value::String(text));
324                    }
325                }
326            }
327            Ok(Event::Empty(e)) if e.name().as_ref() == b"nil" => {
328                skip_to_end(reader, b"value")?;
329                return Ok(Value::Nil);
330            }
331            Ok(Event::Text(t)) => {
332                let text = decode_text(&t)?;
333                if !text.trim().is_empty() {
334                    // Bare text in <value> is implicitly a string.
335                    skip_to_end(reader, b"value")?;
336                    return Ok(Value::String(text));
337                }
338            }
339            Ok(Event::End(e)) if e.name().as_ref() == b"value" => {
340                return Ok(Value::String(String::new()));
341            }
342            Ok(Event::Eof) => {
343                return Err(Error::Parse("unexpected EOF in value".into()));
344            }
345            Err(e) => return Err(e.into()),
346            _ => {}
347        }
348    }
349}
350
351fn parse_struct_content(reader: &mut Reader<&[u8]>) -> Result<Value, Error> {
352    let mut map = HashMap::new();
353    loop {
354        match reader.read_event() {
355            Ok(Event::Start(e)) if e.name().as_ref() == b"member" => {
356                let (name, value) = parse_member(reader)?;
357                map.insert(name, value);
358            }
359            Ok(Event::End(e)) if e.name().as_ref() == b"struct" => {
360                return Ok(Value::Struct(map));
361            }
362            Ok(Event::Eof) => {
363                return Err(Error::Parse("unexpected EOF in struct".into()));
364            }
365            Err(e) => return Err(e.into()),
366            _ => {}
367        }
368    }
369}
370
371fn parse_member(reader: &mut Reader<&[u8]>) -> Result<(String, Value), Error> {
372    let mut name = String::new();
373    let mut value = Value::Nil;
374    loop {
375        match reader.read_event() {
376            Ok(Event::Start(e)) => match e.name().as_ref() {
377                b"name" => {
378                    name = read_text_content(reader)?;
379                }
380                b"value" => {
381                    value = parse_value_content(reader)?;
382                }
383                _ => {}
384            },
385            Ok(Event::End(e)) if e.name().as_ref() == b"member" => {
386                return Ok((name, value));
387            }
388            Ok(Event::Eof) => {
389                return Err(Error::Parse("unexpected EOF in member".into()));
390            }
391            Err(e) => return Err(e.into()),
392            _ => {}
393        }
394    }
395}
396
397fn parse_array_content(reader: &mut Reader<&[u8]>) -> Result<Value, Error> {
398    let mut items = Vec::new();
399    loop {
400        match reader.read_event() {
401            Ok(Event::Start(e)) => {
402                if e.name().as_ref() == b"data" {
403                    loop {
404                        match reader.read_event() {
405                            Ok(Event::Start(e2)) if e2.name().as_ref() == b"value" => {
406                                items.push(parse_value_content(reader)?);
407                            }
408                            Ok(Event::End(e2)) if e2.name().as_ref() == b"data" => break,
409                            Ok(Event::Eof) => {
410                                return Err(Error::Parse("unexpected EOF in array data".into()));
411                            }
412                            Err(e) => return Err(e.into()),
413                            _ => {}
414                        }
415                    }
416                }
417            }
418            Ok(Event::End(e)) if e.name().as_ref() == b"array" => {
419                return Ok(Value::Array(items));
420            }
421            Ok(Event::Eof) => {
422                return Err(Error::Parse("unexpected EOF in array".into()));
423            }
424            Err(e) => return Err(e.into()),
425            _ => {}
426        }
427    }
428}
429
430/// Read text content until the matching end tag.
431/// Decode and unescape a quick-xml text node to an owned String.
432///
433/// quick-xml 0.40 dropped `BytesText::unescape`; decoding and
434/// entity-unescaping are now separate explicit steps.
435fn decode_text(t: &BytesText) -> Result<String, Error> {
436    let decoded = t.decode().map_err(|e| Error::Xml(e.to_string()))?;
437    Ok(quick_xml::escape::unescape(&decoded)
438        .map_err(|e| Error::Xml(e.to_string()))?
439        .into_owned())
440}
441
442fn read_text_content(reader: &mut Reader<&[u8]>) -> Result<String, Error> {
443    let mut text = String::new();
444    loop {
445        match reader.read_event() {
446            Ok(Event::Text(t)) => {
447                text.push_str(&decode_text(&t)?);
448            }
449            Ok(Event::End(_)) => return Ok(text),
450            Ok(Event::Eof) => {
451                return Err(Error::Parse("unexpected EOF reading text".into()));
452            }
453            Err(e) => return Err(e.into()),
454            _ => {}
455        }
456    }
457}
458
459/// Skip events until we find an end tag matching the given name at depth 0.
460fn skip_to_end(reader: &mut Reader<&[u8]>, end_tag: &[u8]) -> Result<(), Error> {
461    let mut depth: u32 = 0;
462    loop {
463        match reader.read_event() {
464            Ok(Event::Start(_)) => depth += 1,
465            Ok(Event::End(e)) => {
466                if depth == 0 && e.name().as_ref() == end_tag {
467                    return Ok(());
468                }
469                depth = depth.saturating_sub(1);
470            }
471            Ok(Event::Eof) => return Ok(()),
472            Err(e) => return Err(e.into()),
473            _ => {}
474        }
475    }
476}
477
478#[cfg(test)]
479mod tests {
480    use super::*;
481
482    #[test]
483    fn test_build_request_int() {
484        let xml = build_request("getBuild", &[Value::Int(42)]);
485        assert!(xml.contains("<methodName>getBuild</methodName>"));
486        assert!(xml.contains("<int>42</int>"));
487    }
488
489    #[test]
490    fn test_build_request_string_escaping() {
491        let xml = build_request("test", &[Value::String("a<b&c".into())]);
492        assert!(xml.contains("a&lt;b&amp;c"));
493    }
494
495    #[test]
496    fn test_parse_int_response() {
497        let xml = r#"<?xml version="1.0"?>
498            <methodResponse><params><param>
499            <value><int>42</int></value>
500            </param></params></methodResponse>"#;
501        let v = parse_response(xml).unwrap();
502        assert_eq!(v.as_int(), Some(42));
503    }
504
505    #[test]
506    fn test_parse_string_response() {
507        let xml = r#"<?xml version="1.0"?>
508            <methodResponse><params><param>
509            <value><string>hello world</string></value>
510            </param></params></methodResponse>"#;
511        let v = parse_response(xml).unwrap();
512        assert_eq!(v.as_str(), Some("hello world"));
513    }
514
515    #[test]
516    fn test_parse_struct_response() {
517        let xml = r#"<?xml version="1.0"?>
518            <methodResponse><params><param>
519            <value><struct>
520                <member><name>task_id</name><value><int>12345</int></value></member>
521                <member><name>nvr</name><value><string>foo-1.0-1.fc42</string></value></member>
522            </struct></value>
523            </param></params></methodResponse>"#;
524        let v = parse_response(xml).unwrap();
525        assert_eq!(v.get("task_id").unwrap().as_int(), Some(12345));
526        assert_eq!(v.get("nvr").unwrap().as_str(), Some("foo-1.0-1.fc42"));
527    }
528
529    #[test]
530    fn test_parse_array_response() {
531        let xml = r#"<?xml version="1.0"?>
532            <methodResponse><params><param>
533            <value><array><data>
534                <value><int>1</int></value>
535                <value><int>2</int></value>
536                <value><int>3</int></value>
537            </data></array></value>
538            </param></params></methodResponse>"#;
539        let v = parse_response(xml).unwrap();
540        let arr = v.as_array().unwrap();
541        assert_eq!(arr.len(), 3);
542        assert_eq!(arr[0].as_int(), Some(1));
543        assert_eq!(arr[2].as_int(), Some(3));
544    }
545
546    #[test]
547    fn test_parse_nested_struct_array() {
548        let xml = r#"<?xml version="1.0"?>
549            <methodResponse><params><param>
550            <value><array><data>
551                <value><struct>
552                    <member><name>id</name><value><int>100</int></value></member>
553                    <member><name>method</name><value><string>buildArch</string></value></member>
554                    <member><name>arch</name><value><string>x86_64</string></value></member>
555                </struct></value>
556                <value><struct>
557                    <member><name>id</name><value><int>101</int></value></member>
558                    <member><name>method</name><value><string>buildArch</string></value></member>
559                    <member><name>arch</name><value><string>aarch64</string></value></member>
560                </struct></value>
561            </data></array></value>
562            </param></params></methodResponse>"#;
563        let v = parse_response(xml).unwrap();
564        let arr = v.as_array().unwrap();
565        assert_eq!(arr.len(), 2);
566        assert_eq!(arr[0].get("id").unwrap().as_int(), Some(100));
567        assert_eq!(arr[0].get("arch").unwrap().as_str(), Some("x86_64"));
568        assert_eq!(arr[1].get("id").unwrap().as_int(), Some(101));
569    }
570
571    #[test]
572    fn test_parse_boolean_response() {
573        let xml = r#"<?xml version="1.0"?>
574            <methodResponse><params><param>
575            <value><boolean>1</boolean></value>
576            </param></params></methodResponse>"#;
577        let v = parse_response(xml).unwrap();
578        assert_eq!(v.as_int(), None);
579        match v {
580            Value::Boolean(b) => assert!(b),
581            _ => panic!("expected boolean"),
582        }
583    }
584
585    #[test]
586    fn test_parse_nil_response() {
587        let xml = r#"<?xml version="1.0"?>
588            <methodResponse><params><param>
589            <value><nil/></value>
590            </param></params></methodResponse>"#;
591        let v = parse_response(xml).unwrap();
592        assert!(matches!(v, Value::Nil));
593    }
594
595    #[test]
596    fn test_parse_fault_response() {
597        let xml = r#"<?xml version="1.0"?>
598            <methodResponse><fault><value><struct>
599                <member><name>faultCode</name><value><int>1000</int></value></member>
600                <member><name>faultString</name><value><string>No such build</string></value></member>
601            </struct></value></fault></methodResponse>"#;
602        let err = parse_response(xml).unwrap_err();
603        match err {
604            Error::Fault { code, message } => {
605                assert_eq!(code, 1000);
606                assert_eq!(message, "No such build");
607            }
608            _ => panic!("expected Fault error, got: {err}"),
609        }
610    }
611
612    #[test]
613    fn test_parse_bare_text_as_string() {
614        let xml = r#"<?xml version="1.0"?>
615            <methodResponse><params><param>
616            <value>bare text</value>
617            </param></params></methodResponse>"#;
618        let v = parse_response(xml).unwrap();
619        assert_eq!(v.as_str(), Some("bare text"));
620    }
621
622    #[test]
623    fn test_is_retriable_http_error() {
624        // reqwest errors are retriable (connection failures, etc.)
625        let err = Error::Xml("unexpected token".into());
626        assert!(err.is_retriable());
627    }
628
629    #[test]
630    fn test_is_retriable_parse_502() {
631        let err = Error::Parse("koji download-logs failed: 502 Bad Gateway".into());
632        assert!(err.is_retriable());
633    }
634
635    #[test]
636    fn test_is_retriable_parse_503() {
637        let err = Error::Parse("503 Service Unavailable".into());
638        assert!(err.is_retriable());
639    }
640
641    #[test]
642    fn test_is_not_retriable_fault() {
643        let err = Error::Fault {
644            code: 1000,
645            message: "No such build".into(),
646        };
647        assert!(!err.is_retriable());
648    }
649
650    #[test]
651    fn test_is_not_retriable_parse_not_found() {
652        let err = Error::Parse("root.log not found for task 123".into());
653        assert!(!err.is_retriable());
654    }
655}