Skip to main content

koji_diff/
xmlrpc.rs

1// SPDX-License-Identifier: MPL-2.0
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::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        Self {
128            http: reqwest::blocking::Client::new(),
129            hub_url: hub_url.to_string(),
130        }
131    }
132
133    /// Call an XML-RPC method with the given parameters.
134    pub fn call(&self, method: &str, params: &[Value]) -> Result<Value, Error> {
135        let body = build_request(method, params);
136        let resp = self
137            .http
138            .post(&self.hub_url)
139            .header("Content-Type", "text/xml")
140            .body(body)
141            .send()?
142            .text()?;
143        parse_response(&resp)
144    }
145}
146
147// --- Request building ---
148
149fn build_request(method: &str, params: &[Value]) -> String {
150    let mut xml = format!(
151        "<?xml version=\"1.0\"?>\n\
152         <methodCall>\n\
153         <methodName>{method}</methodName>\n\
154         <params>\n"
155    );
156    for param in params {
157        xml.push_str("<param>");
158        write_value(&mut xml, param);
159        xml.push_str("</param>\n");
160    }
161    xml.push_str("</params>\n</methodCall>");
162    xml
163}
164
165fn write_value(xml: &mut String, value: &Value) {
166    xml.push_str("<value>");
167    match value {
168        Value::Int(i) => {
169            xml.push_str(&format!("<int>{i}</int>"));
170        }
171        Value::String(s) => {
172            xml.push_str("<string>");
173            for ch in s.chars() {
174                match ch {
175                    '<' => xml.push_str("&lt;"),
176                    '>' => xml.push_str("&gt;"),
177                    '&' => xml.push_str("&amp;"),
178                    _ => xml.push(ch),
179                }
180            }
181            xml.push_str("</string>");
182        }
183        Value::Boolean(b) => {
184            xml.push_str(&format!("<boolean>{}</boolean>", if *b { 1 } else { 0 }));
185        }
186        Value::Double(d) => {
187            xml.push_str(&format!("<double>{d}</double>"));
188        }
189        Value::Array(items) => {
190            xml.push_str("<array><data>");
191            for item in items {
192                write_value(xml, item);
193            }
194            xml.push_str("</data></array>");
195        }
196        Value::Struct(map) => {
197            xml.push_str("<struct>");
198            for (key, val) in map {
199                xml.push_str(&format!("<member><name>{key}</name>"));
200                write_value(xml, val);
201                xml.push_str("</member>");
202            }
203            xml.push_str("</struct>");
204        }
205        Value::Nil => {
206            xml.push_str("<nil/>");
207        }
208    }
209    xml.push_str("</value>");
210}
211
212// --- Response parsing ---
213
214pub fn parse_response(xml: &str) -> Result<Value, Error> {
215    let mut reader = Reader::from_str(xml);
216    reader.config_mut().trim_text(true);
217
218    loop {
219        match reader.read_event() {
220            Ok(Event::Start(e)) => match e.name().as_ref() {
221                b"params" => return parse_params(&mut reader),
222                b"fault" => return parse_fault(&mut reader),
223                _ => {}
224            },
225            Ok(Event::Eof) => {
226                return Err(Error::Parse("unexpected EOF before params or fault".into()));
227            }
228            Err(e) => return Err(Error::Xml(e.to_string())),
229            _ => {}
230        }
231    }
232}
233
234fn parse_params(reader: &mut Reader<&[u8]>) -> Result<Value, Error> {
235    loop {
236        match reader.read_event() {
237            Ok(Event::Start(e)) if e.name().as_ref() == b"value" => {
238                return parse_value_content(reader);
239            }
240            Ok(Event::End(e)) if e.name().as_ref() == b"params" => {
241                return Ok(Value::Nil);
242            }
243            Ok(Event::Eof) => {
244                return Err(Error::Parse("unexpected EOF in params".into()));
245            }
246            Err(e) => return Err(e.into()),
247            _ => {}
248        }
249    }
250}
251
252fn parse_fault(reader: &mut Reader<&[u8]>) -> Result<Value, Error> {
253    loop {
254        match reader.read_event() {
255            Ok(Event::Start(e)) if e.name().as_ref() == b"value" => {
256                let value = parse_value_content(reader)?;
257                let code = value
258                    .get("faultCode")
259                    .and_then(|v| v.as_int())
260                    .unwrap_or(-1);
261                let message = value
262                    .get("faultString")
263                    .and_then(|v| v.as_str())
264                    .unwrap_or("unknown fault")
265                    .to_string();
266                return Err(Error::Fault { code, message });
267            }
268            Ok(Event::Eof) => {
269                return Err(Error::Parse("unexpected EOF in fault".into()));
270            }
271            Err(e) => return Err(e.into()),
272            _ => {}
273        }
274    }
275}
276
277/// Parse the content inside a `<value>` tag (opening `<value>` already consumed).
278fn parse_value_content(reader: &mut Reader<&[u8]>) -> Result<Value, Error> {
279    loop {
280        match reader.read_event() {
281            Ok(Event::Start(e)) => {
282                let tag = e.name().as_ref().to_vec();
283                match tag.as_slice() {
284                    b"int" | b"i4" | b"i8" => {
285                        let text = read_text_content(reader)?;
286                        skip_to_end(reader, b"value")?;
287                        return Ok(Value::Int(text.parse::<i64>().map_err(|e| {
288                            Error::Parse(format!("invalid int '{text}': {e}"))
289                        })?));
290                    }
291                    b"string" => {
292                        let text = read_text_content(reader)?;
293                        skip_to_end(reader, b"value")?;
294                        return Ok(Value::String(text));
295                    }
296                    b"boolean" => {
297                        let text = read_text_content(reader)?;
298                        skip_to_end(reader, b"value")?;
299                        return Ok(Value::Boolean(text == "1" || text == "true"));
300                    }
301                    b"double" => {
302                        let text = read_text_content(reader)?;
303                        skip_to_end(reader, b"value")?;
304                        return Ok(Value::Double(text.parse::<f64>().map_err(|e| {
305                            Error::Parse(format!("invalid double '{text}': {e}"))
306                        })?));
307                    }
308                    b"struct" => {
309                        let s = parse_struct_content(reader)?;
310                        skip_to_end(reader, b"value")?;
311                        return Ok(s);
312                    }
313                    b"array" => {
314                        let a = parse_array_content(reader)?;
315                        skip_to_end(reader, b"value")?;
316                        return Ok(a);
317                    }
318                    _ => {
319                        // Unknown type tag — treat content as string.
320                        let text = read_text_content(reader)?;
321                        skip_to_end(reader, b"value")?;
322                        return Ok(Value::String(text));
323                    }
324                }
325            }
326            Ok(Event::Empty(e)) if e.name().as_ref() == b"nil" => {
327                skip_to_end(reader, b"value")?;
328                return Ok(Value::Nil);
329            }
330            Ok(Event::Text(t)) => {
331                let text = t
332                    .unescape()
333                    .map_err(|e| Error::Xml(e.to_string()))?
334                    .into_owned();
335                if !text.trim().is_empty() {
336                    // Bare text in <value> is implicitly a string.
337                    skip_to_end(reader, b"value")?;
338                    return Ok(Value::String(text));
339                }
340            }
341            Ok(Event::End(e)) if e.name().as_ref() == b"value" => {
342                return Ok(Value::String(String::new()));
343            }
344            Ok(Event::Eof) => {
345                return Err(Error::Parse("unexpected EOF in value".into()));
346            }
347            Err(e) => return Err(e.into()),
348            _ => {}
349        }
350    }
351}
352
353fn parse_struct_content(reader: &mut Reader<&[u8]>) -> Result<Value, Error> {
354    let mut map = HashMap::new();
355    loop {
356        match reader.read_event() {
357            Ok(Event::Start(e)) if e.name().as_ref() == b"member" => {
358                let (name, value) = parse_member(reader)?;
359                map.insert(name, value);
360            }
361            Ok(Event::End(e)) if e.name().as_ref() == b"struct" => {
362                return Ok(Value::Struct(map));
363            }
364            Ok(Event::Eof) => {
365                return Err(Error::Parse("unexpected EOF in struct".into()));
366            }
367            Err(e) => return Err(e.into()),
368            _ => {}
369        }
370    }
371}
372
373fn parse_member(reader: &mut Reader<&[u8]>) -> Result<(String, Value), Error> {
374    let mut name = String::new();
375    let mut value = Value::Nil;
376    loop {
377        match reader.read_event() {
378            Ok(Event::Start(e)) => match e.name().as_ref() {
379                b"name" => {
380                    name = read_text_content(reader)?;
381                }
382                b"value" => {
383                    value = parse_value_content(reader)?;
384                }
385                _ => {}
386            },
387            Ok(Event::End(e)) if e.name().as_ref() == b"member" => {
388                return Ok((name, value));
389            }
390            Ok(Event::Eof) => {
391                return Err(Error::Parse("unexpected EOF in member".into()));
392            }
393            Err(e) => return Err(e.into()),
394            _ => {}
395        }
396    }
397}
398
399fn parse_array_content(reader: &mut Reader<&[u8]>) -> Result<Value, Error> {
400    let mut items = Vec::new();
401    loop {
402        match reader.read_event() {
403            Ok(Event::Start(e)) => {
404                if e.name().as_ref() == b"data" {
405                    loop {
406                        match reader.read_event() {
407                            Ok(Event::Start(e2)) if e2.name().as_ref() == b"value" => {
408                                items.push(parse_value_content(reader)?);
409                            }
410                            Ok(Event::End(e2)) if e2.name().as_ref() == b"data" => break,
411                            Ok(Event::Eof) => {
412                                return Err(Error::Parse("unexpected EOF in array data".into()));
413                            }
414                            Err(e) => return Err(e.into()),
415                            _ => {}
416                        }
417                    }
418                }
419            }
420            Ok(Event::End(e)) if e.name().as_ref() == b"array" => {
421                return Ok(Value::Array(items));
422            }
423            Ok(Event::Eof) => {
424                return Err(Error::Parse("unexpected EOF in array".into()));
425            }
426            Err(e) => return Err(e.into()),
427            _ => {}
428        }
429    }
430}
431
432/// Read text content until the matching end tag.
433fn read_text_content(reader: &mut Reader<&[u8]>) -> Result<String, Error> {
434    let mut text = String::new();
435    loop {
436        match reader.read_event() {
437            Ok(Event::Text(t)) => {
438                text.push_str(&t.unescape().map_err(|e| Error::Xml(e.to_string()))?);
439            }
440            Ok(Event::End(_)) => return Ok(text),
441            Ok(Event::Eof) => {
442                return Err(Error::Parse("unexpected EOF reading text".into()));
443            }
444            Err(e) => return Err(e.into()),
445            _ => {}
446        }
447    }
448}
449
450/// Skip events until we find an end tag matching the given name at depth 0.
451fn skip_to_end(reader: &mut Reader<&[u8]>, end_tag: &[u8]) -> Result<(), Error> {
452    let mut depth: u32 = 0;
453    loop {
454        match reader.read_event() {
455            Ok(Event::Start(_)) => depth += 1,
456            Ok(Event::End(e)) => {
457                if depth == 0 && e.name().as_ref() == end_tag {
458                    return Ok(());
459                }
460                depth = depth.saturating_sub(1);
461            }
462            Ok(Event::Eof) => return Ok(()),
463            Err(e) => return Err(e.into()),
464            _ => {}
465        }
466    }
467}
468
469#[cfg(test)]
470mod tests {
471    use super::*;
472
473    #[test]
474    fn test_build_request_int() {
475        let xml = build_request("getBuild", &[Value::Int(42)]);
476        assert!(xml.contains("<methodName>getBuild</methodName>"));
477        assert!(xml.contains("<int>42</int>"));
478    }
479
480    #[test]
481    fn test_build_request_string_escaping() {
482        let xml = build_request("test", &[Value::String("a<b&c".into())]);
483        assert!(xml.contains("a&lt;b&amp;c"));
484    }
485
486    #[test]
487    fn test_parse_int_response() {
488        let xml = r#"<?xml version="1.0"?>
489            <methodResponse><params><param>
490            <value><int>42</int></value>
491            </param></params></methodResponse>"#;
492        let v = parse_response(xml).unwrap();
493        assert_eq!(v.as_int(), Some(42));
494    }
495
496    #[test]
497    fn test_parse_string_response() {
498        let xml = r#"<?xml version="1.0"?>
499            <methodResponse><params><param>
500            <value><string>hello world</string></value>
501            </param></params></methodResponse>"#;
502        let v = parse_response(xml).unwrap();
503        assert_eq!(v.as_str(), Some("hello world"));
504    }
505
506    #[test]
507    fn test_parse_struct_response() {
508        let xml = r#"<?xml version="1.0"?>
509            <methodResponse><params><param>
510            <value><struct>
511                <member><name>task_id</name><value><int>12345</int></value></member>
512                <member><name>nvr</name><value><string>foo-1.0-1.fc42</string></value></member>
513            </struct></value>
514            </param></params></methodResponse>"#;
515        let v = parse_response(xml).unwrap();
516        assert_eq!(v.get("task_id").unwrap().as_int(), Some(12345));
517        assert_eq!(v.get("nvr").unwrap().as_str(), Some("foo-1.0-1.fc42"));
518    }
519
520    #[test]
521    fn test_parse_array_response() {
522        let xml = r#"<?xml version="1.0"?>
523            <methodResponse><params><param>
524            <value><array><data>
525                <value><int>1</int></value>
526                <value><int>2</int></value>
527                <value><int>3</int></value>
528            </data></array></value>
529            </param></params></methodResponse>"#;
530        let v = parse_response(xml).unwrap();
531        let arr = v.as_array().unwrap();
532        assert_eq!(arr.len(), 3);
533        assert_eq!(arr[0].as_int(), Some(1));
534        assert_eq!(arr[2].as_int(), Some(3));
535    }
536
537    #[test]
538    fn test_parse_nested_struct_array() {
539        let xml = r#"<?xml version="1.0"?>
540            <methodResponse><params><param>
541            <value><array><data>
542                <value><struct>
543                    <member><name>id</name><value><int>100</int></value></member>
544                    <member><name>method</name><value><string>buildArch</string></value></member>
545                    <member><name>arch</name><value><string>x86_64</string></value></member>
546                </struct></value>
547                <value><struct>
548                    <member><name>id</name><value><int>101</int></value></member>
549                    <member><name>method</name><value><string>buildArch</string></value></member>
550                    <member><name>arch</name><value><string>aarch64</string></value></member>
551                </struct></value>
552            </data></array></value>
553            </param></params></methodResponse>"#;
554        let v = parse_response(xml).unwrap();
555        let arr = v.as_array().unwrap();
556        assert_eq!(arr.len(), 2);
557        assert_eq!(arr[0].get("id").unwrap().as_int(), Some(100));
558        assert_eq!(arr[0].get("arch").unwrap().as_str(), Some("x86_64"));
559        assert_eq!(arr[1].get("id").unwrap().as_int(), Some(101));
560    }
561
562    #[test]
563    fn test_parse_boolean_response() {
564        let xml = r#"<?xml version="1.0"?>
565            <methodResponse><params><param>
566            <value><boolean>1</boolean></value>
567            </param></params></methodResponse>"#;
568        let v = parse_response(xml).unwrap();
569        assert_eq!(v.as_int(), None);
570        match v {
571            Value::Boolean(b) => assert!(b),
572            _ => panic!("expected boolean"),
573        }
574    }
575
576    #[test]
577    fn test_parse_nil_response() {
578        let xml = r#"<?xml version="1.0"?>
579            <methodResponse><params><param>
580            <value><nil/></value>
581            </param></params></methodResponse>"#;
582        let v = parse_response(xml).unwrap();
583        assert!(matches!(v, Value::Nil));
584    }
585
586    #[test]
587    fn test_parse_fault_response() {
588        let xml = r#"<?xml version="1.0"?>
589            <methodResponse><fault><value><struct>
590                <member><name>faultCode</name><value><int>1000</int></value></member>
591                <member><name>faultString</name><value><string>No such build</string></value></member>
592            </struct></value></fault></methodResponse>"#;
593        let err = parse_response(xml).unwrap_err();
594        match err {
595            Error::Fault { code, message } => {
596                assert_eq!(code, 1000);
597                assert_eq!(message, "No such build");
598            }
599            _ => panic!("expected Fault error, got: {err}"),
600        }
601    }
602
603    #[test]
604    fn test_parse_bare_text_as_string() {
605        let xml = r#"<?xml version="1.0"?>
606            <methodResponse><params><param>
607            <value>bare text</value>
608            </param></params></methodResponse>"#;
609        let v = parse_response(xml).unwrap();
610        assert_eq!(v.as_str(), Some("bare text"));
611    }
612
613    #[test]
614    fn test_is_retriable_http_error() {
615        // reqwest errors are retriable (connection failures, etc.)
616        let err = Error::Xml("unexpected token".into());
617        assert!(err.is_retriable());
618    }
619
620    #[test]
621    fn test_is_retriable_parse_502() {
622        let err = Error::Parse("koji download-logs failed: 502 Bad Gateway".into());
623        assert!(err.is_retriable());
624    }
625
626    #[test]
627    fn test_is_retriable_parse_503() {
628        let err = Error::Parse("503 Service Unavailable".into());
629        assert!(err.is_retriable());
630    }
631
632    #[test]
633    fn test_is_not_retriable_fault() {
634        let err = Error::Fault {
635            code: 1000,
636            message: "No such build".into(),
637        };
638        assert!(!err.is_retriable());
639    }
640
641    #[test]
642    fn test_is_not_retriable_parse_not_found() {
643        let err = Error::Parse("root.log not found for task 123".into());
644        assert!(!err.is_retriable());
645    }
646}