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) => {
70 write!(f, "HTTP error: {e}")?;
74 let mut source = std::error::Error::source(e);
75 while let Some(cause) = source {
76 write!(f, ": {cause}")?;
77 source = cause.source();
78 }
79 Ok(())
80 }
81 Error::Xml(e) => write!(f, "XML error: {e}"),
82 Error::Fault { code, message } => {
83 write!(f, "XML-RPC fault {code}: {message}")
84 }
85 Error::Parse(e) => write!(f, "parse error: {e}"),
86 }
87 }
88}
89
90impl std::error::Error for Error {}
91
92impl Error {
93 pub fn is_retriable(&self) -> bool {
96 match self {
97 Error::Http(_) => true,
99 Error::Xml(_) => true,
103 Error::Parse(msg) => {
105 msg.contains("502")
106 || msg.contains("503")
107 || msg.contains("504")
108 || msg.contains("Bad Gateway")
109 || msg.contains("Service Unavailable")
110 || msg.contains("Gateway Timeout")
111 }
112 Error::Fault { .. } => false,
114 }
115 }
116}
117
118impl From<reqwest::Error> for Error {
119 fn from(e: reqwest::Error) -> Self {
120 Error::Http(e)
121 }
122}
123
124impl From<quick_xml::Error> for Error {
125 fn from(e: quick_xml::Error) -> Self {
126 Error::Xml(e.to_string())
127 }
128}
129
130pub const DEFAULT_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(600);
146
147pub const TIMEOUT_ENV: &str = "SANDOGASA_KOJI_TIMEOUT";
157
158pub fn configured_timeout() -> Option<std::time::Duration> {
161 match std::env::var(TIMEOUT_ENV)
162 .ok()
163 .and_then(|v| v.trim().parse::<u64>().ok())
164 {
165 Some(0) => None,
166 Some(secs) => Some(std::time::Duration::from_secs(secs)),
167 None => Some(DEFAULT_TIMEOUT),
168 }
169}
170
171pub struct Client {
173 http: reqwest::blocking::Client,
174 hub_url: String,
175}
176
177impl Client {
178 pub fn new(hub_url: &str) -> Self {
180 Self::with_timeout(hub_url, configured_timeout())
181 }
182
183 pub fn with_timeout(hub_url: &str, timeout: Option<std::time::Duration>) -> Self {
188 sandogasa_cli::install_crypto_provider();
189 let builder = reqwest::blocking::Client::builder()
190 .user_agent(concat!("sandogasa-kojihub/", env!("CARGO_PKG_VERSION")))
196 .http1_only()
199 .pool_max_idle_per_host(0);
206 let builder = match timeout {
216 Some(bound) => builder.timeout(bound),
217 None => builder,
218 };
219 Self {
220 http: builder.build().expect("build reqwest client"),
221 hub_url: hub_url.trim_end_matches('/').to_string(),
225 }
226 }
227
228 pub fn hub_url(&self) -> &str {
232 &self.hub_url
233 }
234
235 pub fn call(&self, method: &str, params: &[Value]) -> Result<Value, Error> {
236 let body = build_request(method, params);
237 let resp = self
238 .http
239 .post(&self.hub_url)
240 .header("Content-Type", "text/xml")
241 .body(body)
242 .send()?
243 .error_for_status()?
247 .text()?;
248 parse_response(&resp)
249 }
250}
251
252fn build_request(method: &str, params: &[Value]) -> String {
255 let mut xml = format!(
256 "<?xml version=\"1.0\"?>\n\
257 <methodCall>\n\
258 <methodName>{method}</methodName>\n\
259 <params>\n"
260 );
261 for param in params {
262 xml.push_str("<param>");
263 write_value(&mut xml, param);
264 xml.push_str("</param>\n");
265 }
266 xml.push_str("</params>\n</methodCall>");
267 xml
268}
269
270fn write_value(xml: &mut String, value: &Value) {
271 xml.push_str("<value>");
272 match value {
273 Value::Int(i) => {
274 xml.push_str(&format!("<int>{i}</int>"));
275 }
276 Value::String(s) => {
277 xml.push_str("<string>");
278 xml.push_str(&quick_xml::escape::escape(s));
279 xml.push_str("</string>");
280 }
281 Value::Boolean(b) => {
282 xml.push_str(&format!("<boolean>{}</boolean>", if *b { 1 } else { 0 }));
283 }
284 Value::Double(d) => {
285 xml.push_str(&format!("<double>{d}</double>"));
286 }
287 Value::Array(items) => {
288 xml.push_str("<array><data>");
289 for item in items {
290 write_value(xml, item);
291 }
292 xml.push_str("</data></array>");
293 }
294 Value::Struct(map) => {
295 xml.push_str("<struct>");
296 for (key, val) in map {
297 xml.push_str(&format!("<member><name>{key}</name>"));
298 write_value(xml, val);
299 xml.push_str("</member>");
300 }
301 xml.push_str("</struct>");
302 }
303 Value::Nil => {
304 xml.push_str("<nil/>");
305 }
306 }
307 xml.push_str("</value>");
308}
309
310pub fn parse_response(xml: &str) -> Result<Value, Error> {
313 let mut reader = Reader::from_str(xml);
314 reader.config_mut().trim_text(true);
315
316 loop {
317 match reader.read_event() {
318 Ok(Event::Start(e)) => match e.name().as_ref() {
319 b"params" => return parse_params(&mut reader),
320 b"fault" => return parse_fault(&mut reader),
321 _ => {}
322 },
323 Ok(Event::Eof) => {
324 return Err(Error::Parse("unexpected EOF before params or fault".into()));
325 }
326 Err(e) => return Err(Error::Xml(e.to_string())),
327 _ => {}
328 }
329 }
330}
331
332fn parse_params(reader: &mut Reader<&[u8]>) -> Result<Value, Error> {
333 loop {
334 match reader.read_event() {
335 Ok(Event::Start(e)) if e.name().as_ref() == b"value" => {
336 return parse_value_content(reader);
337 }
338 Ok(Event::End(e)) if e.name().as_ref() == b"params" => {
339 return Ok(Value::Nil);
340 }
341 Ok(Event::Eof) => {
342 return Err(Error::Parse("unexpected EOF in params".into()));
343 }
344 Err(e) => return Err(e.into()),
345 _ => {}
346 }
347 }
348}
349
350fn parse_fault(reader: &mut Reader<&[u8]>) -> Result<Value, Error> {
351 loop {
352 match reader.read_event() {
353 Ok(Event::Start(e)) if e.name().as_ref() == b"value" => {
354 let value = parse_value_content(reader)?;
355 let code = value
356 .get("faultCode")
357 .and_then(|v| v.as_int())
358 .unwrap_or(-1);
359 let message = value
360 .get("faultString")
361 .and_then(|v| v.as_str())
362 .unwrap_or("unknown fault")
363 .to_string();
364 return Err(Error::Fault { code, message });
365 }
366 Ok(Event::Eof) => {
367 return Err(Error::Parse("unexpected EOF in fault".into()));
368 }
369 Err(e) => return Err(e.into()),
370 _ => {}
371 }
372 }
373}
374
375fn parse_value_content(reader: &mut Reader<&[u8]>) -> Result<Value, Error> {
377 loop {
378 match reader.read_event() {
379 Ok(Event::Start(e)) => {
380 let tag = e.name().as_ref().to_vec();
381 match tag.as_slice() {
382 b"int" | b"i4" | b"i8" => {
383 let text = read_text_content(reader)?;
384 skip_to_end(reader, b"value")?;
385 return Ok(Value::Int(text.parse::<i64>().map_err(|e| {
386 Error::Parse(format!("invalid int '{text}': {e}"))
387 })?));
388 }
389 b"string" => {
390 let text = read_text_content(reader)?;
391 skip_to_end(reader, b"value")?;
392 return Ok(Value::String(text));
393 }
394 b"boolean" => {
395 let text = read_text_content(reader)?;
396 skip_to_end(reader, b"value")?;
397 return Ok(Value::Boolean(text == "1" || text == "true"));
398 }
399 b"double" => {
400 let text = read_text_content(reader)?;
401 skip_to_end(reader, b"value")?;
402 return Ok(Value::Double(text.parse::<f64>().map_err(|e| {
403 Error::Parse(format!("invalid double '{text}': {e}"))
404 })?));
405 }
406 b"struct" => {
407 let s = parse_struct_content(reader)?;
408 skip_to_end(reader, b"value")?;
409 return Ok(s);
410 }
411 b"array" => {
412 let a = parse_array_content(reader)?;
413 skip_to_end(reader, b"value")?;
414 return Ok(a);
415 }
416 _ => {
417 let text = read_text_content(reader)?;
419 skip_to_end(reader, b"value")?;
420 return Ok(Value::String(text));
421 }
422 }
423 }
424 Ok(Event::Empty(e)) if e.name().as_ref() == b"nil" => {
425 skip_to_end(reader, b"value")?;
426 return Ok(Value::Nil);
427 }
428 Ok(Event::Text(t)) => {
429 let text = decode_text(&t)?;
430 if !text.trim().is_empty() {
431 skip_to_end(reader, b"value")?;
433 return Ok(Value::String(text));
434 }
435 }
436 Ok(Event::End(e)) if e.name().as_ref() == b"value" => {
437 return Ok(Value::String(String::new()));
438 }
439 Ok(Event::Eof) => {
440 return Err(Error::Parse("unexpected EOF in value".into()));
441 }
442 Err(e) => return Err(e.into()),
443 _ => {}
444 }
445 }
446}
447
448fn parse_struct_content(reader: &mut Reader<&[u8]>) -> Result<Value, Error> {
449 let mut map = HashMap::new();
450 loop {
451 match reader.read_event() {
452 Ok(Event::Start(e)) if e.name().as_ref() == b"member" => {
453 let (name, value) = parse_member(reader)?;
454 map.insert(name, value);
455 }
456 Ok(Event::End(e)) if e.name().as_ref() == b"struct" => {
457 return Ok(Value::Struct(map));
458 }
459 Ok(Event::Eof) => {
460 return Err(Error::Parse("unexpected EOF in struct".into()));
461 }
462 Err(e) => return Err(e.into()),
463 _ => {}
464 }
465 }
466}
467
468fn parse_member(reader: &mut Reader<&[u8]>) -> Result<(String, Value), Error> {
469 let mut name = String::new();
470 let mut value = Value::Nil;
471 loop {
472 match reader.read_event() {
473 Ok(Event::Start(e)) => match e.name().as_ref() {
474 b"name" => {
475 name = read_text_content(reader)?;
476 }
477 b"value" => {
478 value = parse_value_content(reader)?;
479 }
480 _ => {}
481 },
482 Ok(Event::End(e)) if e.name().as_ref() == b"member" => {
483 return Ok((name, value));
484 }
485 Ok(Event::Eof) => {
486 return Err(Error::Parse("unexpected EOF in member".into()));
487 }
488 Err(e) => return Err(e.into()),
489 _ => {}
490 }
491 }
492}
493
494fn parse_array_content(reader: &mut Reader<&[u8]>) -> Result<Value, Error> {
495 let mut items = Vec::new();
496 loop {
497 match reader.read_event() {
498 Ok(Event::Start(e)) => {
499 if e.name().as_ref() == b"data" {
500 loop {
501 match reader.read_event() {
502 Ok(Event::Start(e2)) if e2.name().as_ref() == b"value" => {
503 items.push(parse_value_content(reader)?);
504 }
505 Ok(Event::End(e2)) if e2.name().as_ref() == b"data" => break,
506 Ok(Event::Eof) => {
507 return Err(Error::Parse("unexpected EOF in array data".into()));
508 }
509 Err(e) => return Err(e.into()),
510 _ => {}
511 }
512 }
513 }
514 }
515 Ok(Event::End(e)) if e.name().as_ref() == b"array" => {
516 return Ok(Value::Array(items));
517 }
518 Ok(Event::Eof) => {
519 return Err(Error::Parse("unexpected EOF in array".into()));
520 }
521 Err(e) => return Err(e.into()),
522 _ => {}
523 }
524 }
525}
526
527fn decode_text(t: &BytesText) -> Result<String, Error> {
533 let decoded = t.decode().map_err(|e| Error::Xml(e.to_string()))?;
534 Ok(quick_xml::escape::unescape(&decoded)
535 .map_err(|e| Error::Xml(e.to_string()))?
536 .into_owned())
537}
538
539fn read_text_content(reader: &mut Reader<&[u8]>) -> Result<String, Error> {
540 let mut text = String::new();
541 loop {
542 match reader.read_event() {
543 Ok(Event::Text(t)) => {
544 text.push_str(&decode_text(&t)?);
545 }
546 Ok(Event::End(_)) => return Ok(text),
547 Ok(Event::Eof) => {
548 return Err(Error::Parse("unexpected EOF reading text".into()));
549 }
550 Err(e) => return Err(e.into()),
551 _ => {}
552 }
553 }
554}
555
556fn skip_to_end(reader: &mut Reader<&[u8]>, end_tag: &[u8]) -> Result<(), Error> {
558 let mut depth: u32 = 0;
559 loop {
560 match reader.read_event() {
561 Ok(Event::Start(_)) => depth += 1,
562 Ok(Event::End(e)) => {
563 if depth == 0 && e.name().as_ref() == end_tag {
564 return Ok(());
565 }
566 depth = depth.saturating_sub(1);
567 }
568 Ok(Event::Eof) => return Ok(()),
569 Err(e) => return Err(e.into()),
570 _ => {}
571 }
572 }
573}
574
575#[cfg(test)]
576mod tests {
577 use super::*;
578
579 #[test]
580 fn test_build_request_int() {
581 let xml = build_request("getBuild", &[Value::Int(42)]);
582 assert!(xml.contains("<methodName>getBuild</methodName>"));
583 assert!(xml.contains("<int>42</int>"));
584 }
585
586 #[test]
587 fn test_build_request_string_escaping() {
588 let xml = build_request("test", &[Value::String("a<b&c".into())]);
589 assert!(xml.contains("a<b&c"));
590 }
591
592 #[test]
593 fn test_parse_int_response() {
594 let xml = r#"<?xml version="1.0"?>
595 <methodResponse><params><param>
596 <value><int>42</int></value>
597 </param></params></methodResponse>"#;
598 let v = parse_response(xml).unwrap();
599 assert_eq!(v.as_int(), Some(42));
600 }
601
602 #[test]
603 fn test_parse_string_response() {
604 let xml = r#"<?xml version="1.0"?>
605 <methodResponse><params><param>
606 <value><string>hello world</string></value>
607 </param></params></methodResponse>"#;
608 let v = parse_response(xml).unwrap();
609 assert_eq!(v.as_str(), Some("hello world"));
610 }
611
612 #[test]
613 fn test_parse_struct_response() {
614 let xml = r#"<?xml version="1.0"?>
615 <methodResponse><params><param>
616 <value><struct>
617 <member><name>task_id</name><value><int>12345</int></value></member>
618 <member><name>nvr</name><value><string>foo-1.0-1.fc42</string></value></member>
619 </struct></value>
620 </param></params></methodResponse>"#;
621 let v = parse_response(xml).unwrap();
622 assert_eq!(v.get("task_id").unwrap().as_int(), Some(12345));
623 assert_eq!(v.get("nvr").unwrap().as_str(), Some("foo-1.0-1.fc42"));
624 }
625
626 #[test]
627 fn test_parse_array_response() {
628 let xml = r#"<?xml version="1.0"?>
629 <methodResponse><params><param>
630 <value><array><data>
631 <value><int>1</int></value>
632 <value><int>2</int></value>
633 <value><int>3</int></value>
634 </data></array></value>
635 </param></params></methodResponse>"#;
636 let v = parse_response(xml).unwrap();
637 let arr = v.as_array().unwrap();
638 assert_eq!(arr.len(), 3);
639 assert_eq!(arr[0].as_int(), Some(1));
640 assert_eq!(arr[2].as_int(), Some(3));
641 }
642
643 #[test]
644 fn test_parse_nested_struct_array() {
645 let xml = r#"<?xml version="1.0"?>
646 <methodResponse><params><param>
647 <value><array><data>
648 <value><struct>
649 <member><name>id</name><value><int>100</int></value></member>
650 <member><name>method</name><value><string>buildArch</string></value></member>
651 <member><name>arch</name><value><string>x86_64</string></value></member>
652 </struct></value>
653 <value><struct>
654 <member><name>id</name><value><int>101</int></value></member>
655 <member><name>method</name><value><string>buildArch</string></value></member>
656 <member><name>arch</name><value><string>aarch64</string></value></member>
657 </struct></value>
658 </data></array></value>
659 </param></params></methodResponse>"#;
660 let v = parse_response(xml).unwrap();
661 let arr = v.as_array().unwrap();
662 assert_eq!(arr.len(), 2);
663 assert_eq!(arr[0].get("id").unwrap().as_int(), Some(100));
664 assert_eq!(arr[0].get("arch").unwrap().as_str(), Some("x86_64"));
665 assert_eq!(arr[1].get("id").unwrap().as_int(), Some(101));
666 }
667
668 #[test]
669 fn test_parse_boolean_response() {
670 let xml = r#"<?xml version="1.0"?>
671 <methodResponse><params><param>
672 <value><boolean>1</boolean></value>
673 </param></params></methodResponse>"#;
674 let v = parse_response(xml).unwrap();
675 assert_eq!(v.as_int(), None);
676 match v {
677 Value::Boolean(b) => assert!(b),
678 _ => panic!("expected boolean"),
679 }
680 }
681
682 #[test]
683 fn test_parse_nil_response() {
684 let xml = r#"<?xml version="1.0"?>
685 <methodResponse><params><param>
686 <value><nil/></value>
687 </param></params></methodResponse>"#;
688 let v = parse_response(xml).unwrap();
689 assert!(matches!(v, Value::Nil));
690 }
691
692 #[test]
693 fn test_parse_fault_response() {
694 let xml = r#"<?xml version="1.0"?>
695 <methodResponse><fault><value><struct>
696 <member><name>faultCode</name><value><int>1000</int></value></member>
697 <member><name>faultString</name><value><string>No such build</string></value></member>
698 </struct></value></fault></methodResponse>"#;
699 let err = parse_response(xml).unwrap_err();
700 match err {
701 Error::Fault { code, message } => {
702 assert_eq!(code, 1000);
703 assert_eq!(message, "No such build");
704 }
705 _ => panic!("expected Fault error, got: {err}"),
706 }
707 }
708
709 #[test]
710 fn test_parse_bare_text_as_string() {
711 let xml = r#"<?xml version="1.0"?>
712 <methodResponse><params><param>
713 <value>bare text</value>
714 </param></params></methodResponse>"#;
715 let v = parse_response(xml).unwrap();
716 assert_eq!(v.as_str(), Some("bare text"));
717 }
718
719 #[test]
720 fn test_is_retriable_http_error() {
721 let err = Error::Xml("unexpected token".into());
723 assert!(err.is_retriable());
724 }
725
726 #[test]
727 fn test_is_retriable_parse_502() {
728 let err = Error::Parse("koji download-logs failed: 502 Bad Gateway".into());
729 assert!(err.is_retriable());
730 }
731
732 #[test]
733 fn test_is_retriable_parse_503() {
734 let err = Error::Parse("503 Service Unavailable".into());
735 assert!(err.is_retriable());
736 }
737
738 #[test]
739 fn test_is_not_retriable_fault() {
740 let err = Error::Fault {
741 code: 1000,
742 message: "No such build".into(),
743 };
744 assert!(!err.is_retriable());
745 }
746
747 #[test]
748 fn test_is_not_retriable_parse_not_found() {
749 let err = Error::Parse("root.log not found for task 123".into());
750 assert!(!err.is_retriable());
751 }
752}