#[derive(Debug, Clone)]
pub struct IfaceClient<T> {
client: T,
path: String,
}
impl<T> IfaceClient<T>
where
T: crate::client::Client,
{
pub fn new(client: T, parent_path: &str, iface: &str) -> Self {
Self {
client,
path: format!("{}/{}", parent_path, iface),
}
}
}
impl<T> IfaceClient<T>
where
T: crate::client::Client,
{
#[doc = "Delete network device configuration"]
#[doc = ""]
#[doc = "Permission check: perm(\"/nodes/{node}\", [\"Sys.Modify\"])"]
pub async fn delete(&self) -> Result<(), T::Error> {
let path = self.path.to_string();
self.client.delete(&path, &()).await
}
}
impl<T> IfaceClient<T>
where
T: crate::client::Client,
{
#[doc = "Read network device configuration"]
#[doc = ""]
#[doc = "Permission check: perm(\"/nodes/{node}\", [\"Sys.Audit\"])"]
pub async fn get(&self) -> Result<GetOutput, T::Error> {
let path = self.path.to_string();
self.client.get(&path, &()).await
}
}
impl<T> IfaceClient<T>
where
T: crate::client::Client,
{
#[doc = "Update network device configuration"]
#[doc = ""]
#[doc = "Permission check: perm(\"/nodes/{node}\", [\"Sys.Modify\"])"]
pub async fn put(&self, params: PutParams) -> Result<(), T::Error> {
let path = self.path.to_string();
self.client.put(&path, ¶ms).await
}
}
impl GetOutput {
pub fn new(method: String, ty: String) -> Self {
Self {
method,
ty,
additional_properties: ::std::default::Default::default(),
}
}
}
#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize)]
pub struct GetOutput {
pub method: String,
#[serde(rename = "type")]
pub ty: String,
#[serde(
flatten,
default,
skip_serializing_if = "::std::collections::HashMap::is_empty"
)]
pub additional_properties: ::std::collections::HashMap<String, ::serde_json::Value>,
}
impl PutParams {
pub fn new(ty: Type) -> Self {
Self {
ty,
address: ::std::default::Default::default(),
address6: ::std::default::Default::default(),
autostart: ::std::default::Default::default(),
bond_primary: ::std::default::Default::default(),
bond_mode: ::std::default::Default::default(),
bond_xmit_hash_policy: ::std::default::Default::default(),
bridge_ports: ::std::default::Default::default(),
bridge_vids: ::std::default::Default::default(),
bridge_vlan_aware: ::std::default::Default::default(),
cidr: ::std::default::Default::default(),
cidr6: ::std::default::Default::default(),
comments: ::std::default::Default::default(),
comments6: ::std::default::Default::default(),
delete: ::std::default::Default::default(),
gateway: ::std::default::Default::default(),
gateway6: ::std::default::Default::default(),
mtu: ::std::default::Default::default(),
netmask: ::std::default::Default::default(),
netmask6: ::std::default::Default::default(),
ovs_bonds: ::std::default::Default::default(),
ovs_bridge: ::std::default::Default::default(),
ovs_options: ::std::default::Default::default(),
ovs_ports: ::std::default::Default::default(),
ovs_tag: ::std::default::Default::default(),
slaves: ::std::default::Default::default(),
vlan_id: ::std::default::Default::default(),
vlan_raw_device: ::std::default::Default::default(),
additional_properties: ::std::default::Default::default(),
}
}
}
#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize)]
pub struct PutParams {
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "IP address."]
#[doc = ""]
pub address: Option<::std::net::Ipv4Addr>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "IP address."]
#[doc = ""]
pub address6: Option<::std::net::Ipv6Addr>,
#[serde(
serialize_with = "crate::types::serialize_bool_optional",
deserialize_with = "crate::types::deserialize_bool_optional"
)]
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Automatically start interface on boot."]
#[doc = ""]
pub autostart: Option<bool>,
#[serde(rename = "bond-primary")]
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Specify the primary interface for active-backup bond."]
#[doc = ""]
pub bond_primary: Option<String>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Bonding mode."]
#[doc = ""]
pub bond_mode: Option<BondMode>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Selects the transmit hash policy to use for slave selection in balance-xor and 802.3ad modes."]
#[doc = ""]
pub bond_xmit_hash_policy: Option<BondXmitHashPolicy>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Specify the interfaces you want to add to your bridge."]
#[doc = ""]
pub bridge_ports: Option<String>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Specify the allowed VLANs. For example: '2 4 100-200'. Only used if the bridge is VLAN aware."]
#[doc = ""]
pub bridge_vids: Option<String>,
#[serde(
serialize_with = "crate::types::serialize_bool_optional",
deserialize_with = "crate::types::deserialize_bool_optional"
)]
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Enable bridge vlan support."]
#[doc = ""]
pub bridge_vlan_aware: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "IPv4 CIDR."]
#[doc = ""]
pub cidr: Option<String>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "IPv6 CIDR."]
#[doc = ""]
pub cidr6: Option<String>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Comments"]
#[doc = ""]
pub comments: Option<String>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Comments"]
#[doc = ""]
pub comments6: Option<String>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "A list of settings you want to delete."]
#[doc = ""]
pub delete: Option<String>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Default gateway address."]
#[doc = ""]
pub gateway: Option<::std::net::Ipv4Addr>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Default ipv6 gateway address."]
#[doc = ""]
pub gateway6: Option<::std::net::Ipv6Addr>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "MTU."]
#[doc = ""]
pub mtu: Option<MtuInt>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Network mask."]
#[doc = ""]
pub netmask: Option<String>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Network mask."]
#[doc = ""]
pub netmask6: Option<Netmask6Int>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Specify the interfaces used by the bonding device."]
#[doc = ""]
pub ovs_bonds: Option<String>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "The OVS bridge associated with a OVS port. This is required when you create an OVS port."]
#[doc = ""]
pub ovs_bridge: Option<String>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "OVS interface options."]
#[doc = ""]
pub ovs_options: Option<OvsOptionsStr>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Specify the interfaces you want to add to your bridge."]
#[doc = ""]
pub ovs_ports: Option<String>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Specify a VLan tag (used by OVSPort, OVSIntPort, OVSBond)"]
#[doc = ""]
pub ovs_tag: Option<OvsTagInt>,
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Specify the interfaces used by the bonding device."]
#[doc = ""]
pub slaves: Option<String>,
#[serde(rename = "type")]
#[doc = "Network interface type"]
#[doc = ""]
pub ty: Type,
#[serde(rename = "vlan-id")]
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "vlan-id for a custom named vlan interface (ifupdown2 only)."]
#[doc = ""]
pub vlan_id: Option<VlanIdInt>,
#[serde(rename = "vlan-raw-device")]
#[serde(skip_serializing_if = "Option::is_none", default)]
#[doc = "Specify the raw interface for the vlan interface."]
#[doc = ""]
pub vlan_raw_device: Option<String>,
#[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 = "Bonding mode."]
#[doc = ""]
pub enum BondMode {
#[serde(rename = "802.3ad")]
_8023ad,
#[serde(rename = "active-backup")]
ActiveBackup,
#[serde(rename = "balance-alb")]
BalanceAlb,
#[serde(rename = "balance-rr")]
BalanceRr,
#[serde(rename = "balance-slb")]
BalanceSlb,
#[serde(rename = "balance-tlb")]
BalanceTlb,
#[serde(rename = "balance-xor")]
BalanceXor,
#[serde(rename = "broadcast")]
Broadcast,
#[serde(rename = "lacp-balance-slb")]
LacpBalanceSlb,
#[serde(rename = "lacp-balance-tcp")]
LacpBalanceTcp,
}
impl TryFrom<&str> for BondMode {
type Error = String;
fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
match value {
"802.3ad" => Ok(Self::_8023ad),
"active-backup" => Ok(Self::ActiveBackup),
"balance-alb" => Ok(Self::BalanceAlb),
"balance-rr" => Ok(Self::BalanceRr),
"balance-slb" => Ok(Self::BalanceSlb),
"balance-tlb" => Ok(Self::BalanceTlb),
"balance-xor" => Ok(Self::BalanceXor),
"broadcast" => Ok(Self::Broadcast),
"lacp-balance-slb" => Ok(Self::LacpBalanceSlb),
"lacp-balance-tcp" => Ok(Self::LacpBalanceTcp),
v => Err(format!("Unknown variant {v}")),
}
}
}
#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
#[doc = "Selects the transmit hash policy to use for slave selection in balance-xor and 802.3ad modes."]
#[doc = ""]
pub enum BondXmitHashPolicy {
#[serde(rename = "layer2")]
Layer2,
#[serde(rename = "layer2+3")]
Layer23,
#[serde(rename = "layer3+4")]
Layer34,
}
impl TryFrom<&str> for BondXmitHashPolicy {
type Error = String;
fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
match value {
"layer2" => Ok(Self::Layer2),
"layer2+3" => Ok(Self::Layer23),
"layer3+4" => Ok(Self::Layer34),
v => Err(format!("Unknown variant {v}")),
}
}
}
#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
#[doc = "Network interface type"]
#[doc = ""]
pub enum Type {
OVSBond,
OVSBridge,
OVSIntPort,
OVSPort,
#[serde(rename = "alias")]
Alias,
#[serde(rename = "bond")]
Bond,
#[serde(rename = "bridge")]
Bridge,
#[serde(rename = "eth")]
Eth,
#[serde(rename = "fabric")]
Fabric,
#[serde(rename = "unknown")]
Unknown,
#[serde(rename = "vlan")]
Vlan,
#[serde(rename = "vnet")]
Vnet,
}
impl TryFrom<&str> for Type {
type Error = String;
fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
match value {
"OVSBond" => Ok(Self::OVSBond),
"OVSBridge" => Ok(Self::OVSBridge),
"OVSIntPort" => Ok(Self::OVSIntPort),
"OVSPort" => Ok(Self::OVSPort),
"alias" => Ok(Self::Alias),
"bond" => Ok(Self::Bond),
"bridge" => Ok(Self::Bridge),
"eth" => Ok(Self::Eth),
"fabric" => Ok(Self::Fabric),
"unknown" => Ok(Self::Unknown),
"vlan" => Ok(Self::Vlan),
"vnet" => Ok(Self::Vnet),
v => Err(format!("Unknown variant {v}")),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub struct MtuInt(i128);
impl crate::types::bounded_integer::BoundedInteger for MtuInt {
const MIN: Option<i128> = Some(1280i128);
const MAX: Option<i128> = Some(65520i128);
const DEFAULT: Option<i128> = None::<i128>;
const TYPE_DESCRIPTION: &'static str = "an integer between 1280 and 65520";
fn get(&self) -> i128 {
self.0
}
fn new(value: i128) -> Result<Self, crate::types::bounded_integer::BoundedIntegerError> {
Self::validate(value)?;
Ok(Self(value))
}
}
impl std::convert::TryFrom<i128> for MtuInt {
type Error = crate::types::bounded_integer::BoundedIntegerError;
fn try_from(value: i128) -> Result<Self, Self::Error> {
crate::types::bounded_integer::BoundedInteger::new(value)
}
}
impl ::serde::Serialize for MtuInt {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: ::serde::Serializer,
{
crate::types::bounded_integer::serialize_bounded_integer(self, serializer)
}
}
impl<'de> ::serde::Deserialize<'de> for MtuInt {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: ::serde::Deserializer<'de>,
{
crate::types::bounded_integer::deserialize_bounded_integer(deserializer)
}
}
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub struct Netmask6Int(i128);
impl crate::types::bounded_integer::BoundedInteger for Netmask6Int {
const MIN: Option<i128> = Some(0i128);
const MAX: Option<i128> = Some(128i128);
const DEFAULT: Option<i128> = None::<i128>;
const TYPE_DESCRIPTION: &'static str = "an integer between 0 and 128";
fn get(&self) -> i128 {
self.0
}
fn new(value: i128) -> Result<Self, crate::types::bounded_integer::BoundedIntegerError> {
Self::validate(value)?;
Ok(Self(value))
}
}
impl std::convert::TryFrom<i128> for Netmask6Int {
type Error = crate::types::bounded_integer::BoundedIntegerError;
fn try_from(value: i128) -> Result<Self, Self::Error> {
crate::types::bounded_integer::BoundedInteger::new(value)
}
}
impl ::serde::Serialize for Netmask6Int {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: ::serde::Serializer,
{
crate::types::bounded_integer::serialize_bounded_integer(self, serializer)
}
}
impl<'de> ::serde::Deserialize<'de> for Netmask6Int {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: ::serde::Deserializer<'de>,
{
crate::types::bounded_integer::deserialize_bounded_integer(deserializer)
}
}
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub struct OvsTagInt(i128);
impl crate::types::bounded_integer::BoundedInteger for OvsTagInt {
const MIN: Option<i128> = Some(1i128);
const MAX: Option<i128> = Some(4094i128);
const DEFAULT: Option<i128> = None::<i128>;
const TYPE_DESCRIPTION: &'static str = "an integer between 1 and 4094";
fn get(&self) -> i128 {
self.0
}
fn new(value: i128) -> Result<Self, crate::types::bounded_integer::BoundedIntegerError> {
Self::validate(value)?;
Ok(Self(value))
}
}
impl std::convert::TryFrom<i128> for OvsTagInt {
type Error = crate::types::bounded_integer::BoundedIntegerError;
fn try_from(value: i128) -> Result<Self, Self::Error> {
crate::types::bounded_integer::BoundedInteger::new(value)
}
}
impl ::serde::Serialize for OvsTagInt {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: ::serde::Serializer,
{
crate::types::bounded_integer::serialize_bounded_integer(self, serializer)
}
}
impl<'de> ::serde::Deserialize<'de> for OvsTagInt {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: ::serde::Deserializer<'de>,
{
crate::types::bounded_integer::deserialize_bounded_integer(deserializer)
}
}
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub struct VlanIdInt(i128);
impl crate::types::bounded_integer::BoundedInteger for VlanIdInt {
const MIN: Option<i128> = Some(1i128);
const MAX: Option<i128> = Some(4094i128);
const DEFAULT: Option<i128> = None::<i128>;
const TYPE_DESCRIPTION: &'static str = "an integer between 1 and 4094";
fn get(&self) -> i128 {
self.0
}
fn new(value: i128) -> Result<Self, crate::types::bounded_integer::BoundedIntegerError> {
Self::validate(value)?;
Ok(Self(value))
}
}
impl std::convert::TryFrom<i128> for VlanIdInt {
type Error = crate::types::bounded_integer::BoundedIntegerError;
fn try_from(value: i128) -> Result<Self, Self::Error> {
crate::types::bounded_integer::BoundedInteger::new(value)
}
}
impl ::serde::Serialize for VlanIdInt {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: ::serde::Serializer,
{
crate::types::bounded_integer::serialize_bounded_integer(self, serializer)
}
}
impl<'de> ::serde::Deserialize<'de> for VlanIdInt {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: ::serde::Deserializer<'de>,
{
crate::types::bounded_integer::deserialize_bounded_integer(deserializer)
}
}
#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct OvsOptionsStr {
value: String,
}
impl crate::types::bounded_string::BoundedString for OvsOptionsStr {
const MIN_LENGTH: Option<usize> = None::<usize>;
const MAX_LENGTH: Option<usize> = Some(1024usize);
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 1024";
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 OvsOptionsStr {
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 OvsOptionsStr {
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 OvsOptionsStr {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: ::serde::Deserializer<'de>,
{
crate::types::bounded_string::deserialize_bounded_string(deserializer)
}
}