Merge pull request #522 from linode/dev

Release v5.29.0

Author: ezilber-akamai

linode_api4/groups/__init__.py

@@ -8,6 +8,7 @@
 from .image import *
 from .linode import *
 from .lke import *
+from .lke_tier import *
 from .longview import *
 from .networking import *
 from .nodebalancer import *

linode_api4/groups/lke.py

@@ -1,7 +1,8 @@
-from typing import Any, Dict, Union
+from typing import Any, Dict, Optional, Union
 
 from linode_api4.errors import UnexpectedResponseError
 from linode_api4.groups import Group
+from linode_api4.groups.lke_tier import LKETierGroup
 from linode_api4.objects import (
     KubeVersion,
     LKECluster,
@@ -67,6 +68,7 @@ def cluster_create(
             LKEClusterControlPlaneOptions, Dict[str, Any]
         ] = None,
         apl_enabled: bool = False,
+        tier: Optional[str] = None,
         **kwargs,
     ):
         """
@@ -104,9 +106,13 @@ def cluster_create(
         :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
+                            NOTE: This field is in beta and may only
                             function if base_url is set to `https://api.linode.com/v4beta`.
         :type apl_enabled: bool
+        :param tier: The tier of LKE cluster to create.
+                     NOTE: This field is in beta and may only
+                     function if base_url is set to `https://api.linode.com/v4beta`.
+        :type tier: str
         :param kwargs: Any other arguments to pass along to the API.  See the API
                        docs for possible values.
 
@@ -122,6 +128,7 @@ def cluster_create(
                 node_pools if isinstance(node_pools, list) else [node_pools]
             ),
             "control_plane": control_plane,
+            "tier": tier,
         }
         params.update(kwargs)
 
@@ -183,3 +190,18 @@ def types(self, *filters):
         return self.client._get_and_filter(
             LKEType, *filters, endpoint="/lke/types"
         )
+
+    def tier(self, id: str) -> LKETierGroup:
+        """
+        Returns an object representing the LKE tier API path.
+
+        NOTE: LKE tiers may not currently be available to all users.
+
+        :param id: The ID of the tier.
+        :type id: str
+
+        :returns: An object representing the LKE tier API path.
+        :rtype: LKETier
+        """
+
+        return LKETierGroup(self.client, id)

linode_api4/groups/lke_tier.py

@@ -0,0 +1,40 @@
+from linode_api4.groups import Group
+from linode_api4.objects import TieredKubeVersion
+
+
+class LKETierGroup(Group):
+    """
+    Encapsulates methods related to a specific LKE tier. This
+    should not be instantiated on its own, but should instead be used through
+    an instance of :any:`LinodeClient`::
+
+       client = LinodeClient(token)
+       instances = client.lke.tier("standard") # use the LKETierGroup
+
+    This group contains all features beneath the `/lke/tiers/{tier}` group in the API v4.
+    """
+
+    def __init__(self, client: "LinodeClient", tier: str):
+        super().__init__(client)
+        self.tier = tier
+
+    def versions(self, *filters):
+        """
+        Returns a paginated list of versions for this tier matching the given filters.
+
+        API Documentation: Not Yet Available
+
+        :param filters: Any number of filters to apply to this query.
+                        See :doc:`Filtering Collections</linode_api4/objects/filtering>`
+                        for more details on filtering.
+
+        :returns: A paginated list of kube versions that match the query.
+        :rtype: PaginatedList of TieredKubeVersion
+        """
+
+        return self.client._get_and_filter(
+            TieredKubeVersion,
+            endpoint=f"/lke/tiers/{self.tier}/versions",
+            parent_id=self.tier,
+            *filters,
+        )

linode_api4/groups/object_storage.py

@@ -8,6 +8,7 @@
 from linode_api4 import (
     ObjectStorageEndpoint,
     ObjectStorageEndpointType,
+    ObjectStorageType,
     PaginatedList,
 )
 from linode_api4.errors import UnexpectedResponseError
@@ -70,6 +71,24 @@ def keys(self, *filters):
         """
         return self.client._get_and_filter(ObjectStorageKeys, *filters)
 
+    def types(self, *filters):
+        """
+        Returns a paginated list of Object Storage Types.
+
+        API Documentation: https://techdocs.akamai.com/linode-api/reference/get-object-storage-types
+
+        :param filters: Any number of filters to apply to this query.
+                        See :doc:`Filtering Collections</linode_api4/objects/filtering>`
+                        for more details on filtering.
+
+        :returns: A Paginated List of Object Storage types that match the query.
+        :rtype: PaginatedList of ObjectStorageType
+        """
+
+        return self.client._get_and_filter(
+            ObjectStorageType, *filters, endpoint="/object-storage/types"
+        )
+
     def keys_create(
         self,
         label: str,

linode_api4/linode_client.py

@@ -455,7 +455,13 @@ def volume_create(self, label, region=None, linode=None, size=20, **kwargs):
         )
 
     # helper functions
-    def _get_and_filter(self, obj_type, *filters, endpoint=None):
+    def _get_and_filter(
+        self,
+        obj_type,
+        *filters,
+        endpoint=None,
+        parent_id=None,
+    ):
         parsed_filters = None
         if filters:
             if len(filters) > 1:
@@ -467,8 +473,13 @@ def _get_and_filter(self, obj_type, *filters, endpoint=None):
 
         # Use sepcified endpoint
         if endpoint:
-            return self._get_objects(endpoint, obj_type, filters=parsed_filters)
+            return self._get_objects(
+                endpoint, obj_type, parent_id=parent_id, filters=parsed_filters
+            )
         else:
             return self._get_objects(
-                obj_type.api_list(), obj_type, filters=parsed_filters
+                obj_type.api_list(),
+                obj_type,
+                parent_id=parent_id,
+                filters=parsed_filters,
             )

linode_api4/objects/database.py

@@ -265,6 +265,30 @@ def invalidate(self):
 
         Base.invalidate(self)
 
+    def suspend(self):
+        """
+        Suspend a MySQL Managed Database, releasing idle resources and keeping only necessary data.
+
+        API documentation: https://techdocs.akamai.com/linode-api/reference/suspend-databases-mysql-instance
+        """
+        self._client.post(
+            "{}/suspend".format(MySQLDatabase.api_endpoint), model=self
+        )
+
+        return self.invalidate()
+
+    def resume(self):
+        """
+        Resume a suspended MySQL Managed Database.
+
+        API documentation: https://techdocs.akamai.com/linode-api/reference/resume-databases-mysql-instance
+        """
+        self._client.post(
+            "{}/resume".format(MySQLDatabase.api_endpoint), model=self
+        )
+
+        return self.invalidate()
+
 
 class PostgreSQLDatabase(Base):
     """
@@ -405,6 +429,30 @@ def invalidate(self):
 
         Base.invalidate(self)
 
+    def suspend(self):
+        """
+        Suspend a PostgreSQL Managed Database, releasing idle resources and keeping only necessary data.
+
+        API documentation: https://techdocs.akamai.com/linode-api/reference/suspend-databases-postgre-sql-instance
+        """
+        self._client.post(
+            "{}/suspend".format(PostgreSQLDatabase.api_endpoint), model=self
+        )
+
+        return self.invalidate()
+
+    def resume(self):
+        """
+        Resume a suspended PostgreSQL Managed Database.
+
+        API documentation: https://techdocs.akamai.com/linode-api/reference/resume-databases-postgre-sql-instance
+        """
+        self._client.post(
+            "{}/resume".format(PostgreSQLDatabase.api_endpoint), model=self
+        )
+
+        return self.invalidate()
+
 
 ENGINE_TYPE_TRANSLATION = {
     "mysql": MySQLDatabase,

linode_api4/objects/lke.py

@@ -14,6 +14,7 @@
     Region,
     Type,
 )
+from linode_api4.objects.base import _flatten_request_body_recursive
 from linode_api4.util import drop_null_keys
 
 
@@ -49,6 +50,26 @@ class KubeVersion(Base):
     }
 
 
+class TieredKubeVersion(DerivedBase):
+    """
+    A TieredKubeVersion is a version of Kubernetes that is specific to a certain LKE tier.
+
+    NOTE: LKE tiers may not currently be available to all users.
+
+    API Documentation: https://techdocs.akamai.com/linode-api/reference/get-lke-version
+    """
+
+    api_endpoint = "/lke/tiers/{tier}/versions/{id}"
+    parent_id_name = "tier"
+    id_attribute = "id"
+    derived_url_path = "versions"
+
+    properties = {
+        "id": Property(identifier=True),
+        "tier": Property(identifier=True),
+    }
+
+
 @dataclass
 class LKENodePoolTaint(JSONObject):
     """
@@ -154,6 +175,8 @@ class LKENodePool(DerivedBase):
     An LKE Node Pool describes a pool of Linode Instances that exist within an
     LKE Cluster.
 
+    NOTE: The k8s_version and update_strategy fields are only available for LKE Enterprise clusters.
+
     API Documentation: https://techdocs.akamai.com/linode-api/reference/get-lke-node-pool
     """
 
@@ -175,6 +198,12 @@ class LKENodePool(DerivedBase):
         "tags": Property(mutable=True, unordered=True),
         "labels": Property(mutable=True),
         "taints": Property(mutable=True),
+        # Enterprise-specific properties
+        # Ideally we would use slug_relationship=TieredKubeVersion here, but
+        # it isn't possible without an extra request because the tier is not
+        # directly exposed in the node pool response.
+        "k8s_version": Property(mutable=True),
+        "update_strategy": Property(mutable=True),
     }
 
     def _parse_raw_node(
@@ -255,6 +284,7 @@ class LKECluster(Base):
         "pools": Property(derived_class=LKENodePool),
         "control_plane": Property(mutable=True),
         "apl_enabled": Property(),
+        "tier": Property(),
     }
 
     def invalidate(self):
@@ -385,6 +415,10 @@ def node_pool_create(
         node_count: int,
         labels: Optional[Dict[str, str]] = None,
         taints: List[Union[LKENodePoolTaint, Dict[str, Any]]] = None,
+        k8s_version: Optional[
+            Union[str, KubeVersion, TieredKubeVersion]
+        ] = None,
+        update_strategy: Optional[str] = None,
         **kwargs,
     ):
         """
@@ -399,7 +433,13 @@ def node_pool_create(
         :param labels: A dict mapping labels to their values to apply to this pool.
         :type labels: Dict[str, str]
         :param taints: A list of taints to apply to this pool.
-        :type taints: List of :any:`LKENodePoolTaint` or dict
+        :type taints: List of :any:`LKENodePoolTaint` or dict.
+        :param k8s_version: The Kubernetes version to use for this pool.
+                            NOTE: This field is specific to enterprise clusters.
+        :type k8s_version: str, KubeVersion, or TieredKubeVersion
+        :param update_strategy: The strategy to use when updating this node pool.
+                                NOTE: This field is specific to enterprise clusters.
+        :type update_strategy: str
         :param kwargs: Any other arguments to pass to the API.  See the API docs
                        for possible values.
 
@@ -409,6 +449,10 @@ def node_pool_create(
         params = {
             "type": node_type,
             "count": node_count,
+            "labels": labels,
+            "taints": taints,
+            "k8s_version": k8s_version,
+            "update_strategy": update_strategy,
         }
 
         if labels is not None:
@@ -420,7 +464,9 @@ def node_pool_create(
         params.update(kwargs)
 
         result = self._client.post(
-            "{}/pools".format(LKECluster.api_endpoint), model=self, data=params
+            "{}/pools".format(LKECluster.api_endpoint),
+            model=self,
+            data=drop_null_keys(_flatten_request_body_recursive(params)),
         )
         self.invalidate()
 

linode_api4/objects/networking.py

@@ -244,6 +244,37 @@ def get_rules(self):
             "{}/rules".format(self.api_endpoint), model=self
         )
 
+    @property
+    def rule_versions(self):
+        """
+        Gets the JSON rule versions for this Firewall.
+
+        API Documentation: https://techdocs.akamai.com/linode-api/reference/get-firewall-rule-versions
+
+        :returns: Lists the current and historical rules of the firewall (that is not deleted),
+                using version. Whenever the rules update, the version increments from 1.
+        :rtype: dict
+        """
+        return self._client.get(
+            "{}/history".format(self.api_endpoint), model=self
+        )
+
+    def get_rule_version(self, version):
+        """
+        Gets the JSON for a specific rule version for this Firewall.
+
+        API Documentation: https://techdocs.akamai.com/linode-api/reference/get-firewall-rule-version
+
+        :param version: The firewall rule version to view.
+        :type version: int
+
+        :returns: Gets a specific firewall rule version for an enabled or disabled firewall.
+        :rtype: dict
+        """
+        return self._client.get(
+            "{}/history/rules/{}".format(self.api_endpoint, version), model=self
+        )
+
     def device_create(self, id, type="linode", **kwargs):
         """
         Creates and attaches a device to this Firewall