canonicalwebteam.store-api 6.7.0__py3-none-any.whl → 6.8.0__py3-none-any.whl

canonicalwebteam/exceptions.py

@@ -14,6 +14,46 @@ class StoreApiConnectionError(StoreApiError):
     pass
 
 
+class StoreApiInternalError(StoreApiConnectionError):
+    """
+    Store API internal error
+    """
+
+    pass
+
+
+class StoreApiNotImplementedError(StoreApiConnectionError):
+    """
+    Store API doesn't implement this method
+    """
+
+    pass
+
+
+class StoreApiBadGatewayError(StoreApiConnectionError):
+    """
+    Got and invalid response from Store API
+    """
+
+    pass
+
+
+class StoreApiServiceUnavailableError(StoreApiConnectionError):
+    """
+    Store API is not available
+    """
+
+    pass
+
+
+class StoreApiGatewayTimeoutError(StoreApiConnectionError):
+    """
+    Request to Store API timed out
+    """
+
+    pass
+
+
 class StoreApiResourceNotFound(StoreApiError):
     """
     The requested resource is not found

canonicalwebteam/retry_utils.py

@@ -0,0 +1,170 @@
+from typing import Callable, Tuple, Type, TypeVar
+from random import random
+from sys import maxsize as MAX_INT
+import functools
+
+
+P = TypeVar("P")
+R = TypeVar("R")
+
+
+def retry(
+    func: Callable[P, R] = None,
+    *,
+    limit: int = MAX_INT,
+    delay_fn: Callable[[int], float] = (lambda x: 0.0),
+    sleep_fn: Callable[[float], None] = (lambda x: None),
+    callback_fn: Callable[[Exception], bool] = (lambda x: False),
+    logger_fn: Callable[[str], None] = (lambda x: None),
+    exceptions: Tuple[Type[Exception]] = (Exception),
+) -> Callable[P, R]:
+    """
+    Decorator that implements retry logic for `func` when any of the
+    Exceptions in `exceptions` happen.
+
+    Arguments:
+    func: function what will be retried
+
+    Keyword arguments:
+    limit: max number of retry attempts
+    exceptions: tuple containing the types of exceptions we can catch and
+        that trigger a retry
+    callback_fn: function that takes as argument an exception caught a during
+        the retry loop, it should return a bool indicating whether to abort
+        the loop or not; it will be called every time a member of `exceptions`
+        is caught
+    logger_fn: function that logs errors caught and not propagated during
+        the retry loop; it will be called every time a member of `exceptions`
+        is caught
+    delay_fn: function that takes the current attempt as an argument and
+        returns a float indicating the delay in seconds before calling `func`
+        again
+    sleep_fn: function that takes a float indicating a delay in seconds and
+        waits for this specified time before executing `func` again; it's
+        user's responsibility to make sure the sleep function is appropriate
+        for their usage (e.g. use an async sleep in and async environment)
+    """
+
+    if func is None:
+        # if the decorator is applied using parameters (e.g. @retry(limit=3)),
+        # `func` will be None, so we must first do a partial application on
+        # the decorator itself to actually wrap `func` correctly
+        return functools.partial(
+            retry,
+            limit=limit,
+            delay_fn=delay_fn,
+            sleep_fn=sleep_fn,
+            callback_fn=callback_fn,
+            logger_fn=logger_fn,
+            exceptions=exceptions,
+        )
+
+    if limit <= 0:
+        raise ValueError("The limit must be at least 1")
+
+    @functools.wraps(func)
+    def _retry(*args, **kwargs):
+        retry_attempts = 0
+        last_exception = None
+
+        while retry_attempts < limit:
+            if retry_attempts > 0:
+                # only sleep if we've already tried once
+                sleep_fn(delay_fn(retry_attempts))
+
+            try:
+                return func(*args, **kwargs)
+            except exceptions as e:
+                last_exception = e
+                retry_attempts += 1
+
+                if callback_fn(e):
+                    # stop early if callback says so, raise `e` immediately
+                    raise e
+
+                logger_fn(
+                    f"@retry ({retry_attempts}/{limit}) `{func.__name__}`: {e}"
+                )
+
+        # if we made it here, it means we ran the loop and couldn't get a
+        # clean run, raise the last exception we caught and let the user
+        # deal with it
+        raise last_exception
+
+    return _retry
+
+
+def delay_constant(delay: float):
+    """
+    Returns a function that always returns `delay`
+    """
+    if delay < 0:
+        raise ValueError("The delay must be at least 0")
+
+    def _delay_constant(_: int):
+        return delay
+
+    return _delay_constant
+
+
+def delay_random(min: float, max: float):
+    """
+    Returns a function that picks a random delay between `min` and `max`
+    """
+    if min < 0:
+        raise ValueError("The minimum delay must be at least 0")
+    if max <= min:
+        raise ValueError("The maximum delay must be greater than the minimum")
+
+    def _delay_random(_: int):
+        return min + random() * (max - min)
+
+    return _delay_random
+
+
+def delay_exponential(
+    delay_mult: float, exp_base: float, max_delay: float = float("inf")
+):
+    """
+    Returns a function that implements an exponential backoff with an upper
+    limit based on the number of attempts made `n`, according to the following
+    formula:
+        min(`max_delay`, `delay_mult` * `exp_base`^`n`)
+    """
+    if delay_mult <= 0:
+        raise ValueError("The delay multiplier must be greater than 0")
+    if exp_base <= 1:
+        raise ValueError("The exponential base must be greater than 1")
+    if max_delay <= 0:
+        raise ValueError("The maximum delay must be greater than 0")
+
+    def _delay_exponential(attempt: int):
+        return min(max_delay, delay_mult * (exp_base**attempt))
+
+    return _delay_exponential
+
+
+"""
+Example usage:
+
+    @retry(
+        limit=5,
+        logger_fn=print,
+        exceptions=(TypeError),
+        sleep_fn=sleep,
+        delay_fn=delay_exponential(1, 2)
+    )
+    def test_fn(val: int):
+        return None + val  # this will raise TypeError
+
+    try:
+        test_fn(2)
+    except TypeError as e:
+        print(e)
+
+This will attempt to run `test_fn` 5 times, will catch TypeError 4 times and
+then it will let the exception propagate after executing the function for the
+last time. Each time, it will take an exponentially longer amount of time to
+run, making the total execution time around 30s (plus some small random delay
+caused by the OS).
+"""

canonicalwebteam/store_api/base.py

@@ -1,12 +1,17 @@
 from canonicalwebteam.exceptions import (
+    PublisherAgreementNotSigned,
+    PublisherMacaroonRefreshRequired,
+    PublisherMissingUsername,
+    StoreApiBadGatewayError,
     StoreApiConnectionError,
+    StoreApiGatewayTimeoutError,
+    StoreApiInternalError,
+    StoreApiNotImplementedError,
     StoreApiResourceNotFound,
     StoreApiResponseDecodeError,
     StoreApiResponseError,
     StoreApiResponseErrorList,
-    PublisherAgreementNotSigned,
-    PublisherMacaroonRefreshRequired,
-    PublisherMissingUsername,
+    StoreApiServiceUnavailableError,
 )
 
 
@@ -17,7 +22,22 @@ class Base:
     def process_response(self, response):
         # 5xx responses are not in JSON format
         if response.status_code >= 500:
-            raise StoreApiConnectionError("Service Unavailable")
+            if response.status_code == 500:
+                raise StoreApiInternalError("Internal error upstream")
+            elif response.status_code == 501:
+                raise StoreApiNotImplementedError(
+                    "Service doesn't implement this method"
+                )
+            elif response.status_code == 502:
+                raise StoreApiBadGatewayError("Invalid response from upstream")
+            elif response.status_code == 503:
+                raise StoreApiServiceUnavailableError("Service is unavailable")
+            elif response.status_code == 504:
+                raise StoreApiGatewayTimeoutError("Upstream request timed out")
+            else:
+                raise StoreApiConnectionError(
+                    f"Service unavailable, code {response.status_code}"
+                )
 
         try:
             body = response.json()

{canonicalwebteam_store_api-6.7.0.dist-info → canonicalwebteam_store_api-6.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: canonicalwebteam.store-api
-Version: 6.7.0
+Version: 6.8.0
 Summary: 
 License: LGPL-3.0
 Author: Canonical Web Team

canonicalwebteam_store_api-6.8.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+canonicalwebteam/__init__.py,sha256=ED6jHcYiuYpr_0vjGz0zx2lrrmJT9sDJCzIljoDfmlM,65
+canonicalwebteam/exceptions.py,sha256=Uf9HxtLH5fAXPdDm6H14tA8jUxKQAWUmWIovzHLtdRw,2134
+canonicalwebteam/retry_utils.py,sha256=KcaWscyVbzhP4VNPWUnh-mlIKe5T09z4jdI1bJgtvfg,5422
+canonicalwebteam/store_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+canonicalwebteam/store_api/base.py,sha256=_kx3_hPQHJPUtdf3z4NXmcwHlswV1g1mw483fZXD5LM,3331
+canonicalwebteam/store_api/dashboard.py,sha256=M5JLjTTahN-bfiVz9SuP6ahLjqEvOalwmNim6X5Ky6o,22796
+canonicalwebteam/store_api/devicegw.py,sha256=YXmVXdHCZhukNHJq-eaFUCxa2VxqLT8qt19UrqgXGN0,9777
+canonicalwebteam/store_api/publishergw.py,sha256=u2D2Y76xC8ms16XTZcUe_KmRdcyzqOV2g0aN9HYZBrQ,29702
+canonicalwebteam_store_api-6.8.0.dist-info/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+canonicalwebteam_store_api-6.8.0.dist-info/METADATA,sha256=_u5GFZweT4nhOYTN9pSs0E3zLvJnFBgbtevUyjsByuQ,2253
+canonicalwebteam_store_api-6.8.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+canonicalwebteam_store_api-6.8.0.dist-info/RECORD,,

canonicalwebteam_store_api-6.7.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-canonicalwebteam/__init__.py,sha256=ED6jHcYiuYpr_0vjGz0zx2lrrmJT9sDJCzIljoDfmlM,65
-canonicalwebteam/exceptions.py,sha256=A49LRhiEIfXNB2zC-zNcZEcdh0ugw6G7fBbXbs-BWxA,1517
-canonicalwebteam/store_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-canonicalwebteam/store_api/base.py,sha256=DmfVcefWxGYNQxzYmaDVhmthTCg2vEwEnvczU9Bk5zE,2414
-canonicalwebteam/store_api/dashboard.py,sha256=M5JLjTTahN-bfiVz9SuP6ahLjqEvOalwmNim6X5Ky6o,22796
-canonicalwebteam/store_api/devicegw.py,sha256=YXmVXdHCZhukNHJq-eaFUCxa2VxqLT8qt19UrqgXGN0,9777
-canonicalwebteam/store_api/publishergw.py,sha256=u2D2Y76xC8ms16XTZcUe_KmRdcyzqOV2g0aN9HYZBrQ,29702
-canonicalwebteam_store_api-6.7.0.dist-info/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
-canonicalwebteam_store_api-6.7.0.dist-info/METADATA,sha256=PJgxFUHDwul_1i3n7LbmZrLHxPNMJB9GPGXDYBUUD_0,2253
-canonicalwebteam_store_api-6.7.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-canonicalwebteam_store_api-6.7.0.dist-info/RECORD,,