Merge pull request #290 from linode/dev

Release v5.5.0

Author: lgarber-akamai

.gitignore

@@ -10,4 +10,5 @@ docs/_build/*
 .pytest_cache/*
 .tox/*
 venv
-baked_version
+baked_version
+.vscode

linode_api4/groups/database.py

@@ -5,7 +5,6 @@
     Database,
     DatabaseEngine,
     DatabaseType,
-    MongoDBDatabase,
     MySQLDatabase,
     PostgreSQLDatabase,
 )
@@ -200,67 +199,3 @@ def postgresql_create(self, label, region, engine, ltype, **kwargs):
 
         d = PostgreSQLDatabase(self.client, result["id"], result)
         return d
-
-    def mongodb_instances(self, *filters):
-        """
-        Returns a list of Managed MongoDB Databases active on this account.
-
-        API Documentation: https://www.linode.com/docs/api/databases/#managed-mongodb-databases-list
-
-        :param filters: Any number of filters to apply to this query.
-
-        :returns: A list of MongoDB databases that matched the query.
-        :rtype: PaginatedList of MongoDBDatabase
-        """
-        return self.client._get_and_filter(MongoDBDatabase, *filters)
-
-    def mongodb_create(self, label, region, engine, ltype, **kwargs):
-        """
-        Creates an :any:`MongoDBDatabase` on this account with
-        the given label, region, engine, and node type.  For example::
-
-           client = LinodeClient(TOKEN)
-
-           # look up Region and Types to use.  In this example I'm just using
-           # the first ones returned.
-           region = client.regions().first()
-           node_type = client.database.types()[0]
-           engine = client.database.engines(DatabaseEngine.engine == 'mongodb')[0]
-
-           new_database = client.database.mongodb_create(
-               "example-database",
-               region,
-               engine.id,
-               type.id
-            )
-
-        API Documentation: https://www.linode.com/docs/api/databases/#managed-mongodb-database-create
-
-        :param label: The name for this cluster
-        :type label: str
-        :param region: The region to deploy this cluster in
-        :type region: str or Region
-        :param engine: The engine to deploy this cluster with
-        :type engine: str or Engine
-        :param ltype: The Linode Type to use for this cluster
-        :type ltype: str or Type
-        """
-
-        params = {
-            "label": label,
-            "region": region.id if issubclass(type(region), Base) else region,
-            "engine": engine.id if issubclass(type(engine), Base) else engine,
-            "type": ltype.id if issubclass(type(ltype), Base) else ltype,
-        }
-        params.update(kwargs)
-
-        result = self.client.post("/databases/mongodb/instances", data=params)
-
-        if "id" not in result:
-            raise UnexpectedResponseError(
-                "Unexpected response when creating MongoDB Database",
-                json=result,
-            )
-
-        d = MongoDBDatabase(self.client, result["id"], result)
-        return d

linode_api4/linode_client.py

@@ -2,11 +2,11 @@
 
 import json
 import logging
-import time
 from typing import BinaryIO, Tuple
 
 import pkg_resources
 import requests
+from requests.adapters import HTTPAdapter, Retry
 
 from linode_api4.errors import ApiError, UnexpectedResponseError
 from linode_api4.groups import *
@@ -22,14 +22,27 @@
 logger = logging.getLogger(__name__)
 
 
+class LinearRetry(Retry):
+    """
+    Linear retry is a subclass of Retry that uses a linear backoff strategy.
+    This is necessary to maintain backwards compatibility with the old retry system.
+    """
+
+    def get_backoff_time(self):
+        return self.backoff_factor
+
+
 class LinodeClient:
     def __init__(
         self,
         token,
         base_url="https://api.linode.com/v4",
         user_agent=None,
         page_size=None,
-        retry_rate_limit_interval=None,
+        retry=True,
+        retry_rate_limit_interval=1.0,
+        retry_max=5,
+        retry_statuses=None,
     ):
         """
         The main interface to the Linode API.
@@ -51,26 +64,57 @@ def __init__(
                                   can be found in the API docs, but at time of writing
                                   are between 25 and 500.
         :type page_size: int
-        :param retry_rate_limit_interval: If given, 429 responses will be automatically
-                                         retried up to 5 times with the given interval,
-                                         in seconds, between attempts.
-        :type retry_rate_limit_interval: int
+        :param retry: Whether API requests should automatically be retries on known
+                      intermittent responses.
+        :type retry: bool
+        :param retry_rate_limit_interval: The amount of time to wait between HTTP request
+                                          retries.
+        :type retry_rate_limit_interval: float
+        :param retry_max: The number of request retries that should be attempted before
+                          raising an API error.
+        :type retry_max: int
+        :type retry_statuses: List of int
+        :param retry_statuses: Additional HTTP response statuses to retry on.
+                               By default, the client will retry on 408, 429, and 502
+                               responses.
         """
         self.base_url = base_url
         self._add_user_agent = user_agent
         self.token = token
-        self.session = requests.Session()
         self.page_size = page_size
-        self.retry_rate_limit_interval = retry_rate_limit_interval
+
+        retry_forcelist = [408, 429, 502]
+
+        if retry_statuses is not None:
+            retry_forcelist.extend(retry_statuses)
 
         # make sure we got a sane backoff
-        if self.retry_rate_limit_interval is not None:
-            if not isinstance(self.retry_rate_limit_interval, int):
-                raise ValueError("retry_rate_limit_interval must be an int")
-            if self.retry_rate_limit_interval < 1:
-                raise ValueError(
-                    "retry_rate_limit_interval must not be less than 1"
-                )
+        if not isinstance(retry_rate_limit_interval, float):
+            raise ValueError("retry_rate_limit_interval must be a float")
+
+        # Ensure the max retries value is valid
+        if not isinstance(retry_max, int):
+            raise ValueError("retry_max must be an int")
+
+        self.retry = retry
+        self.retry_rate_limit_interval = retry_rate_limit_interval
+        self.retry_max = retry_max
+        self.retry_statuses = retry_statuses
+
+        # Initialize the HTTP client session
+        self.session = requests.Session()
+
+        self._retry_config = LinearRetry(
+            total=retry_max if retry else 0,
+            status_forcelist=retry_forcelist,
+            respect_retry_after_header=True,
+            backoff_factor=retry_rate_limit_interval,
+            raise_on_status=False,
+        )
+        retry_adapter = HTTPAdapter(max_retries=self._retry_config)
+
+        self.session.mount("http://", retry_adapter)
+        self.session.mount("https://", retry_adapter)
 
         #: Access methods related to Linodes - see :any:`LinodeGroup` for
         #: more information
@@ -196,29 +240,11 @@ def _api_call(
         if data is not None:
             body = json.dumps(data)
 
-        # retry on 429 response
-        max_retries = 5 if self.retry_rate_limit_interval else 1
-        for attempt in range(max_retries):
-            response = method(url, headers=headers, data=body)
-
-            warning = response.headers.get("Warning", None)
-            if warning:
-                logger.warning(
-                    "Received warning from server: {}".format(warning)
-                )
-
-            # if we were configured to retry 429s, and we got a 429, sleep briefly and then retry
-            if self.retry_rate_limit_interval and response.status_code == 429:
-                logger.warning(
-                    "Received 429 response; waiting {} seconds and retrying request (attempt {}/{})".format(
-                        self.retry_rate_limit_interval,
-                        attempt,
-                        max_retries,
-                    )
-                )
-                time.sleep(self.retry_rate_limit_interval)
-            else:
-                break
+        response = method(url, headers=headers, data=body)
+
+        warning = response.headers.get("Warning", None)
+        if warning:
+            logger.warning("Received warning from server: {}".format(warning))
 
         if 399 < response.status_code < 600:
             j = None
@@ -288,6 +314,29 @@ def put(self, *args, **kwargs):
     def delete(self, *args, **kwargs):
         return self._api_call(*args, method=self.session.delete, **kwargs)
 
+    def __setattr__(self, key, value):
+        # Allow for dynamic updating of the retry config
+        handlers = {
+            "retry_rate_limit_interval": lambda: setattr(
+                self._retry_config, "backoff_factor", value
+            ),
+            "retry": lambda: setattr(
+                self._retry_config, "total", self.retry_max if value else 0
+            ),
+            "retry_max": lambda: setattr(
+                self._retry_config, "total", value if self.retry else 0
+            ),
+            "retry_statuses": lambda: setattr(
+                self._retry_config, "status_forcelist", value
+            ),
+        }
+
+        handler = handlers.get(key)
+        if hasattr(self, "_retry_config") and handler is not None:
+            handler()
+
+        super().__setattr__(key, value)
+
     def image_create(self, disk, label=None, description=None):
         """
         .. note:: This method is an alias to maintain backwards compatibility.

linode_api4/objects/base.py

@@ -90,7 +90,18 @@ def __repr__(self):
 
     @property
     def dict(self):
-        return dict(self.__dict__)
+        result = vars(self).copy()
+        cls = type(self)
+
+        for k, v in result.items():
+            if isinstance(v, cls):
+                result[k] = v.dict
+            elif isinstance(v, list):
+                result[k] = [
+                    item.dict if isinstance(item, cls) else item for item in v
+                ]
+
+        return result
 
 
 class Base(object, metaclass=FilterableMetaclass):
@@ -210,9 +221,26 @@ def save(self, force=True) -> bool:
         if not force and not self._changed:
             return False
 
-        resp = self._client.put(
-            type(self).api_endpoint, model=self, data=self._serialize()
-        )
+        data = None
+        if not self._populated:
+            data = {
+                a: object.__getattribute__(self, a)
+                for a in type(self).properties
+                if type(self).properties[a].mutable
+                and object.__getattribute__(self, a) is not None
+            }
+
+            for key, value in data.items():
+                if (
+                    isinstance(value, ExplicitNullValue)
+                    or value == ExplicitNullValue
+                ):
+                    data[key] = None
+
+        else:
+            data = self._serialize()
+
+        resp = self._client.put(type(self).api_endpoint, model=self, data=data)
 
         if "error" in resp:
             return False