bofh 0.0.1

Library for communicating with the Cerebrum IGA
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use thiserror::Error;
use xmlrpc::{Request, Value};

#[derive(Error, Debug)]
pub enum BofhError {
    #[error("{0}")]
    XmlRpcError(#[from] xmlrpc::Error),
    #[error("Attempted to run session command before session was established")]
    NoSessionError,
    #[error("{0}")]
    CerebrumError(String),
    #[error("Server restarted")]
    ServerRestartedError,
    #[error("Session expired")]
    SessionExpiredError,
    #[error("Unknown command")]
    NotImplementedError,
    #[error("{0}")]
    Fault(String),
}

pub struct Bofh {
    /// The URL to the bofhd server
    pub url: String,
    session: Option<String>,
    /// The Message Of The Day provided by the bofhd server after connection
    pub motd: Option<String>,
}

impl Bofh {
    pub fn new(url: String) -> Result<Self, BofhError> {
        let mut bofh = Self {
            url,
            session: None,
            motd: None,
        };
        bofh.motd = Some(bofh.get_motd()?);
        Ok(bofh)
    }

    fn run_request(&mut self, request: Request) -> Result<Value, BofhError> {
        match request.call_url(&self.url) {
            Ok(result) => Ok(result),
            Err(err) => {
                if let Some(fault) = err.fault() {
                    if let Some(bofhd_error) = fault
                        .fault_string
                        .strip_prefix("Cerebrum.modules.bofhd.errors.")
                    {
                        if let Some(cerebrum_error) = bofhd_error.strip_prefix("CerebrumError:") {
                            Err(BofhError::CerebrumError(cerebrum_error.to_string()))
                        } else if bofhd_error.strip_prefix("ServerRestartedError:").is_some() {
                            //Err(BofhError::ServerRestartedError)
                            //self.init_commands(True);
                            self.run_request(request)
                        } else if bofhd_error.strip_prefix("SessionExpiredError:").is_some() {
                            //Err(BofhError::SessionExpiredError(request))
                            todo!() // TODO
                        } else {
                            unimplemented!()
                        }
                    } else if fault
                        .fault_string
                        .strip_prefix("NotImplementedError:")
                        .is_some()
                    {
                        Err(BofhError::NotImplementedError)
                    } else {
                        Err(BofhError::Fault(fault.fault_string.to_owned()))
                    }
                } else {
                    Err(BofhError::XmlRpcError(err))
                }
            }
        }
    }

    fn run_raw_command(&mut self, command: &str, args: Vec<&str>) -> Result<Value, BofhError> {
        let mut request = Request::new(command);
        for arg in args {
            request = request.arg(arg);
        }
        self.run_request(request)
    }

    fn run_raw_sess_command(&mut self, command: &str, args: Vec<&str>) -> Result<Value, BofhError> {
        if let Some(session) = &self.session {
            let mut request = Request::new(command).arg(session.to_owned());
            for arg in args {
                request = request.arg(arg);
            }
            self.run_request(request)
        } else {
            // TODO Maybe just panic here instead, this should never happen
            Err(BofhError::NoSessionError)
        }
    }

    pub fn run_command(&mut self, command: &str, args: Vec<&str>) -> Result<Value, BofhError> {
        self.run_raw_sess_command(command, args)
    }

    pub fn login(
        &mut self,
        username: &str,
        password: String,
        _init: bool,
    ) -> Result<(), BofhError> {
        self.session = Some(
            self.run_raw_command("login", vec![username, &password])?
                .as_str()
                .unwrap()
                .to_string(),
        );
        Ok(())
    }

    pub fn get_motd(&mut self) -> Result<String, BofhError> {
        Ok(self
            .run_raw_command("get_motd", vec![])?
            .as_str()
            .unwrap()
            .to_string())
    }
}

impl Drop for Bofh {
    fn drop(&mut self) {
        if self.session.is_some() {
            let _ = self.run_raw_sess_command("logout", vec![]);
        }
        self.session = None;
        // TODO bring down all commands
    }
}

#[cfg(test)]
mod tests {
    use crate::Bofh;
    #[test]
    fn connect() {
        let _ = Bofh::new(String::from("https://cerebrum-uio-test.uio.no:8000"));
    }
}