Merge branch 'dev' into TPT-3447-obj-gen2

Author: ezilber-akamai

.github/workflows/publish-pypi.yaml

@@ -24,6 +24,6 @@ jobs:
           LINODE_SDK_VERSION: ${{ github.event.release.tag_name }}
 
       - name: Publish the release artifacts to PyPI
-        uses: pypa/gh-action-pypi-publish@67339c736fd9354cd4f8cb0b744f2b82a74b5c70 # pin@release/v1.12.3
+        uses: pypa/gh-action-pypi-publish@76f52bc884231f62b9a034ebfe128415bbaabdfc # pin@release/v1.12.4
         with:
           password: ${{ secrets.PYPI_API_TOKEN }}

linode_api4/groups/lke.py

@@ -66,6 +66,7 @@ def cluster_create(
         control_plane: Union[
             LKEClusterControlPlaneOptions, Dict[str, Any]
         ] = None,
+        apl_enabled: bool = False,
         **kwargs,
     ):
         """
@@ -100,8 +101,12 @@ def cluster_create(
                           formatted dicts.
         :param kube_version: The version of Kubernetes to use
         :type kube_version: KubeVersion or str
-        :param control_plane: Dict[str, Any] or LKEClusterControlPlaneRequest
-        :type control_plane: The control plane configuration of this LKE cluster.
+        :param control_plane: The control plane configuration of this LKE cluster.
+        :type control_plane: Dict[str, Any] or LKEClusterControlPlaneRequest
+        :param apl_enabled: Whether this cluster should use APL.
+                            NOTE: This endpoint is in beta and may only
+                            function if base_url is set to `https://api.linode.com/v4beta`.
+        :type apl_enabled: bool
         :param kwargs: Any other arguments to pass along to the API.  See the API
                        docs for possible values.
 
@@ -120,6 +125,10 @@ def cluster_create(
         }
         params.update(kwargs)
 
+        # Prevent errors for users without access to APL
+        if apl_enabled:
+            params["apl_enabled"] = apl_enabled
+
         result = self.client.post(
             "/lke/clusters",
             data=_flatten_request_body_recursive(drop_null_keys(params)),

linode_api4/groups/networking.py

@@ -367,3 +367,30 @@ def transfer_prices(self, *filters):
         return self.client._get_and_filter(
             NetworkTransferPrice, *filters, endpoint="/network-transfer/prices"
         )
+
+    def delete_vlan(self, vlan, region):
+        """
+        This operation deletes a VLAN.
+        You can't delete a VLAN if it's still attached to a Linode.
+
+        API Documentation: https://techdocs.akamai.com/linode-api/reference/delete-vlan
+
+        :param vlan: The label of the VLAN to be deleted.
+        :type vlan: str or VLAN
+        :param region: The VLAN's region.
+        :type region: str or Region
+        """
+        if isinstance(region, Region):
+            region = region.id
+
+        if isinstance(vlan, VLAN):
+            vlan = vlan.label
+        resp = self.client.delete(
+            "/networking/vlans/{}/{}".format(region, vlan),
+            model=self,
+        )
+
+        if "error" in resp:
+            return False
+
+        return True

linode_api4/objects/lke.py

@@ -257,6 +257,7 @@ class LKECluster(Base):
         "k8s_version": Property(slug_relationship=KubeVersion, mutable=True),
         "pools": Property(derived_class=LKENodePool),
         "control_plane": Property(mutable=True),
+        "apl_enabled": Property(),
     }
 
     def invalidate(self):
@@ -353,6 +354,36 @@ def control_plane_acl(self) -> LKEClusterControlPlaneACL:
 
         return LKEClusterControlPlaneACL.from_json(self._control_plane_acl)
 
+    @property
+    def apl_console_url(self) -> Optional[str]:
+        """
+        Returns the URL of this cluster's APL installation if this cluster
+        is APL-enabled, else None.
+
+        :returns: The URL of the APL console for this cluster.
+        :rtype: str or None
+        """
+
+        if not self.apl_enabled:
+            return None
+
+        return f"https://console.lke{self.id}.akamai-apl.net"
+
+    @property
+    def apl_health_check_url(self) -> Optional[str]:
+        """
+        Returns the URL of this cluster's APL health check endpoint if this cluster
+        is APL-enabled, else None.
+
+        :returns: The URL of the APL console for this cluster.
+        :rtype: str or None
+        """
+
+        if not self.apl_enabled:
+            return None
+
+        return f"https://auth.lke{self.id}.akamai-apl.net/ready"
+
     def node_pool_create(
         self,
         node_type: Union[Type, str],

test/fixtures/lke_clusters.json

@@ -6,5 +6,6 @@
     "label": "example-cluster",
     "region": "ap-west",
     "k8s_version": "1.19",
-    "tags": []
+    "tags": [],
+    "apl_enabled": true
 }

test/fixtures/lke_clusters_18881.json

@@ -9,5 +9,6 @@
     "tags": [],
     "control_plane": {
         "high_availability": true
-    }
+    },
+    "apl_enabled": true
 }

test/integration/conftest.py

@@ -502,3 +502,22 @@ def pytest_configure(config):
         "markers",
         "smoke: mark test as part of smoke test suite",
     )
+
+
+@pytest.fixture(scope="session")
+def linode_for_vlan_tests(test_linode_client, e2e_test_firewall):
+    client = test_linode_client
+    region = get_region(client, {"Linodes", "Vlans"}, site_type="core")
+    label = get_test_label(length=8)
+
+    linode_instance, password = client.linode.instance_create(
+        "g6-nanode-1",
+        region,
+        image="linode/debian12",
+        label=label,
+        firewall=e2e_test_firewall,
+    )
+
+    yield linode_instance
+
+    linode_instance.delete()

test/integration/models/lke/test_lke.py

@@ -110,6 +110,32 @@ def lke_cluster_with_labels_and_taints(test_linode_client):
     cluster.delete()
 
 
+@pytest.fixture(scope="session")
+def lke_cluster_with_apl(test_linode_client):
+    version = test_linode_client.lke.versions()[0]
+
+    region = get_region(test_linode_client, {"Kubernetes", "Disk Encryption"})
+
+    # NOTE: g6-dedicated-4 is the minimum APL-compatible Linode type
+    node_pools = test_linode_client.lke.node_pool("g6-dedicated-4", 3)
+    label = get_test_label() + "_cluster"
+
+    cluster = test_linode_client.lke.cluster_create(
+        region,
+        label,
+        node_pools,
+        version,
+        control_plane=LKEClusterControlPlaneOptions(
+            high_availability=True,
+        ),
+        apl_enabled=True,
+    )
+
+    yield cluster
+
+    cluster.delete()
+
+
 def get_cluster_status(cluster: LKECluster, status: str):
     return cluster._raw_json["status"] == status
 
@@ -328,6 +354,19 @@ def test_lke_cluster_labels_and_taints(lke_cluster_with_labels_and_taints):
     assert LKENodePoolTaint.from_json(updated_taints[1]) in pool.taints
 
 
+@pytest.mark.flaky(reruns=3, reruns_delay=2)
+def test_lke_cluster_with_apl(lke_cluster_with_apl):
+    assert lke_cluster_with_apl.apl_enabled == True
+    assert (
+        lke_cluster_with_apl.apl_console_url
+        == f"https://console.lke{lke_cluster_with_apl.id}.akamai-apl.net"
+    )
+    assert (
+        lke_cluster_with_apl.apl_health_check_url
+        == f"https://auth.lke{lke_cluster_with_apl.id}.akamai-apl.net/ready"
+    )
+
+
 def test_lke_types(test_linode_client):
     types = test_linode_client.lke.types()
 

test/integration/models/networking/test_networking.py

@@ -4,11 +4,15 @@
     get_region,
     get_token,
 )
-from test.integration.helpers import get_test_label
+from test.integration.helpers import (
+    get_test_label,
+    retry_sending_request,
+    wait_for_condition,
+)
 
 import pytest
 
-from linode_api4 import LinodeClient
+from linode_api4 import Instance, LinodeClient
 from linode_api4.objects import Config, ConfigInterfaceIPv4, Firewall, IPAddress
 from linode_api4.objects.networking import NetworkTransferPrice, Price
 
@@ -163,3 +167,45 @@ def test_allocate_and_delete_ip(test_linode_client, create_linode):
     is_deleted = ip.delete()
 
     assert is_deleted is True
+
+
+def get_status(linode: Instance, status: str):
+    return linode.status == status
+
+
+def test_create_and_delete_vlan(test_linode_client, linode_for_vlan_tests):
+    linode = linode_for_vlan_tests
+
+    config: Config = linode.configs[0]
+
+    config.interfaces = []
+    config.save()
+
+    vlan_label = "testvlan"
+    interface = config.interface_create_vlan(
+        label=vlan_label, ipam_address="10.0.0.2/32"
+    )
+
+    config.invalidate()
+
+    assert interface.id == config.interfaces[0].id
+    assert interface.purpose == "vlan"
+    assert interface.label == vlan_label
+
+    # Remove the VLAN interface and reboot Linode
+    config.interfaces = []
+    config.save()
+
+    wait_for_condition(3, 100, get_status, linode, "running")
+
+    retry_sending_request(3, linode.reboot)
+
+    wait_for_condition(3, 100, get_status, linode, "rebooting")
+    assert linode.status == "rebooting"
+
+    # Delete the VLAN
+    is_deleted = test_linode_client.networking.delete_vlan(
+        vlan_label, linode.region
+    )
+
+    assert is_deleted is True

test/unit/objects/lke_test.py

@@ -39,6 +39,7 @@ def test_get_cluster(self):
         self.assertEqual(cluster.region.id, "ap-west")
         self.assertEqual(cluster.k8s_version.id, "1.19")
         self.assertTrue(cluster.control_plane.high_availability)
+        self.assertTrue(cluster.apl_enabled)
 
     def test_get_pool(self):
         """
@@ -352,6 +353,40 @@ def test_cluster_create_with_labels_and_taints(self):
                 ],
             }
 
+    def test_cluster_create_with_apl(self):
+        """
+        Tests that an LKE cluster can be created with APL enabled.
+        """
+
+        with self.mock_post("lke/clusters") as m:
+            cluster = self.client.lke.cluster_create(
+                "us-mia",
+                "test-aapl-cluster",
+                [
+                    self.client.lke.node_pool(
+                        "g6-dedicated-4",
+                        3,
+                    )
+                ],
+                "1.29",
+                apl_enabled=True,
+                control_plane=LKEClusterControlPlaneOptions(
+                    high_availability=True,
+                ),
+            )
+
+            assert m.call_data["apl_enabled"] == True
+            assert m.call_data["control_plane"]["high_availability"] == True
+
+        assert (
+            cluster.apl_console_url == "https://console.lke18881.akamai-apl.net"
+        )
+
+        assert (
+            cluster.apl_health_check_url
+            == "https://auth.lke18881.akamai-apl.net/ready"
+        )
+
     def test_populate_with_taints(self):
         """
         Tests that LKENodePool correctly handles a list of LKENodePoolTaint and Dict objects.