Struct cni_plugin::ip_range::IpRange

pub struct IpRange {
    pub subnet: IpNetwork,
    pub range_start: Option<IpAddr>,
    pub range_end: Option<IpAddr>,
    pub gateway: Option<IpAddr>,
}

A range of IPs, usable for defining an IP pool.

The subnet is the only required field. The range can be further limited with the range_start and range_end fields, which are inclusive.

Examples

{"subnet": "10.0.0.0/8"}
{"subnet": "10.0.10.0/23", "rangeStart": "10.0.11.0", "rangeEnd": "10.0.11.254"}
{"subnet": "192.168.1.1/24", "gateway": "192.168.1.254"}

Fields

subnet: IpNetwork

The subnet for the range.

range_start: Option<IpAddr>

The start of the available range within the subnet, inclusive.

range_end: Option<IpAddr>

The end of the available range within the subnet, inclusive.

gateway: Option<IpAddr>

The gateway of the range.

Interpretation of an absent gateway is left to the implementation.

Implementations

impl IpRange

pub fn iter_free(&self) -> impl Iterator<Item = (IpNetwork, &Self)>

Naive implementation of iterating the IP range.

This iterator will yield every IP available in the range, that is, every IP in the subnet, except those lower than range_start, higher than range_end, or the one which is the gateway.

The current implementation iterates through the entire range and filters off the excluded IPs as per above. For IPv4 this will likely never be an issue but IPv6 ranges are monstrous and could spend a long time spinning before reaching range_start.

Trait Implementations

impl Clone for IpRange

fn clone(&self) -> IpRange

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for IpRange

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IpRange

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for IpRange

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.