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 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
93pub 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 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
121fn 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("<"),
150 '>' => xml.push_str(">"),
151 '&' => xml.push_str("&"),
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
186pub 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
251fn 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 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 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
405fn 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
423fn 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<b&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}