path: root/src/house.rs

/*!
  * `House`s are where [crate::waifu::Waifu]s live (the physical hypervisors that
  * libvirtd connects to
  */
use crate::waifu::*;
use crate::errors::Error;
use serde::{Serialize, Deserialize};
use std::convert::TryFrom;
use virt::connect::Connect;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};

#[derive(Serialize, Deserialize, Debug)]
pub enum Address {
    IP(String),
    Domain(String)
}

impl ToString for Address {
    fn to_string(&self) -> String {
        match self {
            Address::IP(s) => s.clone(),
            Address::Domain(s) => s.clone(),
        }
    }
}

/// Defines a "house" where waifus live
#[derive(Debug, Serialize, Deserialize)]
pub struct House {
    /// Hostname
    pub name: String,
    /// FQDN or IP address, a way to talk to the house
    pub address: String,

    /// Connection to the House, if available
    #[serde(skip)]
    con: Option<Connect>,
}

impl House { 
    pub fn new(url: String) -> Result<Self, Error> {
        let mut c = Connect::open(&url.clone())?;

        // If the connection succeeds, we've got one!
        Ok(Self {
            name: c.get_hostname()?,
            address: c.get_uri()?,
            con: Some(c),
        })
    }

    pub fn inhabitants(&mut self) -> Result<Vec<Waifu>, Error> {
        match &self.con {
            Some(c) => {
                let domains = c.list_all_domains(0)?;

                let mut waifus: Vec<Waifu> = Vec::new();

                for d in domains.iter() {
                    waifus.push(d.clone().try_into()?);
                }
                Ok(waifus)
            },
            None => {
                return Err(Error::Connection("Domain connection was None".to_string()));
            }
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;
    /// Kind of a stupid test, but just a sanity check to make sure that [ToString] impl up above
    /// is still working
    #[test]
    fn addr_to_string() {
        let a: Address = Address::IP("127.0.0.1".to_string());
        let d: Address = Address::Domain("example.com".to_string());

        assert_eq!(String::from("127.0.0.1"), a.to_string());
        assert_eq!("example.com".to_string(), d.to_string());
    }

    #[test]
    fn connect_to_house() {
        let h: House = House::new("test:///default".to_string()).unwrap();
    }

    #[test]
    fn list_inhabitants() {
        let mut h: House = House::new("test:///default".to_string()).unwrap();

        let empty_vec: Vec<Waifu> = vec![];

        h.inhabitants().unwrap();
    }

}