xmlrpc 0.15.1

An XML-RPC implementation for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

//! Tests communication with a python3 XML-RPC server.

extern crate xmlrpc;

use xmlrpc::{Fault, Request, Value};

use std::net::TcpStream;
use std::process::{Child, Command};
use std::thread::sleep;
use std::time::{Duration, Instant};

const PORT: u16 = 8000;
const URL: &'static str = "http://127.0.0.1:8000";

/// Kills a child process when dropped.
struct Reap(Child);

impl Drop for Reap {
    fn drop(&mut self) {
        // an error seems to mean that the process has already died, which we don't expect here
        self.0.kill().expect("process already died");
    }
}

fn setup() -> Result<Reap, ()> {
    let start = Instant::now();
    let mut child = match Command::new("python3")
        .arg("-m")
        .arg("xmlrpc.server")
        .spawn()
    {
        Ok(child) => child,
        Err(e) => {
            eprintln!(
                "could not start python XML-RPC server, ignoring python test ({})",
                e
            );
            return Err(());
        }
    };

    // wait until someone listens on the port or the child dies
    let mut iteration = 0;
    loop {
        match child.try_wait().unwrap() {
            None => {} // still running
            Some(status) => panic!("python process unexpectedly died: {}", status),
        }

        // try to connect to the server
        match TcpStream::connect(("127.0.0.1", PORT)) {
            Ok(_) => {
                // server should work now
                println!(
                    "connected to server after {:?} (iteration {})",
                    Instant::now() - start,
                    iteration
                );
                return Ok(Reap(child));
            }
            Err(_) => {} // not yet ready
        }

        sleep(Duration::from_millis(50));

        iteration += 1;
    }
}

fn run_tests() {
    let pow = Request::new("pow").arg(2).arg(8).call_url(URL).unwrap();
    assert_eq!(pow.as_i64(), Some(2i64.pow(8)));

    // call with wrong operands should return a fault
    let err = Request::new("pow")
        .arg(2)
        .arg(2)
        .arg("BLA")
        .call_url(URL)
        .unwrap_err();
    err.fault().expect("returned error was not a fault");

    // perform a multicall
    let result = Request::new_multicall(&[
        Request::new("pow").arg(2).arg(4),
        Request::new("add").arg(2).arg(4),
        Request::new("doesn't exist"),
    ])
    .call_url(URL)
    .unwrap();
    // `result` now contains an array of results. on success, a 1-element array containing the
    // result is placed in the `result` array. on fault, the corresponding fault struct is used.
    let results = result.as_array().unwrap();
    assert_eq!(results[0], Value::Array(vec![Value::Int(16)]));
    assert_eq!(results[1], Value::Array(vec![Value::Int(6)]));
    Fault::from_value(&results[2]).expect("expected fault as third result");
}

fn main() {
    let mut reaper = match setup() {
        Ok(reap) => reap,
        Err(()) => return,
    };

    match reaper.0.try_wait().unwrap() {
        None => {} // still running
        Some(status) => {
            panic!("python process unexpectedly exited: {}", status);
        }
    }

    run_tests();

    match reaper.0.try_wait().unwrap() {
        None => {} // still running
        Some(status) => {
            panic!("python process unexpectedly exited: {}", status);
        }
    }
}