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