canonicalwebteam.store-api 6.6.0__tar.gz → 6.8.0__tar.gz

{canonicalwebteam_store_api-6.6.0 → canonicalwebteam_store_api-6.8.0}/PKG-INFO

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

{canonicalwebteam_store_api-6.6.0 → canonicalwebteam_store_api-6.8.0}/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_store_api-6.8.0/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-6.6.0 → canonicalwebteam_store_api-6.8.0}/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.6.0 → canonicalwebteam_store_api-6.8.0}/canonicalwebteam/store_api/publishergw.py

@@ -1,5 +1,5 @@
 from os import getenv
-from typing import Optional
+from typing import Optional, Union
 from requests import Session
 
 from canonicalwebteam.store_api.base import Base
@@ -312,7 +312,7 @@ class PublisherGW(Base):
         return self.process_response(response)
 
     def unregister_package_name(
-        self, publisher_auth: str, package_name: str
+        self, publisher_auth: Union[str, dict], package_name: str
     ) -> dict:
         """
         Unregister a package name.
@@ -328,9 +328,29 @@ class PublisherGW(Base):
             Otherwise, returns an error list
         """
         url = self.get_endpoint_url(package_name, has_name_space=True)
+        if self.name_space == "snap":
+            # for Snap packages, `unregister_package` uses SCA's API under the
+            # hood: this means we must pass the authorization header as if
+            # we were calling SCA
+            if not isinstance(publisher_auth, dict):
+                raise TypeError(
+                    "Name space 'snap' requires a 'dict' as 'publisher_auth'"
+                )
+            authorization_header = dashboard_authorization_header(
+                publisher_auth
+            )
+        else:
+            if not isinstance(publisher_auth, str):
+                raise TypeError(
+                    f"Name space '{self.name_space}' requires a 'str' as "
+                    "'publisher_auth'"
+                )
+            authorization_header = self._get_authorization_header(
+                publisher_auth
+            )
         response = self.session.delete(
             url=url,
-            headers=self._get_authorization_header(publisher_auth),
+            headers=authorization_header,
         )
         return response
 

{canonicalwebteam_store_api-6.6.0 → canonicalwebteam_store_api-6.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = 'canonicalwebteam.store-api'
-version = '6.6.0'
+version = '6.8.0'
 description = ''
 authors = ['Canonical Web Team <webteam@canonical.com>']
 license = 'LGPL-3.0'