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