#[derive(Debug, Clone)]
pub struct StartClient<T> {
client: T,
path: String,
}
impl<T> StartClient<T>
where
T: crate::client::Client,
{
pub fn new(client: T, parent_path: &str) -> Self {
Self {
client,
path: format!("{}{}", parent_path, "/start"),
}
}
}
impl<T> StartClient<T>
where
T: crate::client::Client,
{
#[doc = "Start virtual machine."]
#[doc = ""]
#[doc = "Permission check: perm(\"/vms/{vmid}\", [\"VM.PowerMgmt\"])"]
pub async fn post(&self, params: PostParams) -> Result<String, T::Error> {
let path = self.path.to_string();
self.client.post(&path, ¶ms).await
}
}
#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, Default)]
pub struct PostParams {
#[serde(rename = "force-cpu")]
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Override QEMU's -cpu argument with the given string."]
#[doc = ""]
pub force_cpu: Option<String>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Specify the QEMU machine."]
#[doc = ""]
pub machine: Option<String>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "The cluster node name."]
#[doc = ""]
pub migratedfrom: Option<String>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "CIDR of the (sub) network that is used for migration."]
#[doc = ""]
pub migration_network: Option<String>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Migration traffic is encrypted using an SSH tunnel by default. On secure, completely private networks this can be disabled to increase performance."]
#[doc = ""]
pub migration_type: Option<MigrationType>,
#[serde(rename = "nets-host-mtu")]
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Used for migration compat. List of VirtIO network devices and their effective host_mtu setting according to the QEMU object model on the source side of the migration. A value of 0 means that the host_mtu parameter is to be avoided for the corresponding device."]
#[doc = ""]
pub nets_host_mtu: Option<NetsHostMtuStr>,
#[serde(
serialize_with = "crate::types::serialize_bool_optional",
deserialize_with = "crate::types::deserialize_bool_optional"
)]
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Ignore locks - only root is allowed to use this option."]
#[doc = ""]
pub skiplock: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Some command save/restore state from this location."]
#[doc = ""]
pub stateuri: Option<StateuriStr>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Mapping from source to target storages. Providing only a single storage ID maps all source storages to that storage. Providing the special value '1' will map each source storage to itself."]
#[doc = ""]
pub targetstorage: Option<String>,
#[serde(
serialize_with = "crate::types::serialize_unsigned_int_optional",
deserialize_with = "crate::types::deserialize_unsigned_int_optional"
)]
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Wait maximal timeout seconds."]
#[doc = ""]
pub timeout: Option<u64>,
#[serde(rename = "with-conntrack-state")]
#[serde(
serialize_with = "crate::types::serialize_bool_optional",
deserialize_with = "crate::types::deserialize_bool_optional"
)]
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Whether to migrate conntrack entries for running VMs."]
#[doc = ""]
pub with_conntrack_state: Option<bool>,
#[serde(
flatten,
default,
skip_serializing_if = "::std::collections::HashMap::is_empty"
)]
pub additional_properties: ::std::collections::HashMap<String, ::serde_json::Value>,
}
#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
#[doc = "Migration traffic is encrypted using an SSH tunnel by default. On secure, completely private networks this can be disabled to increase performance."]
#[doc = ""]
pub enum MigrationType {
#[serde(rename = "insecure")]
Insecure,
#[serde(rename = "secure")]
Secure,
}
impl TryFrom<&str> for MigrationType {
type Error = String;
fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
match value {
"insecure" => Ok(Self::Insecure),
"secure" => Ok(Self::Secure),
v => Err(format!("Unknown variant {v}")),
}
}
}
#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct NetsHostMtuStr {
value: String,
}
impl crate::types::bounded_string::BoundedString for NetsHostMtuStr {
const MIN_LENGTH: Option<usize> = None::<usize>;
const MAX_LENGTH: Option<usize> = None::<usize>;
const DEFAULT: Option<&'static str> = None::<&'static str>;
const PATTERN: Option<&'static str> = Some("net\\d+=\\d+(,net\\d+=\\d+)*");
const TYPE_DESCRIPTION: &'static str =
"a string with pattern r\"net\\d+=\\d+(,net\\d+=\\d+)*\" and no length constraints";
fn get_value(&self) -> &str {
&self.value
}
fn new(value: String) -> Result<Self, crate::types::bounded_string::BoundedStringError> {
Self::validate(&value)?;
Ok(Self { value })
}
}
impl std::convert::TryFrom<String> for NetsHostMtuStr {
type Error = crate::types::bounded_string::BoundedStringError;
fn try_from(value: String) -> Result<Self, Self::Error> {
crate::types::bounded_string::BoundedString::new(value)
}
}
impl ::serde::Serialize for NetsHostMtuStr {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: ::serde::Serializer,
{
crate::types::bounded_string::serialize_bounded_string(self, serializer)
}
}
impl<'de> ::serde::Deserialize<'de> for NetsHostMtuStr {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: ::serde::Deserializer<'de>,
{
crate::types::bounded_string::deserialize_bounded_string(deserializer)
}
}
#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct StateuriStr {
value: String,
}
impl crate::types::bounded_string::BoundedString for StateuriStr {
const MIN_LENGTH: Option<usize> = None::<usize>;
const MAX_LENGTH: Option<usize> = Some(128usize);
const DEFAULT: Option<&'static str> = None::<&'static str>;
const PATTERN: Option<&'static str> = None::<&'static str>;
const TYPE_DESCRIPTION: &'static str = "a string with length at most 128";
fn get_value(&self) -> &str {
&self.value
}
fn new(value: String) -> Result<Self, crate::types::bounded_string::BoundedStringError> {
Self::validate(&value)?;
Ok(Self { value })
}
}
impl std::convert::TryFrom<String> for StateuriStr {
type Error = crate::types::bounded_string::BoundedStringError;
fn try_from(value: String) -> Result<Self, Self::Error> {
crate::types::bounded_string::BoundedString::new(value)
}
}
impl ::serde::Serialize for StateuriStr {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: ::serde::Serializer,
{
crate::types::bounded_string::serialize_bounded_string(self, serializer)
}
}
impl<'de> ::serde::Deserialize<'de> for StateuriStr {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: ::serde::Deserializer<'de>,
{
crate::types::bounded_string::deserialize_bounded_string(deserializer)
}
}