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