1use std::collections::HashMap;
6use std::fmt;
7
8use quick_xml::Reader;
9use quick_xml::events::Event;
10
11#[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 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 pub fn is_retriable(&self) -> bool {
85 match self {
86 Error::Http(_) => true,
88 Error::Xml(_) => true,
92 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 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
119pub 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 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
147fn 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("<"),
176 '>' => xml.push_str(">"),
177 '&' => xml.push_str("&"),
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
212pub 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
277fn 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 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 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
432fn 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
450fn 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<b&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 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}