openstack_sdk 0.22.5

// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
//
// WARNING: This file is automatically generated from OpenAPI schema using
// `openstack-codegenerator`.

//! Creates a subnet on a network.
//!
//! OpenStack Networking does not try to derive the correct IP version from the
//! CIDR. If you do not specify the `gateway_ip` attribute, OpenStack
//! Networking allocates an address from the CIDR for the gateway for the
//! subnet.
//!
//! To specify a subnet without a gateway, set the `gateway_ip` attribute to
//! `null` in the request body. If you do not specify the `allocation_pools`
//! attribute, OpenStack Networking automatically allocates pools for covering
//! all IP addresses in the CIDR, excluding the address reserved for the subnet
//! gateway. Otherwise, you can explicitly specify allocation pools as shown in
//! the following example.
//!
//! When you specify both the `allocation_pools` and `gateway_ip` attributes,
//! you must ensure that the gateway IP does not overlap with the allocation
//! pools; otherwise, the call returns the `Conflict (409)` response code.
//!
//! A subnet can have one or more name servers and host routes. Hosts in this
//! subnet use the name servers. Devices with IP addresses from this subnet,
//! not including the local subnet route, use the host routes.
//!
//! Specify the `ipv6_ra_mode` and `ipv6_address_mode` attributes to create
//! subnets that support IPv6 configurations, such as stateless address
//! autoconfiguration (SLAAC), DHCPv6 stateful, and DHCPv6 stateless
//! configurations.
//!
//! A subnet can optionally be associated with a network segment when it is
//! created by specifying the `segment_id` of a valid segment on the specified
//! network. A network with subnets associated in this way is called a routed
//! network. On any given network, all of the subnets must be associated with
//! segments or none of them can be. Neutron enforces this invariant.
//! Currently, routed networks are only supported for provider networks.
//!
//! Normal response codes: 201
//!
//! Error response codes: 400, 401, 403, 404, 409
//!
use derive_builder::Builder;
use http::{HeaderMap, HeaderName, HeaderValue};

use crate::api::rest_endpoint_prelude::*;

use serde::Deserialize;
use serde::Serialize;
use std::borrow::Cow;

#[derive(Builder, Debug, Deserialize, Clone, Serialize)]
#[builder(setter(strip_option))]
pub struct AllocationPools<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(into))]
    pub(crate) end: Option<Cow<'a, str>>,

    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(into))]
    pub(crate) start: Option<Cow<'a, str>>,
}

#[derive(Builder, Debug, Deserialize, Clone, Serialize)]
#[builder(setter(strip_option))]
pub struct HostRoutes<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(into))]
    pub(crate) destination: Option<Cow<'a, str>>,

    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(into))]
    pub(crate) nexthop: Option<Cow<'a, str>>,
}

#[derive(Debug, Deserialize, Clone, Serialize)]
pub enum Ipv6AddressMode {
    #[serde(rename = "dhcpv6-stateful")]
    Dhcpv6Stateful,
    #[serde(rename = "dhcpv6-stateless")]
    Dhcpv6Stateless,
    #[serde(rename = "slaac")]
    Slaac,
}

#[derive(Debug, Deserialize, Clone, Serialize)]
pub enum Ipv6RaMode {
    #[serde(rename = "dhcpv6-stateful")]
    Dhcpv6Stateful,
    #[serde(rename = "dhcpv6-stateless")]
    Dhcpv6Stateless,
    #[serde(rename = "slaac")]
    Slaac,
}

/// A `subnet` object.
#[derive(Builder, Debug, Deserialize, Clone, Serialize)]
#[builder(setter(strip_option))]
pub struct Subnet<'a> {
    /// Allocation pools with `start` and `end` IP addresses for this subnet.
    /// If allocation_pools are not specified, OpenStack Networking
    /// automatically allocates pools for covering all IP addresses in the
    /// CIDR, excluding the address reserved for the subnet gateway by default.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(into))]
    pub(crate) allocation_pools: Option<Vec<AllocationPools<'a>>>,

    /// The CIDR of the subnet.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(into))]
    pub(crate) cidr: Option<Option<Cow<'a, str>>>,

    /// A human-readable description for the resource. Default is an empty
    /// string.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(into))]
    pub(crate) description: Option<Cow<'a, str>>,

    /// List of dns name servers associated with the subnet. Default is an
    /// empty list.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(into))]
    pub(crate) dns_nameservers: Option<Vec<Cow<'a, str>>>,

    /// Whether to publish DNS records for IPs from this subnet. Default is
    /// `false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(into))]
    pub(crate) dns_publish_fixed_ip: Option<bool>,

    /// Indicates whether dhcp is enabled or disabled for the subnet. Default
    /// is `true`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(into))]
    pub(crate) enable_dhcp: Option<bool>,

    /// Gateway IP of this subnet. If the value is `null` that implies no
    /// gateway is associated with the subnet. If the gateway_ip is not
    /// specified, OpenStack Networking allocates an address from the CIDR for
    /// the gateway for the subnet by default.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(into))]
    pub(crate) gateway_ip: Option<Option<Cow<'a, str>>>,

    /// Additional routes for the subnet. A list of dictionaries with
    /// `destination` and `nexthop` parameters. Default value is an empty list.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(into))]
    pub(crate) host_routes: Option<Vec<HostRoutes<'a>>>,

    /// The IP protocol version. Value is `4` or `6`.
    #[serde()]
    #[builder(setter(into))]
    pub(crate) ip_version: i32,

    /// The IPv6 address modes specifies mechanisms for assigning IP addresses.
    /// Value is `slaac`, `dhcpv6-stateful`, `dhcpv6-stateless`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub(crate) ipv6_address_mode: Option<Ipv6AddressMode>,

    /// The IPv6 router advertisement specifies whether the networking service
    /// should transmit ICMPv6 packets, for a subnet. Value is `slaac`,
    /// `dhcpv6-stateful`, `dhcpv6-stateless`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub(crate) ipv6_ra_mode: Option<Ipv6RaMode>,

    /// Human-readable name of the resource. Default is an empty string.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(into))]
    pub(crate) name: Option<Cow<'a, str>>,

    /// The ID of the network to which the subnet belongs.
    #[serde()]
    #[builder(setter(into))]
    pub(crate) network_id: Cow<'a, str>,

    /// The prefix length to use for subnet allocation from a subnet pool. If
    /// not specified, the `default_prefixlen` value of the subnet pool will be
    /// used.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(into))]
    pub(crate) prefixlen: Option<u32>,

    /// The ID of a network segment the subnet is associated with. It is
    /// available when `segment` extension is enabled.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(into))]
    pub(crate) segment_id: Option<Option<Cow<'a, str>>>,

    /// The service types associated with the subnet.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(into))]
    pub(crate) service_types: Option<Vec<Cow<'a, str>>>,

    /// The ID of the subnet pool associated with the subnet.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(into))]
    pub(crate) subnetpool_id: Option<Option<Cow<'a, str>>>,

    /// The ID of the project that owns the resource. Only administrative and
    /// users with advsvc role can specify a project ID other than their own.
    /// You cannot change this value through authorization policies.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(into))]
    pub(crate) tenant_id: Option<Cow<'a, str>>,

    /// Whether to allocate this subnet from the default subnet pool.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(into))]
    pub(crate) use_default_subnetpool: Option<bool>,
}

#[derive(Builder, Debug, Clone)]
#[builder(setter(strip_option))]
pub struct Request<'a> {
    /// A `subnet` object.
    #[builder(setter(into))]
    pub(crate) subnet: Subnet<'a>,

    #[builder(setter(name = "_headers"), default, private)]
    _headers: Option<HeaderMap>,
}
impl<'a> Request<'a> {
    /// Create a builder for the endpoint.
    pub fn builder() -> RequestBuilder<'a> {
        RequestBuilder::default()
    }
}

impl<'a> RequestBuilder<'a> {
    /// Add a single header to the Subnet.
    pub fn header<K, V>(&mut self, header_name: K, header_value: V) -> &mut Self
    where
        K: Into<HeaderName>,
        V: Into<HeaderValue>,
    {
        self._headers
            .get_or_insert(None)
            .get_or_insert_with(HeaderMap::new)
            .insert(header_name.into(), header_value.into());
        self
    }

    /// Add multiple headers.
    pub fn headers<I, T>(&mut self, iter: I) -> &mut Self
    where
        I: Iterator<Item = T>,
        T: Into<(Option<HeaderName>, HeaderValue)>,
    {
        self._headers
            .get_or_insert(None)
            .get_or_insert_with(HeaderMap::new)
            .extend(iter.map(Into::into));
        self
    }
}

impl RestEndpoint for Request<'_> {
    fn method(&self) -> http::Method {
        http::Method::POST
    }

    fn endpoint(&self) -> Cow<'static, str> {
        "subnets".to_string().into()
    }

    fn parameters(&self) -> QueryParams<'_> {
        QueryParams::default()
    }

    fn body(&self) -> Result<Option<(&'static str, Vec<u8>)>, BodyError> {
        let mut params = JsonBodyParams::default();

        params.push("subnet", serde_json::to_value(&self.subnet)?);

        params.into_body()
    }

    fn service_type(&self) -> ServiceType {
        ServiceType::Network
    }

    fn response_key(&self) -> Option<Cow<'static, str>> {
        Some("subnet".into())
    }

    /// Returns headers to be set into the request
    fn request_headers(&self) -> Option<&HeaderMap> {
        self._headers.as_ref()
    }

    /// Returns required API version
    fn api_version(&self) -> Option<ApiVersion> {
        Some(ApiVersion::new(2, 0))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[cfg(feature = "sync")]
    use crate::api::Query;
    use crate::test::client::FakeOpenStackClient;
    use crate::types::ServiceType;
    use http::{HeaderName, HeaderValue};
    use httpmock::MockServer;
    use serde_json::json;

    #[test]
    fn test_service_type() {
        assert_eq!(
            Request::builder()
                .subnet(
                    SubnetBuilder::default()
                        .ip_version(123)
                        .network_id("foo")
                        .build()
                        .unwrap()
                )
                .build()
                .unwrap()
                .service_type(),
            ServiceType::Network
        );
    }

    #[test]
    fn test_response_key() {
        assert_eq!(
            Request::builder()
                .subnet(
                    SubnetBuilder::default()
                        .ip_version(123)
                        .network_id("foo")
                        .build()
                        .unwrap()
                )
                .build()
                .unwrap()
                .response_key()
                .unwrap(),
            "subnet"
        );
    }

    #[cfg(feature = "sync")]
    #[test]
    fn endpoint() {
        let server = MockServer::start();
        let client = FakeOpenStackClient::new(server.base_url());
        let mock = server.mock(|when, then| {
            when.method(httpmock::Method::POST)
                .path("/subnets".to_string());

            then.status(200)
                .header("content-type", "application/json")
                .json_body(json!({ "subnet": {} }));
        });

        let endpoint = Request::builder()
            .subnet(
                SubnetBuilder::default()
                    .ip_version(123)
                    .network_id("foo")
                    .build()
                    .unwrap(),
            )
            .build()
            .unwrap();
        let _: serde_json::Value = endpoint.query(&client).unwrap();
        mock.assert();
    }

    #[cfg(feature = "sync")]
    #[test]
    fn endpoint_headers() {
        let server = MockServer::start();
        let client = FakeOpenStackClient::new(server.base_url());
        let mock = server.mock(|when, then| {
            when.method(httpmock::Method::POST)
                .path("/subnets".to_string())
                .header("foo", "bar")
                .header("not_foo", "not_bar");
            then.status(200)
                .header("content-type", "application/json")
                .json_body(json!({ "subnet": {} }));
        });

        let endpoint = Request::builder()
            .subnet(
                SubnetBuilder::default()
                    .ip_version(123)
                    .network_id("foo")
                    .build()
                    .unwrap(),
            )
            .headers(
                [(
                    Some(HeaderName::from_static("foo")),
                    HeaderValue::from_static("bar"),
                )]
                .into_iter(),
            )
            .header(
                HeaderName::from_static("not_foo"),
                HeaderValue::from_static("not_bar"),
            )
            .build()
            .unwrap();
        let _: serde_json::Value = endpoint.query(&client).unwrap();
        mock.assert();
    }
}