1use std::collections::HashMap;
6use std::fmt;
7
8use quick_xml::Reader;
9use quick_xml::events::{BytesText, 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 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 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
151fn 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("<"),
180 '>' => xml.push_str(">"),
181 '&' => xml.push_str("&"),
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
216pub 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
281fn 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 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 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
433fn 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
462fn 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<b&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 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}