//! All responses which are recieved by this application from the Lunanode API.
//! These responses are all strictly typed, and documented. Although in some cases it is noted that
//! it should have an even stricter type, or that the field meaning is unkown.
use crate ::success ;
use crate ::external ;
use crate ::types ::{
LunaNodeResponse ,
} ;
use clap ;
use lunanode_macros ::lunanode_response ;
use serde ::{ Serialize , Deserialize } ;
use serde_with ::{
DisplayFromStr ,
serde_as ,
} ;
#[ serde_as ]
#[ derive(Serialize, Deserialize, PartialEq, Debug) ]
/// Defines a VM (used for requests using the VM section)
pub struct VirtualMachine {
/// the UUID of the VM
vm_id : String , // should be UUIDv4
/// the name of the VM set by the user
name : String , // the name set by the user
#[ serde_as(as= " DisplayFromStr " ) ]
/// The plan ID, cross-reference with /plan/list/
plan_id : i32 , // should be more strict
/// The hostname set by the user
hostname : String , // the hostname set by the user
#[ serde(rename= " primaryip " ) ]
/// The primary (public) IP address of the VM.
primary_ip : std ::net ::Ipv4Addr ,
#[ serde(rename= " privateip " ) ]
/// The private IP address of the VM.
private_ip : std ::net ::Ipv4Addr ,
#[ serde_as(as= " DisplayFromStr " ) ]
/// RAM of the VM in GB
ram : i32 , // in GB, may need to be a float
#[ serde_as(as= " DisplayFromStr " ) ]
/// The number of virtual CPU cores
vcpu : i32 , // CPU cores
#[ serde_as(as= " DisplayFromStr " ) ]
/// The storage amount of the VM in GB
storage : i32 , // in GB
#[ serde_as(as= " DisplayFromStr " ) ]
/// bandwidth in GB/month
bandwidth : i32 , // in GB/month
/// The region where the VM is located
region : LNRegion , // could be more strict
/// The status, which should be more strict than a String.
os_status : String , // should be nmore strict
}
#[ lunanode_response ]
/// The result of requesting a list of VMs on the user's Lunanode account.
/// See also: [`crate::requests::VmListRequest`]
pub struct VmListResponse {
/// A list of VMs.
vms : Vec < VirtualMachine > ,
}
#[ derive(Serialize, Deserialize, Debug) ]
#[ serde(rename_all= " lowercase " ) ]
/// An enum defining whether an IP is attached to a VM or is simply allocated without being
/// attached to any VM in particular.
/// See also: [`FloatingIp`]
enum AttachmentType {
/// An unattached floating IP.
Unattached ,
/// An attached floating IP.
Vm ,
}
#[ serde_as ]
#[ derive(Serialize, Deserialize, Debug) ]
/// Detailed information about a floating IP
struct FloatingIp {
/// A String with a VM UUID if attached, otherwise None.
attached_id : Option < String > ,
/// A String with the VM's name if attached, otherwise None.
attached_name : Option < String > ,
/// Vm/Unattached
attached_type : AttachmentType ,
/// The hostname of the floating IP address, usually something like
/// xxx-xxx-xxx-xxx.rdns.lunanode.com
hostname : String ,
/// The IP address of the floating IP.
ip : std ::net ::Ipv4Addr ,
/// The region in which the IP address has been allocated.
region : LNRegion ,
/// The rDNS domain, if specified, otherwise, None.
reverse : Option < String > ,
#[ serde_as(as= " DisplayFromStr " ) ]
/// The last time the record was updated.
time_updated : chrono ::DateTime < chrono ::Utc > ,
}
#[ serde_as ]
#[ derive(Serialize, Deserialize, Debug) ]
/// Extra detailed information for a VM.
pub struct VMInfoExtra {
#[ serde_as(as= " DisplayFromStr " ) ]
/// bandwidth allowed over a month in GB
bandwidth : i32 ,
/// the hostname set by the user
hostname : String , // sufficiently vague
/// the name set by the user
name : String , // sufficiently vague
/// the status of the operating system; possible values: "active", ... TODO
os_status : String , // should be stricter
#[ serde_as(as= " DisplayFromStr " ) ]
/// id of the plan being used on the VM
plan_id : i32 ,
#[ serde(rename= " primaryip " ) ]
/// primary (floating) IP
primary_ip : std ::net ::Ipv4Addr ,
#[ serde(rename= " privateip " ) ]
/// the private (non-floating) IP to connect between nodes
private_ip : std ::net ::Ipv4Addr ,
#[ serde_as(as= " DisplayFromStr " ) ]
/// RAM meassured in MB
ram : i32 ,
/// the datacentre location the VM is running in
region : LNRegion ,
#[ serde_as(as= " DisplayFromStr " ) ]
/// the storage size of the VM in GB
storage : i32 ,
#[ serde_as(as= " DisplayFromStr " ) ]
/// number of virtual CPU cores allocated to the VM
vcpu : i32 ,
#[ serde_as(as= " DisplayFromStr " ) ]
/// UUIDv4 of the VM
vm_id : String ,
}
#[ derive(Serialize, Deserialize, Debug) ]
#[ serde(untagged) ]
/// A generic IP address type, with two variants: V4, and V6. This is used for generic types returned from the API. For example, a list of IP addresses without the IP type specified.
pub enum IPAddress {
/// IPv4 variant
V4 ( std ::net ::Ipv4Addr ) ,
/// IPv6 variant
V6 ( std ::net ::Ipv6Addr ) ,
}
#[ derive(Serialize, Deserialize, Debug) ]
/// An IP address type enum, specifying either V4 or V6.
pub enum IPAddressType {
#[ serde(rename= " 4 " ) ]
/// IPv4 variant
V4 ,
#[ serde(rename= " 6 " ) ]
/// IPv6 variant
V6 ,
}
#[ derive(Serialize, Deserialize, Debug) ]
/// VM IP address
pub struct VMAddress {
/// The IP address of the VM.
addr : IPAddress ,
#[ serde(with= " external " ) ]
/// Whether the IP is an internal or external kind.
external : bool ,
/// The version of IP address used.
version : IPAddressType ,
#[ serde(rename= " reverse " ) ]
/// The reverse DNS assigned to the VM, if specified. Otherwise, None.
rdns : Option < String > ,
}
#[ serde_as ]
#[ derive(Serialize, Deserialize, Debug) ]
/// Detailed VM info.
pub struct VMInfo {
#[ serde(rename= " additionalip " ) ]
/// A list of additional IPs (which are not the primary IP) which have been assigned to the VM.
additional_ip : Vec < VMAddress > ,
#[ serde(rename= " additionalprivateip " ) ]
/// Any additional private IPs assigned to the VM.
additional_private_ip : Vec < VMAddress > ,
/// A list of addresses inherently part of the VM. Think of a primary private IP, or where
/// outgoing internet traffic is routed.
addresses : Vec < VMAddress > ,
/// a possibly empty string containing an error message
error_detail : Option < String > ,
/// some unkown string that doesn't seem to be a UUID... maybe the checksum?
host_id : String ,
/// the name of the VM set at creation by the user
hostname : String ,
/// the name of the image being used by the VM
image : String ,
/// the primary, external IP of the VM
ip : std ::net ::Ipv4Addr ,
/// a list of IPv6 addresses assigned to the VM
ipv6 : Vec < std ::net ::Ipv6Addr > ,
/// Login details from the VM; this could potentially be a bit more strict to support the storing of username and password separately.
/// Also, it's optional. The server may not even report this value at all, not only give a blank one. Fair enough. Seems more secure.
login_details : Option < String > ,
/// the operating system (orignal image used to load the machine)
os : String , // sufficiently vague
#[ serde(rename= " privateip " ) ]
/// the primary private IP assigned to the machine
private_ip : std ::net ::Ipv4Addr ,
/// security groups by id that the VM belongs to; should be a vec of i32, but it might take some custom implementations
security_group_ids : Vec < String > ,
/// security groups by name that the VM belongs to
security_groups : Vec < String > ,
#[ serde(rename= " securitygroups " ) ]
/// why is there a second one of these with a different name. This is stupid.
security_groups2 : Vec < String > ,
/// an HTML status of the machine
status : String ,
/// the color of the status; this could be stricter
status_color : String , // could be more strict
/// the non-HTML status, this could potentially be more strict
status_nohtml : String ,
/// A raw status-code string; this could for sure be more strict.
status_raw : String ,
/// A possibly empty string, idk what task_state is tho
task_state : String , // a possibly empty string
/// A possibly empty string of attached volumes.
volumes : String ,
}
#[ lunanode_response ]
/// The result from a [`crate::requests::VmInfoRequest`].
pub struct VMInfoResponse {
/// Extra information (cached)
extra : VMInfoExtra ,
/// Detailed VM info (uncached)
info : VMInfo ,
}
#[ derive(Serialize, Deserialize, Debug) ]
/// A plan category.
pub enum PlanCategory {
#[ serde(rename= " Compute-Optimized " ) ]
/// For CPU-bound tasks.
ComputeOptimized ,
#[ serde(rename= " General Purpose " ) ]
/// Pretty good for most projects.
GeneralPurpose ,
#[ serde(rename= " Memory-Optimized " ) ]
/// For memory-bound tasks.
MemoryOptimized ,
#[ serde(rename= " SSD-Cached High-Memory " ) ]
/// For IO/memory-bound tasks.
SSDCacheHighMemory ,
#[ serde(rename= " SSD-Cached Standard " ) ]
/// For IO-bound tasks.
SSDCacheStandard ,
}
#[ derive(Serialize, Deserialize, Debug, Hash, Eq, PartialEq) ]
#[ serde(rename_all = " lowercase " ) ]
/// Regions where Lunanode is supported.
pub enum LNRegion {
/// Montreal, Quebec, Canada.
Montreal ,
/// Roubaix, France.
Roubaix ,
/// Toronto, Ontario, Canada.
Toronto
}
#[ serde_as ]
#[ derive(Serialize, Deserialize, Debug) ]
/// A VM plan/level of serivce.
pub struct Plan {
#[ serde_as(as= " DisplayFromStr " ) ]
/// Does the plan support all regions?
all_regions : i32 , // may need to be more strict?
#[ serde_as(as= " DisplayFromStr " ) ]
/// The maxmimum bandwidth in Mbps
bandwidth : i32 , // in Mbps
/// Category of plan
category : PlanCategory ,
#[ serde_as(as= " DisplayFromStr " ) ]
/// Lunanode uses a CPU points system to determine how powerful the CPU is.
cpu_points : f32 , // no idea what this meas
/// The name of the plan, set by Lunanode themselves.
name : String , // plan name, this could potentially be strictly typed as the types of plans don't often change "s.half", "s.1", "m.1", "m.2", etc.
#[ serde_as(as= " DisplayFromStr " ) ]
/// The plan ID. Could be useful if creating a new VM.
plan_id : i32 , // can be strictly typed, if needed
#[ serde_as(as= " DisplayFromStr " ) ]
/// The cost in USD per hour.
price : f32 , // up to 7 decmial points (f32), and this is the number of US dollars per hour
/// The price is USD per month, with a $ attached.
price_monthly_nice : String , // instead of calculating it on your own, this provides a nice reading of the price for clients
/// The price in USD per hour, with a $ attached.
price_nice : String , // same as above, but for the hour
#[ serde_as(as= " DisplayFromStr " ) ]
/// The amount of RAM in MB.
ram : i32 , // in MB
/// Regions where the plan can be dpeloyed.
regions : Vec < LNRegion > , // list of regions by name
/// Regions where the plan can be deployed, separated by a comma.
regions_nice : String , // list of regions concatonated with commans
#[ serde_as(as= " DisplayFromStr " ) ]
/// Storage in GB.
storage : i32 , // per GB
#[ serde_as(as= " DisplayFromStr " ) ]
/// Number of vCPU cores.
vcpu : i32 , // number of vCPU cores
}
#[ lunanode_response ]
/// A list of plans from a [`crate::requests::PlanListRequest`]
pub struct PlanListResponse {
/// List of plans; see [`Plan`] for more detail.
plans : Vec < Plan > ,
}
#[ serde_as ]
#[ derive(Serialize, Deserialize, Debug) ]
/// An ISO or QCOW2 image stored on Lunanode.
pub struct Image {
#[ serde_as(as= " DisplayFromStr " ) ]
/// ID of the image. This is useful for later if you would like to interact with it in some way.
image_id : i32 , // id of the image
/// Name of the Image set by the user, or Lunanode.
name : String , // set by the user or LunaNode
/// The region in which the image is stored.
region : LNRegion ,
/// The status of the image; at least "active" and "inactive" are possible.
status : String , // should be stricter, at least "active", "inactive"(?)
}
#[ serde_as ]
#[ derive(Serialize, Deserialize, Debug) ]
/// A storage volume on the user's Lunanode account.
pub struct Volume {
#[ serde_as(as= " DisplayFromStr " ) ]
/// The personal ID used for the volume.
id : i32 ,
#[ serde_as(as= " DisplayFromStr " ) ]
/// the UUID for the volume
identification : String ,
/// the name set by the user
name : String ,
/// The region where the volume is located.
region : LNRegion ,
/// The size of the volume, in GB
#[ serde_as(as= " DisplayFromStr " ) ]
size : i32 ,
/// The status of the volume; this should be more string, but for now at least "active".
status : String ,
#[ serde_as(as= " DisplayFromStr " ) ]
/// a datetime (explicitly set to UTC) of when the volume was created
time_created : chrono ::DateTime < chrono ::Utc > ,
#[ serde_as(as= " DisplayFromStr " ) ]
/// ID of the user who created the volume
user_id : i32 ,
}
#[ serde_as ]
#[ derive(Serialize, Deserialize, Debug) ]
/// Details of a Lunanode image
pub struct ImageDetails {
/// This should be more strict. At least one possible value is "writeback".
cache_mode : String , // should be stricter, at least "writeback",
/// This should be more strict; this should be a strict checksum type.
checksum : String , // should be stricter, to check of checksum type
/// This should be more strict. At least one possible value is "iso".
disk_format : String , // should be stricter, at least "iso"
/// This should be more strict. I think the only possible values are "ide" and "sata".
hw_disk_bus : String , // should be stricter, at least "ide",
/// It's not clear exactly what this means; the Lunanode documentation isn't extremely well done.
/// But at least one possible value here is "cirrus"; unsure if other values are possible, or
/// what they are.
hw_video_model : String , // could, in theory, be stricter, at least: "cirrus",
/// The model of the virtual interface (I think)
hw_vif_model : String , // appropriately vague
/// A read only image?
#[ serde(with= " success " ) ]
is_read_only : bool , // "yes"/"no"
/// There should not be many possible values, but one of them is "host-model".
libvrt_cpu_mode : String , // should be stricter, at least: "host-model",
/// Unkown list of metadata.
metadata : Vec < ( ) > , // vec of what?
/// The name of the image; often set by the user.
name : String , // sufficiently vague
/// The region of the image.
region : LNRegion , // sufficiently typed
/// The size of the image in MB.
size : i32 , // in MB, maybe?
/// In theory this could be stricter, but Lunanode does not enumerate all possible return types.
/// Possible values are at least: "active".
status : String , // should be stricter, at least: "active",
#[ serde_as(as= " DisplayFromStr " ) ]
/// An (explicitly UTC) datetime of when the VM was created
time_created : chrono ::DateTime < chrono ::Utc > , // should be a datetime
}
#[ lunanode_response ]
/// A response from [`crate::requests::ImageDetailRequest`]
pub struct ImageDetailResponse {
/// Details of a specific image.
details : ImageDetails ,
}
#[ lunanode_response ]
/// See also: [`crate::requests::ImageListRequest`]
pub struct ImageListResponse {
/// List of images and their information.
images : Vec < Image > ,
}
#[ lunanode_response ]
/// See also: [`crate::requests::BillingCreditRequest`]
pub struct BillingCreditResponse {
/// Money left in the account in USD
#[ serde_as(as= " DisplayFromStr " ) ]
credit : f32 ,
}
#[ lunanode_response ]
/// See also: [`crate::requests::VolumeListRequest`]
pub struct VolumeListResponse {
/// List of volumes and their associated information.
volumes : Vec < Volume > ,
}
#[ serde_as ]
#[ derive(Serialize, Deserialize, Debug) ]
/// A network with a subnet.
pub struct Network {
/// The name set by the user when creating the network.
name : String ,
#[ serde_as(as= " DisplayFromStr " ) ]
/// The ID of the network; this is useful if you'd like to modify it in another request.
net_id : i32 ,
/// The network subnet. This should be strictly typed as an IP address w/ a subnet attached. TODO: subnet type
subnet : String ,
}
#[ lunanode_response ]
/// A response from [`crate::requests::NetworkListRequest`]
pub struct NetworkListResponse {
/// A list of networks.
networks : Vec < Network > ,
}
#[ lunanode_response ]
/// A response from [`crate::requests::FloatingIpListRequest`]
pub struct FloatingIpListResponse {
/// A list of [`FloatingIp`]s.
ips : Vec < FloatingIp > ,
}
#[ serde_as ]
#[ derive(Serialize, Deserialize, Debug) ]
/// A domain "zone". This is the same as a root domain.
pub struct Zone {
#[ serde_as(as= " DisplayFromStr " ) ]
/// The lunanode id of the zone.
id : i32 ,
/// The domain (or subdomain) being managed by the zone.
name : String ,
/// The default TTL used for this zone. This can be overridden manually when specifying new records.
#[ serde_as(as= " DisplayFromStr " ) ]
ttl : i32 ,
}
#[ lunanode_response ]
/// A response from [`crate::requests::ZoneListRequest`]
pub struct ZoneListResponse {
/// A map of all zones, with their IDs as their keys.
zones : std ::collections ::HashMap < i32 , Zone > ,
}
#[ derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq, Hash, clap::ValueEnum) ]
#[ serde(rename= " UPPERCASE " ) ]
/// Possible record types for [`Record`]
pub enum RecordType {
/// An A record is an IPv4 pointer with a key (domain or subdomain) and value (IP address).
A ,
/// An AAAA record (usually said "quadrupal A") is an IPv6 pointer with a key (domain or subdomain) and
/// value (IP address).
AAAA ,
/// A CNAME record basically forwards requests from a domain or subdomain to a second domain or
/// subdomain. It is very common to see this in places where www.example.com and ftp.example.com
/// use the same server (and IP address) at example.com; now, when switching IP addresses, the address only
/// needs to be updated for example.com, and all the subdomains will still function like normal.
CNAME ,
/// An ALIAS record states that writing a domain one way, for example: ca.example.com, is the
/// same as another, for example: canada.example.com.
ALIAS ,
/// An MX record tells email providers where to send incoming mail.
MX ,
/// An NS record decides the nameserver record for the domain. This is necessary to use in the
/// case of Lunanode, since you cannot purchase a domain through them. You must purchase the
/// domain elsewhere, then set your NS records at your registrar to point to lunanode's
/// nameservers.
NS ,
/// A TXT record is a static record generally used for verification of some kind or another. Some
/// email providers (ProtonMail), will require you to set up a TXT record to prove that you own
/// the domain.
TXT ,
/// An SPF record is a deprecated form of email authentication record.
SPF ,
/// An SRV record can be used so that a port is not necessary when running multiple (similar or
/// the same) services on different ports. For example, suppose you run two web servers, one at
/// 80 and 443 (standard HTTP and HTTPS ports) and one on 8080 and 4443 (commonly used in live
/// updating prototypes. An SRV record can help you use a subdomain instead of a port number
/// at the end of the domain. So beta.example.com and www.example.com could point a browser to
/// different ports of the same IP.
SRV
}
#[ serde_as ]
#[ derive(Serialize, Deserialize, Debug) ]
/// A DNS record.
pub struct Record {
/// The record id
#[ serde_as(as= " DisplayFromStr " ) ]
id : i32 ,
/// The record type, one of A, AAAA, CNAME, ALIAS, MX, NS, TXT, SPF, SRV
#[ serde(rename= " type " ) ]
record_type : RecordType ,
/// The name of the record (for example, if setting an ip address for example.org, this field would show: example.org."
name : String ,
/// The data assigned to this record. It shoudl always be a IPv4/v6 address, unless it's an NS
data : String ,
#[ serde_as(as= " DisplayFromStr " ) ]
/// The auxiliary value, only used on some record types.
aux : i32 ,
#[ serde_as(as= " DisplayFromStr " ) ]
/// The TTL for the record.
ttl : i32 ,
/// Unknown value
policy : String ,
/// The region the record applies to, if specificed. Otherwise None. Currently a String due to type issues.
region : String ,
#[ serde(rename= " regiongroup " ) ]
/// This value can be any region group defined by the user or auto. This could be stricter.
region_group : String ,
/// This value can be either Canada or France, and it should be stricter.
country : String ,
/// The continent as set by the user for this record. May be none or auto.
continent : String ,
#[ serde_as(as= " DisplayFromStr " ) ]
/// Is the record for everywhere (global); this should be a bool
global : i32 ,
#[ serde_as(as= " DisplayFromStr " ) ]
/// The latitude of the record, if given.
latitude : f32 ,
#[ serde_as(as= " DisplayFromStr " ) ]
/// Longitude of a record, if given.
longitude : f32 ,
#[ serde(with= " external " ) ]
/// Is active in inactive record.
status : bool ,
#[ serde_as(as= " DisplayFromStr " ) ]
/// Monitor id, if given.
monitor_id : i32 ,
/// Optional check name?
check_name : Option < String > ,
/// The "nice" version of the status as a string.
status_nice : String ,
}
#[ lunanode_response ]
/// The result of requesting all DNS records for a domain.
/// See also: [`crate::requests::RecordListRequest`], [`ZoneListResponse`]
pub struct RecordListResponse {
records : std ::collections ::HashMap < i32 , Record > ,
}
#[ serde_as ]
#[ derive(Serialize, Deserialize, Debug) ]
/// A detailed dyn record.
pub struct DynRecord {
#[ serde_as(as= " DisplayFromStr " ) ]
/// An id you may need later to edit this.
/// See also: [`DynUpdateResponse`], [`DynRemoveResponse`]
id : i32 ,
/// The name, or key (usually a subddomain) of the dyn record.
name : String ,
/// An IP address (a value).
ip : IPAddress ,
}
#[ lunanode_response ]
/// The result of requesting all dyn records on a domain.
/// See also: [`crate::requests::DynListRequest`]
pub struct DynListResponse {
dyns : std ::collections ::HashMap < i32 , DynRecord > ,
}
#[ serde_as ]
#[ derive(Serialize, Deserialize, Debug) ]
/// Detailed information about an SSH key.
/// See also: [`SshKeyResponse`]
pub struct SshKey {
#[ serde_as(as= " DisplayFromStr " ) ]
id : i32 ,
/// Name of key, as specified by the user.
name : String ,
/// The value of the SSH key; this is not more strict, only because the value is meant to be literal and not a "structured" representation of an SSH key. In addition, this would take a lot of extra boilerplate.
value : String ,
}
#[ lunanode_response ]
/// The result of requesting a list of all regions.
/// See also: [`crate::requests::RegionListRequest`]
pub struct RegionListResponse {
/// A map of all regions supported by Lunanode.
regions : std ::collections ::HashMap < LNRegion , String > ,
}
#[ lunanode_response ]
/// The result of requesting all ssh keys connected to an account.
/// See also: [`crate::requests::SshKeyRequest`]
pub struct SshKeyResponse {
#[ serde(flatten) ]
/// List of keys stored in the LunaNode cloud. The String is just an index that I can't get to flatten :grumpy programmer noises:
keys : std ::collections ::HashMap < String , SshKey > ,
}
#[ lunanode_response ]
/// The reuslt of requesting email usage statistics from Lunanode.
pub struct EmailUsageResponse {
#[ serde_as(as= " DisplayFromStr " ) ]
/// The number of domains being used by the account.
domains : i32 ,
/// Usage of email in GB, this should be an i32.
storage : String ,
/// Usage of email in GB with GB appended to the end of the string,
storage_nice : String ,
#[ serde_as(as= " DisplayFromStr " ) ]
messages : i32 ,
}
#[ serde_as ]
#[ derive(Serialize, Deserialize, Debug) ]
/// The result of requesting an email's domain information.
pub struct EmailDomainInfo {
#[ serde_as(as= " DisplayFromStr " ) ]
/// An id for the domain's email info. This will be useful later if you want to change
/// information about how the email domain operates.
id : i32 ,
/// A String of the domain.
name : String ,
/// Storage used
storage : String ,
/// Storage used in MB/GB, with " MB/GB" attached.
storage_nice : String ,
}
#[ lunanode_response ]
/// The result of requesting a list of email domains on the Lunanode account.
pub struct EmailDomainListResponse {
#[ serde(flatten) ]
/// Key/value pairs where the key is a String of the domain.
domains : std ::collections ::HashMap < String , EmailDomainInfo > ,
}
#[ lunanode_response ]
/// The result of requesting all monitor checks (active or inactive).
/// See also: [`crate::requests::MonitorCheckListRequest`]
pub struct MonitorCheckListResponse {
/// This is not done yet. A Check type will be required. TODO
checks : Vec < String > ,
}
#[ derive(Serialize, Deserialize, Debug) ]
#[ serde(untagged) ]
/// The type of parameter being asked for by the monitor check.
/// See also: [`Param`]
pub enum ParamType {
/// A single, simple parameter.
Single ( String ) ,
/// Posssible options in the case of a fixed set of choices. Generally speaking, the key/value
/// Strings will be the same, unless the choice has a space or some other character that would
/// make it annoying to parse over an HTTP request.
Options ( std ::collections ::HashMap < String , String > ) ,
}
#[ derive(Serialize, Deserialize, Debug) ]
/// Detailed information about a parameter of a monitor check.
/// See also [`MonitorTypes`]
pub struct Param {
#[ serde(with= " external " ) ]
/// Is the parameter required when creating this monitor check.
required : bool ,
/// What kind of parameter is this.
r#type : ParamType ,
/// The name of the parameter, this would be the name of a field in a request.
name : String ,
/// A placeholder, or example of what may by used in this parameter.
placeholder : Option < String > ,
}
#[ derive(Serialize, Deserialize, Debug) ]
/// Detailed information about various monitor types in a category.
/// See also: [`MonitorCheckTypesResponse`]
pub struct MonitorTypes {
/// The name of the monitor type.
name : String ,
/// The short name of the monitor type.
short_name : String ,
/// A list of parameters for the given monitor type.
params : std ::collections ::HashMap < String , Param >
}
#[ lunanode_response ]
/// The result of asking for possible monitor check types.
/// See also: [`crate::requests::MonitorCheckTypesRequest`]
pub struct MonitorCheckTypesResponse {
/// All possible monitor check types as supported by Lunanode.
/// Note that the String key matches a category name, and all monitor types under that category
/// will be listed under each.
types : std ::collections ::HashMap < String , MonitorTypes > ,
}
#[ derive(Serialize, Deserialize, Debug) ]
#[ serde(rename_all= " lowercase " ) ]
/// The type of contact as stated by lunanode as possible options. This type helps decide how to
/// use the contact in the case of a monitor trip.
/// See also: [`Contact`]
pub enum ContactType {
/// A (presumably) valid email.
Email ,
/// A (presumably) valid SMS-captable phone or VOIP number.
Sms ,
/// A (presumably) valid voice-captable phone or VOIP number.
Voice ,
/// A (presumably) valid HTTP(S) URL.
Http ,
}
#[ serde_as ]
#[ derive(Serialize, Deserialize, Debug) ]
/// A contact for monitoring purposes.
/// See also: [`Contacts`], [`MonitorContactListResponse`]
pub struct Contact {
#[ serde_as(as= " DisplayFromStr " ) ]
id : i32 ,
r#type : ContactType ,
data : String ,
}
#[ derive(Serialize, Deserialize, Debug) ]
#[ serde(untagged) ]
/// Possible values for contacts listed in Lunanode. This is required because what the API sends
/// back an empty list when there are no contacts, but a hashmap if there is one or more contacts.
pub enum Contacts {
/// Need an empty vec of some kind to hold the blank value, which appears as [].
Empty ( Vec < String > ) ,
/// Note that this HashMap should be indexed by i32, not String. This is a limitation of serde as far as I can tell.
Populated ( std ::collections ::HashMap < String , Contact > ) ,
}
#[ lunanode_response ]
/// The result of requesting a contact list for monitoring purposes.
/// See also: [`crate::requests::MonitorContactListRequest`]
pub struct MonitorContactListResponse {
/// A list of contacts in your LunaNode account. This should be deserialized as Option<HashMap<String, Contact>>, but I haven't gotten around to serializing this in that way. TODO.
contacts : Contacts ,
}
#[ serde_as ]
#[ derive(Serialize, Deserialize, Debug) ]
/// An email user on the Lunanode email system.
pub struct EmailUser {
/// The user's ID.
#[ serde_as(as= " DisplayFromStr " ) ]
id : i32 ,
/// The user's email. This may be more strict in the future.
email : String ,
#[ serde_as(as= " DisplayFromStr " ) ]
/// The user's storage usage in MB.
storage : i32 ,
/// The user's storage usage, with an "MB" or "GB" designation afterwards.
storage_nice : String ,
}
#[ lunanode_response ]
/// The result of requesting a list of email users in a certain domain.
/// See also: [`crate::requests::EmailUserListRequest`]
pub struct EmailUserListResponse {
#[ serde(flatten) ]
/// The users of a domain's email. The String is an id (and should be an i32 TODO).
users : std ::collections ::HashMap < String , EmailUser > ,
}
#[ lunanode_response ]
/// The result of sending a start command to a VM.
/// See also: [`crate::requests::VmStartRequest`]
pub struct VmStartResponse { }
#[ lunanode_response ]
/// The result of sending a stop command to a VM.
/// See also: [`crate::requests::VmStopRequest`]
pub struct VmStopResponse { }
#[ lunanode_response ]
/// The result of sending a reboot command to a VM.
/// See also: [`crate::requests::VmRebootRequest`]
pub struct VmRebootResponse { }
#[ lunanode_response ]
/// The result of adding an email user to a domain.
/// See also: [`crate::requests::EmailUserAddRequest`]
pub struct EmailUserAddResponse { }
#[ lunanode_response ]
/// The result of removing an email user from a domain.
/// See also: [`crate::requests::EmailUserRemoveRequest`]
pub struct EmailUserRemoveResponse { }
#[ lunanode_response ]
/// The result of setting an email user's password in the specified domain.
/// See also: `EmailUserSetPasswordRequest`
pub struct EmailUserSetPasswordResponse { }
#[ serde_as ]
#[ derive(Serialize, Deserialize, Debug) ]
/// A VM-specific IP
pub struct VmIp {
floating : std ::net ::Ipv4Addr ,
/// A network UUID
network : String ,
#[ serde_as(as= " DisplayFromStr " ) ]
network_id : i32 ,
/// Port UUID? What is this?
port : String ,
/// This is an ip/subnet pair, so it could/should be stricter.
subnet : String ,
}
#[ lunanode_response ]
/// The result of querying for a list of ips in a specific VM.
/// See also: [`crate::requests::VmIpListRequest`]
pub struct VmIpListResponse {
ips : std ::collections ::HashMap < String , VmIp > ,
}
#[ lunanode_response ]
/// the result of removing a dynamic record.
/// See also: [`crate::requests::DynRemoveRequest`]
pub struct DynRemoveResponse { }
#[ lunanode_response ]
/// the result of adding a dynamic record.
/// See also: [`crate::requests::DynAddRequest`]
pub struct DynAddResponse { }
#[ lunanode_response ]
/// the result of adding a zone.
/// See also: [`crate::requests::ZoneAddRequest`]
pub struct ZoneAddResponse { }
#[ lunanode_response ]
/// the result of removing a zone.
/// See also: [`crate::requests::ZoneRemoveRequest`]
pub struct ZoneRemoveResponse { }
#[ lunanode_response ]
/// The result of adding a new record.
/// See also: [`crate::requests::RecordAddRequest`]
pub struct RecordAddResponse { }
#[ lunanode_response ]
/// The result of remove a DNS record.
/// See also: [`crate::requests::RecordRemoveRequest`]
pub struct RecordRemoveResponse { }
#[ lunanode_response ]
/// The result of remove a DNS record.
/// See also: [`crate::requests::RecordRemoveRequest`]
pub struct EmailDomainAddResponse { }
#[ lunanode_response ]
/// The result of remove a DNS record.
/// See also: [`crate::requests::RecordRemoveRequest`]
pub struct EmailDomainRemoveResponse { }
#[ serde_as ]
#[ derive(Serialize, Deserialize, Debug) ]
/// A single email alias
pub struct EmailAlias {
#[ serde_as(as= " DisplayFromStr " ) ]
/// email alias id for a given domain; this needs to be used in conjunction with a domain ID to do anything useful.
id : i32 ,
/// The source address of the email (blank for catch-all).
source : String ,
/// Where the final address is (this may be external).
destination : String ,
}
#[ lunanode_response ]
/// The result of listing email aliases.
/// See also: [`crate::requests::EmailAliasListRequest`]
pub struct EmailAliasListResponse {
#[ serde(flatten) ]
aliases : std ::collections ::HashMap < String , EmailAlias > ,
}
#[ lunanode_response ]
/// The result of adding a new email alias.
/// See also: [`crate::requests::EmailAliasListRequest`]
pub struct EmailAliasAddResponse { }
#[ lunanode_response ]
/// The result removing an email alias.
/// See also: [`crate::requests::EmailAliasListRequest`]
pub struct EmailAliasRemoveResponse { }