Add range allocate

Author: lgarber-akamai

linode_api4/groups/networking.py

@@ -180,6 +180,64 @@ def ipv6_ranges(self, *filters):
         """
         return self.client._get_and_filter(IPv6Range, *filters)
 
+    def ipv6_range_allocate(
+        self,
+        prefix_length: int,
+        route_target: Optional[str] = None,
+        linode: Optional[Union[Instance, int]] = None,
+        **kwargs,
+    ) -> IPv6Range:
+        """
+        Creates an IPv6 Range and assigns it based on the provided Linode or route target IPv6 SLAAC address.
+
+        API Documentation: https://techdocs.akamai.com/linode-api/reference/post-ipv6-range
+
+        Create an IPv6 range assigned to a Linode by ID::
+
+            range = client.networking.ipv6_range_allocate(64, linode_id=123)
+
+
+        Create an IPv6 range assigned to a Linode by SLAAC::
+
+            range = client.networking.ipv6_range_allocate(
+                64,
+                route_target=instance.ipv6.split("/")[0]
+            )
+
+        :param prefix_length: The prefix length of the IPv6 range.
+        :type prefix_length: int
+        :param route_target: The IPv6 SLAAC address to assign this range to. Required if linode is not specified.
+        :type route_target: str
+        :param linode: The ID of the Linode to assign this range to.
+                       The SLAAC address for the provided Linode is used as the range's route_target.
+                       Required if linode is not specified.
+        :type linode: Instance or int
+
+        :returns: The new IPAddress.
+        :rtype: IPAddress
+        """
+
+        params = {
+            "prefix_length": prefix_length,
+            "route_target": route_target,
+            "linode_id": linode,
+        }
+
+        params.update(**kwargs)
+
+        result = self.client.post(
+            "/networking/ipv6/ranges",
+            data=drop_null_keys(_flatten_request_body_recursive(params)),
+        )
+
+        if not "range" in result:
+            raise UnexpectedResponseError(
+                "Unexpected response when allocating IPv6 range!", json=result
+            )
+
+        result = IPv6Range(self.client, result["address"], result)
+        return result
+
     def ipv6_pools(self, *filters):
         """
         Returns a list of IPv6 pools on this account.

test/integration/models/linode/interfaces/test_interfaces.py

@@ -1,4 +1,5 @@
 import ipaddress
+from test.integration.conftest import get_region
 from test.integration.helpers import get_test_label
 
 import pytest
@@ -9,20 +10,44 @@
     LinodeInterface,
     LinodeInterfaceDefaultRouteOptions,
     LinodeInterfaceOptions,
+    LinodeInterfacePublicIPv4AddressOptions,
+    LinodeInterfacePublicIPv4Options,
+    LinodeInterfacePublicIPv6Options,
+    LinodeInterfacePublicIPv6RangeOptions,
     LinodeInterfacePublicOptions,
     LinodeInterfaceVLANOptions,
     LinodeInterfaceVPCOptions,
 )
 
 
+@pytest.fixture(scope="function")
+def instance_with_interface_generation_linode(
+    test_linode_client, e2e_test_firewall
+):
+    client = test_linode_client
+
+    label = get_test_label()
+
+    instance, _ = client.linode.instance_create(
+        "g6-nanode-1",
+        get_region(test_linode_client, {"Linode Interfaces"}, site_type="core"),
+        label=label,
+        interface_generation=InterfaceGeneration.LINODE,
+    )
+
+    yield instance
+
+    instance.delete()
+
+
 @pytest.fixture(scope="session")
-def linode_create_with_interfaces(
+def instance_with_interfaces(
     test_linode_client, e2e_test_firewall, create_vpc_with_subnet
 ):
     client = test_linode_client
     vpc, subnet = create_vpc_with_subnet
 
-    # Are there regions where VPCs are supported but Linode Interfaces aren't
+    # Are there regions where VPCs are supported but Linode Interfaces aren't?
     region = vpc.region
     label = get_test_label()
 
@@ -61,9 +86,9 @@ def linode_create_with_interfaces(
 
 def test_linode_create_with_linode_interfaces(
     create_vpc_with_subnet,
-    linode_create_with_interfaces,
+    instance_with_interfaces,
 ):
-    instance: Instance = linode_create_with_interfaces
+    instance: Instance = instance_with_interfaces
     vpc, subnet = create_vpc_with_subnet
 
     def __assert_base(iface: LinodeInterface):
@@ -126,3 +151,55 @@ def __assert_vlan(iface: LinodeInterface):
     __assert_public(instance.interfaces[0])
     __assert_vpc(instance.interfaces[1])
     __assert_vlan(instance.interfaces[2])
+
+
+def test_linode_interface_create_public(
+    e2e_test_firewall,
+    instance_with_interface_generation_linode,
+):
+    instance: Instance = instance_with_interface_generation_linode
+
+    ip = instance.ip_allocate()
+    instance
+
+    iface = instance.interface_create(
+        firewall_id=e2e_test_firewall.id,
+        default_route=LinodeInterfaceDefaultRouteOptions(
+            ipv4=True,
+            ipv6=True,
+        ),
+        public=LinodeInterfacePublicOptions(
+            ipv4=LinodeInterfacePublicIPv4Options(
+                addresses=[
+                    LinodeInterfacePublicIPv4AddressOptions(
+                        address=ip.address,
+                        primary=True,
+                    )
+                ]
+            ),
+            ipv6=LinodeInterfacePublicIPv6Options(
+                ranges=[LinodeInterfacePublicIPv6RangeOptions()]
+            ),
+        ),
+    )
+
+    assert iface.id is not None
+    assert iface.linode_id == instance.id
+
+    assert iface.created is not None
+    assert iface.updated is not None
+
+    assert isinstance(iface.mac_address, str)
+    assert iface.version
+
+    assert iface.default_route.ipv4
+    assert iface.default_route.ipv6
+
+    assert iface.public.ipv4.addresses[0].address == ip.address
+    assert iface.public.ipv4.addresses[0].primary
+    assert len(iface.public.ipv4.shared) == 0
+
+    assert iface.public.ipv6.slaac[0].address == instance.ipv6.split("/")[0]
+    assert iface.public.ipv6.slaac[0].prefix == 64
+    assert len(iface.public.ipv6.shared) == 0
+    assert len(iface.public.ipv6.ranges) == 0