129 lines
3.5 KiB
Rust
129 lines
3.5 KiB
Rust
use serde::{Deserialize, Serialize};
|
|
use std::{fmt, net::Ipv4Addr};
|
|
use trust_dns_proto::rr::Name;
|
|
|
|
use crate::net::{cidr::CidrV4, mac::MacAddr};
|
|
|
|
#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
|
|
#[repr(u32)]
|
|
pub enum DomainState {
|
|
NoState = 0u32,
|
|
Running,
|
|
Blocked,
|
|
Paused,
|
|
ShuttingDown,
|
|
ShutOff,
|
|
Crashed,
|
|
Suspended,
|
|
Unknown(u32),
|
|
}
|
|
|
|
impl Default for DomainState {
|
|
fn default() -> Self {
|
|
Self::NoState
|
|
}
|
|
}
|
|
|
|
impl From<u32> for DomainState {
|
|
fn from(value: u32) -> Self {
|
|
match value {
|
|
0 => Self::NoState,
|
|
1 => Self::Running,
|
|
2 => Self::Blocked,
|
|
3 => Self::Paused,
|
|
4 => Self::ShuttingDown,
|
|
5 => Self::ShutOff,
|
|
6 => Self::Crashed,
|
|
7 => Self::Suspended,
|
|
other => Self::Unknown(other),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for DomainState {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
write!(
|
|
f,
|
|
"{}",
|
|
match self {
|
|
Self::NoState => "no state".to_owned(),
|
|
Self::Running => "running".to_owned(),
|
|
Self::Blocked => "blocked".to_owned(),
|
|
Self::Paused => "paused".to_owned(),
|
|
Self::ShuttingDown => "shutting down".to_owned(),
|
|
Self::ShutOff => "shut off".to_owned(),
|
|
Self::Crashed => "crashed".to_owned(),
|
|
Self::Suspended => "suspended".to_owned(),
|
|
Self::Unknown(code) => format!("unknown ({})", code),
|
|
}
|
|
)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
pub struct CreateStatus {
|
|
pub status_text: String,
|
|
pub completion: f32,
|
|
pub result: Option<Result<Instance, String>>,
|
|
}
|
|
|
|
/// Struct representing a VM instance.
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
pub struct Instance {
|
|
pub name: String,
|
|
pub uuid: uuid::Uuid,
|
|
pub lease: Option<Lease>,
|
|
pub state: DomainState,
|
|
}
|
|
|
|
/// Struct representing a logical "lease" held by a VM.
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
pub struct Lease {
|
|
/// Subnet name corresponding to the lease
|
|
pub subnet: String,
|
|
/// The IPv4 address held by the Lease
|
|
pub addr: CidrV4,
|
|
/// The MAC address associated by the Lease
|
|
pub mac_addr: MacAddr,
|
|
}
|
|
|
|
/// Struct representing a subnet used by the host for virtual
|
|
/// networking.
|
|
#[derive(Clone, Debug, Serialize, Deserialize)]
|
|
pub struct Subnet {
|
|
/// The subnet short name.
|
|
pub name: String,
|
|
pub data: SubnetData,
|
|
}
|
|
|
|
#[derive(Clone, Debug, Serialize, Deserialize)]
|
|
pub struct SubnetData {
|
|
/// The name of the interface the subnet is accessible via.
|
|
pub ifname: String,
|
|
/// The network information for the subnet.
|
|
pub network: CidrV4,
|
|
/// The first host address that can be assigned dynamically
|
|
/// on the subnet.
|
|
pub start_host: Ipv4Addr,
|
|
/// The last host address that can be assigned dynamically
|
|
/// on the subnet.
|
|
pub end_host: Ipv4Addr,
|
|
/// The default gateway for the subnet.
|
|
pub gateway4: Ipv4Addr,
|
|
/// The primary DNS server for the subnet.
|
|
pub dns: Vec<Ipv4Addr>,
|
|
/// The base domain used for DNS lookup.
|
|
pub domain_name: Option<Name>,
|
|
/// The VLAN ID used for the domain. If none, no VLAN is set.
|
|
pub vlan_id: Option<u32>,
|
|
}
|
|
|
|
impl SubnetData {
|
|
pub fn start_bytes(&self) -> u32 {
|
|
self.network.host_bits(&self.start_host)
|
|
}
|
|
|
|
pub fn end_bytes(&self) -> u32 {
|
|
self.network.host_bits(&self.end_host)
|
|
}
|
|
}
|