File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/retries.tar
Back
throttling.py 0000644 00000003363 15030215750 0007317 0 ustar 00 from collections import namedtuple CubicParams = namedtuple('CubicParams', ['w_max', 'k', 'last_fail']) class CubicCalculator: _SCALE_CONSTANT = 0.4 _BETA = 0.7 def __init__( self, starting_max_rate, start_time, scale_constant=_SCALE_CONSTANT, beta=_BETA, ): self._w_max = starting_max_rate self._scale_constant = scale_constant self._beta = beta self._k = self._calculate_zero_point() self._last_fail = start_time def _calculate_zero_point(self): scaled_value = (self._w_max * (1 - self._beta)) / self._scale_constant k = scaled_value ** (1 / 3.0) return k def success_received(self, timestamp): dt = timestamp - self._last_fail new_rate = self._scale_constant * (dt - self._k) ** 3 + self._w_max return new_rate def error_received(self, current_rate, timestamp): # Consider not having this be the current measured rate. # We have a new max rate, which is the current rate we were sending # at when we received an error response. self._w_max = current_rate self._k = self._calculate_zero_point() self._last_fail = timestamp return current_rate * self._beta def get_params_snapshot(self): """Return a read-only object of the current cubic parameters. These parameters are intended to be used for debug/troubleshooting purposes. These object is a read-only snapshot and cannot be used to modify the behavior of the CUBIC calculations. New parameters may be added to this object in the future. """ return CubicParams( w_max=self._w_max, k=self._k, last_fail=self._last_fail ) base.py 0000644 00000001435 15030215750 0006031 0 ustar 00 class BaseRetryBackoff: def delay_amount(self, context): """Calculate how long we should delay before retrying. :type context: RetryContext """ raise NotImplementedError("delay_amount") class BaseRetryableChecker: """Base class for determining if a retry should happen. This base class checks for specific retryable conditions. A single retryable checker doesn't necessarily indicate a retry will happen. It's up to the ``RetryPolicy`` to use its ``BaseRetryableCheckers`` to make the final decision on whether a retry should happen. """ def is_retryable(self, context): """Returns True if retryable, False if not. :type context: RetryContext """ raise NotImplementedError("is_retryable") __pycache__/throttling.cpython-310.pyc 0000644 00000003701 15030215750 0013652 0 ustar 00 o �h� � @ s, d dl mZ edg d��ZG dd� d�ZdS )� )� namedtuple� CubicParams��w_max�k� last_failc @ sB e Zd ZdZdZeefdd�Zdd� Zdd� Zd d � Zd d � Z d S )�CubicCalculatorg�������?gffffff�?c C s& || _ || _|| _| �� | _|| _d S �N)�_w_max�_scale_constant�_beta�_calculate_zero_point�_k� _last_fail)�self�starting_max_rate� start_time�scale_constant�beta� r �N/usr/local/CyberCP/lib/python3.10/site-packages/botocore/retries/throttling.py�__init__ s zCubicCalculator.__init__c C s" | j d| j | j }|d }|S )N� gUUUUUU�?)r r r )r � scaled_valuer r r r r s z%CubicCalculator._calculate_zero_pointc C s( || j }| j|| j d | j }|S )N� )r r r r )r � timestamp�dt�new_rater r r �success_received s z CubicCalculator.success_receivedc C s || _ | �� | _|| _|| j S r )r r r r r )r � current_rater r r r �error_received! s z CubicCalculator.error_receivedc C s t | j| j| jd�S )aX Return a read-only object of the current cubic parameters. These parameters are intended to be used for debug/troubleshooting purposes. These object is a read-only snapshot and cannot be used to modify the behavior of the CUBIC calculations. New parameters may be added to this object in the future. r )r r r r )r r r r �get_params_snapshot+ s �z#CubicCalculator.get_params_snapshotN) �__name__� __module__� __qualname__�_SCALE_CONSTANT�_BETAr r r r r! r r r r r s � r N)� collectionsr r r r r r r �<module> s __pycache__/__init__.cpython-310.pyc 0000644 00000000447 15030215750 0013217 0 ustar 00 o �hy � @ s d Z dS )zrNew retry v2 handlers. This package obsoletes the botocore/retryhandler.py module and contains new retry logic. N)�__doc__� r r �L/usr/local/CyberCP/lib/python3.10/site-packages/botocore/retries/__init__.py�<module> s __pycache__/standard.cpython-310.pyc 0000644 00000037063 15030215750 0013264 0 ustar 00 o �hN � @ s< d Z ddlZddlZddlmZmZmZmZ ddlm Z m Z ddl m Z m Z dZe�e�Zefdd�ZG d d � d �ZG d d � d �ZG d d� d�ZG dd� d�ZG dd� de �ZG dd� de �ZG dd� de �ZG dd� de �ZG dd� de �ZG dd � d �Z G d d � d �Z G d d � d e �Z G d!d"� d"e �Z G d#d$� d$�Z dS )%aC Standard retry behavior. This contains the default standard retry behavior. It provides consistent behavior with other AWS SDKs. The key base classes uses for retries: * ``BaseRetryableChecker`` - Use to check a specific condition that indicates a retry should happen. This can include things like max attempts, HTTP status code checks, error code checks etc. * ``RetryBackoff`` - Use to determine how long we should backoff until we retry a request. This is the class that will implement delay such as exponential backoff. * ``RetryPolicy`` - Main class that determines if a retry should happen. It can combine data from a various BaseRetryableCheckers to make a final call as to whether or not a retry should happen. It then uses a ``BaseRetryBackoff`` to determine how long to delay. * ``RetryHandler`` - The bridge between botocore's event system used by endpoint.py to manage retries and the interfaces defined in this module. This allows us to define an API that has minimal coupling to the event based API used by botocore. � N)�ConnectionError�ConnectTimeoutError�HTTPClientError�ReadTimeoutError)�quota�special)�BaseRetryableChecker�BaseRetryBackoff� c C s� t t�� �}| jjj}|�� }| jj�d|� �|j � t t t |d�t � d�t� |d�}d|� �}| jjjd|� �|j|d� |S )Nz after-call.)� max_attempts)� retry_checker� retry_backoff)� retry_policy�retry_event_adapter� retry_quotaz retry-config-z needs-retry.)� unique_id)�RetryQuotaCheckerr � RetryQuota�meta� service_model� service_id� hyphenize�events�register�release_retry_quota� RetryHandler� RetryPolicy�StandardRetryConditions�ExponentialBackoff�RetryEventAdapter� needs_retry)�clientr r r �service_event_name�handlerr � r$ �L/usr/local/CyberCP/lib/python3.10/site-packages/botocore/retries/standard.py�register_retry_handler+ s* ��� �r& c @ � e Zd ZdZdd� Zdd� ZdS )r z�Bridge between botocore's event system and this module. This class is intended to be hooked to botocore's event system as an event handler. c C s || _ || _|| _d S �N)� _retry_policy�_retry_event_adapter� _retry_quota)�selfr r r r$ r$ r% �__init__M s zRetryHandler.__init__c K sn d}| j jdi |��}| j�|�r*| j�|�r$| j�|�}t�d|� n t�d� nt�d� | j � |� |S )z.Connect as a handler to the needs-retry event.Nz1Retry needed, retrying request after delay of: %sz;Retry needed but retry quota reached, not retrying request.zNot retrying request.r$ ) r* �create_retry_contextr) � should_retryr+ �acquire_retry_quota�compute_retry_delay�logger�debug�!adapt_retry_response_from_context)r, �kwargs� retry_delay�contextr$ r$ r% r R s �� zRetryHandler.needs_retryN)�__name__� __module__� __qualname__�__doc__r- r r$ r$ r$ r% r F s r c @ r' )r a{ Adapter to existing retry interface used in the endpoints layer. This existing interface for determining if a retry needs to happen is event based and used in ``botocore.endpoint``. The interface has grown organically over the years and could use some cleanup. This adapter converts that interface into the interface used by the new retry strategies. c K sN |d }|du r d}d}n|\}}t |d |d |||d |d d d�}|S ) z+Create context based on needs-retry kwargs.�responseN�attempts� operation�caught_exception� request_dictr7 )�attempt_number�operation_model� http_response�parsed_responser? �request_context)� RetryContext)r, r5 r< rC rD r7 r$ r$ r% r. u s �z&RetryEventAdapter.create_retry_contextc C s. |� � }|jdur|j�di ��|� dS dS )z/Modify response back to user back from context.N�ResponseMetadata)�get_retry_metadatarD � setdefault�update)r, r7 �metadatar$ r$ r% r4 � s ��z3RetryEventAdapter.adapt_retry_response_from_contextN)r8 r9 r: r; r. r4 r$ r$ r$ r% r j s r c @ s< e Zd ZdZ d dd�Zdd� Zdd� Zd d � ZdS ) rF a� Normalize a response that we use to check if a retry should occur. This class smoothes over the different types of responses we may get from a service including: * A modeled error response from the service that contains a service code and error message. * A raw HTTP response that doesn't contain service protocol specific error keys. * An exception received while attempting to retrieve a response. This could be a ConnectionError we receive from our HTTP layer which could represent that we weren't able to receive a response from the service. This class guarantees that at least one of the above attributes will be non None. This class is meant to provide a read-only view into the properties associated with a possible retryable response. None of the properties are meant to be modified directly. Nc C s: || _ || _|| _|| _|| _|d u ri }|| _i | _d S r( )rA rB rD rC r? rE �_retry_metadata)r, rA rB rD rC r? rE r$ r$ r% r- � s zRetryContext.__init__c C s4 | j du rdS | j �di �}t|t�sdS |�d�S )z�Check if there was a parsed response with an error code. If we could not find any error codes, ``None`` is returned. N�Error�Code)rD �get� isinstance�dict)r, �errorr$ r$ r% �get_error_code� s zRetryContext.get_error_codec K s | j jdi |�� dS )z�Add key/value pairs to the retry metadata. This allows any objects during the retry process to add metadata about any checks/validations that happened. This gets added to the response metadata in the retry handler. Nr$ )rL rJ )r, r5 r$ r$ r% �add_retry_metadata� s z RetryContext.add_retry_metadatac C s | j �� S r( )rL �copy�r, r$ r$ r% rH � � z RetryContext.get_retry_metadata)NNNNN)r8 r9 r: r; r- rS rT rH r$ r$ r$ r% rF � s � rF c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )r c C s || _ || _d S r( )�_retry_checker�_retry_backoff)r, r r r$ r$ r% r- � s zRetryPolicy.__init__c C � | j �|�S r( )rX � is_retryable�r, r7 r$ r$ r% r/ � � zRetryPolicy.should_retryc C rZ r( )rY � delay_amountr\ r$ r$ r% r1 � r] z RetryPolicy.compute_retry_delayN)r8 r9 r: r- r/ r1 r$ r$ r$ r% r � s r c @ s, e Zd ZdZdZdejfdd�Zdd� ZdS )r � � c C s | j | _|| _|| _d S r( )�_BASE�_base� _max_backoff�_random)r, � max_backoff�randomr$ r$ r% r- s zExponentialBackoff.__init__c C s | � � t| j|jd | j� S )a Calculates delay based on exponential backoff. This class implements truncated binary exponential backoff with jitter:: t_i = rand(0, 1) * min(2 ** attempt, MAX_BACKOFF) where ``i`` is the request attempt (0 based). � )rd �minrb rA rc r\ r$ r$ r% r^ s �z ExponentialBackoff.delay_amountN)r8 r9 r: ra � _MAX_BACKOFFrf r- r^ r$ r$ r$ r% r � s r c @ � e Zd Zdd� Zdd� ZdS )�MaxAttemptsCheckerc C � || _ d S r( )� _max_attempts�r, r r$ r$ r% r- rW zMaxAttemptsChecker.__init__c C sV |j | jk }|j�d�}|rt|�dd�| j�|d< |s)t�d| j� |jdd� |S )N�retries�maxr zMax attempts of %s reached.T)�MaxAttemptsReached)rA rm rE rO rp r2 r3 rT )r, r7 �under_max_attempts�retries_contextr$ r$ r% r[ s � z MaxAttemptsChecker.is_retryableN�r8 r9 r: r- r[ r$ r$ r$ r% rk � rk c @ s< e Zd Zg d�Zg d�ZeefZ ddd�Zdd� Z dS ) �TransientRetryableChecker)�RequestTimeout�RequestTimeoutException�PriorRequestNotComplete)i� i� i� i� Nc C sP |d u r | j d d � }|d u r| jd d � }|d u r | j}|| _|| _|| _d S r( )�_TRANSIENT_ERROR_CODES�_TRANSIENT_STATUS_CODES�_TRANSIENT_EXCEPTION_CLS�_transient_error_codes�_transient_status_codes�_transient_exception_cls)r, �transient_error_codes�transient_status_codes�transient_exception_clsr$ r$ r% r- 6 s z"TransientRetryableChecker.__init__c C sJ |� � | jv r dS |jd ur|jj| jv rdS |jd ur#t|j| j�S dS )NTF)rS r} rC � status_coder~ r? rP r r\ r$ r$ r% r[ F s � �z&TransientRetryableChecker.is_retryable)NNN) r8 r9 r: rz r{ r r r| r- r[ r$ r$ r$ r% rv * s � � rv c @ s& e Zd Zg d�Zddd�Zdd� ZdS )�ThrottledRetryableChecker)� Throttling�ThrottlingException�ThrottledException�RequestThrottledException�TooManyRequestsException�&ProvisionedThroughputExceededException� TransactionInProgressException�RequestLimitExceeded�BandwidthLimitExceeded�LimitExceededException�RequestThrottled�SlowDownry �EC2ThrottledExceptionNc C s |d u r | j d d � }|| _d S r( )�_THROTTLED_ERROR_CODES�_throttled_error_codes)r, �throttled_error_codesr$ r$ r% r- j s z"ThrottledRetryableChecker.__init__c C s |� � | jv S r( )rS r� r\ r$ r$ r% r[ o s z&ThrottledRetryableChecker.is_retryabler( )r8 r9 r: r� r- r[ r$ r$ r$ r% r� V s r� c @ r' )�ModeledRetryableCheckerz0Check if an error has been modeled as retryable.c C s t � | _d S r( )�ModeledRetryErrorDetector�_error_detectorrV r$ r$ r% r- x r] z ModeledRetryableChecker.__init__c C s$ |� � }|d u r dS | j�|�d uS )NF)rS r� �detect_error_type)r, r7 � error_coder$ r$ r% r[ { s z$ModeledRetryableChecker.is_retryableN)r8 r9 r: r; r- r[ r$ r$ r$ r% r� u s r� c @ s e Zd ZdZdZdZdd� ZdS )r� z<Checks whether or not an error is a modeled retryable error.�TRANSIENT_ERROR�THROTTLING_ERRORc C s� |� � }|j}|du s|jsdS |jD ]-}|j�d�dur@|j�di ��d�p)|j}||kr@|jd �d�r;| j S | j S qdS )aC Detect the error type associated with an error code and model. This will either return: * ``self.TRANSIENT_ERROR`` - If the error is a transient error * ``self.THROTTLING_ERROR`` - If the error is a throttling error * ``None`` - If the error is neither type of error. N� retryablerR �code� throttling)rS rB � error_shapesrK rO �namer� r� )r, r7 r� �op_model�shape�error_code_to_checkr$ r$ r% r� � s � ��z+ModeledRetryErrorDetector.detect_error_typeN)r8 r9 r: r; r� r� r� r$ r$ r$ r% r� � s r� c @ rj )�ThrottlingErrorDetectorc C s t � | _t� | _|| _d S r( )r� �_modeled_error_detectorr� �_fixed_error_code_detectorr* )r, r r$ r$ r% r- � s z ThrottlingErrorDetector.__init__c K s: | j jdi |��}| j�|�rdS | j�|�}|| jjkS )NTr$ )r* r. r� r[ r� r� r� )r, r5 r7 � error_typer$ r$ r% �is_throttling_error� s z+ThrottlingErrorDetector.is_throttling_errorN)r8 r9 r: r- r� r$ r$ r$ r% r� � s r� c @ s$ e Zd ZdZefdd�Zdd� ZdS )r z�Concrete class that implements the standard retry policy checks. Specifically: not max_attempts and (transient or throttled or modeled_retry) c C s6 t |�| _tt� t� t� tt�� t�� g�g�| _ d S r( ) rk �_max_attempts_checker�OrRetryCheckerrv r� r� r �RetryIDPCommunicationError�RetryDDBChecksumError�_additional_checkersrn r$ r$ r% r- � s ��� �z StandardRetryConditions.__init__c C s | j �|�o | j�|�S r( )r� r[ r� r\ r$ r$ r% r[ � s � �z$StandardRetryConditions.is_retryableN)r8 r9 r: r; �DEFAULT_MAX_ATTEMPTSr- r[ r$ r$ r$ r% r � s r c @ rj )r� c C rl r( )� _checkers)r, �checkersr$ r$ r% r- � rW zOrRetryChecker.__init__c s t � fdd�| jD ��S )Nc 3 s � | ]}|� � �V qd S r( )r[ )�.0�checker�r7 r$ r% � <genexpr>� s � z.OrRetryChecker.is_retryable.<locals>.<genexpr>)�anyr� r\ r$ r� r% r[ � s zOrRetryChecker.is_retryableNrt r$ r$ r$ r% r� � ru r� c @ s@ e Zd ZdZdZdZeefZdd� Z dd� Z dd � Z d d � Z d S ) r � rg � c C s || _ d | _d S r( )�_quota�_last_amount_acquired)r, r r$ r$ r% r- � s zRetryQuotaChecker.__init__c C sF | � |�r | j}n| j}| j�|�}|r||jd< dS |jdd� dS )N�retry_quota_capacityT)�RetryQuotaReachedF)�_is_timeout_error�_TIMEOUT_RETRY_REQUEST� _RETRY_COSTr� �acquirerE rT )r, r7 �capacity_amount�successr$ r$ r% r0 � s z%RetryQuotaChecker.acquire_retry_quotac C s t |j| j�S r( )rP r? �_TIMEOUT_EXCEPTIONSr\ r$ r$ r% r� � s z#RetryQuotaChecker._is_timeout_errorc K sb |d u rd S |j }d| krdk r/n d S d|vr#| j�| j� d S |d }| j�|� d S d S )N�� i, r� )r� r� �release�_NO_RETRY_INCREMENT)r, r7 rC r5 r� r� r$ r$ r% r s �z%RetryQuotaChecker.release_retry_quotaN) r8 r9 r: r� r� r� r r r� r- r0 r� r r$ r$ r$ r% r � s r )!r; �loggingrf �botocore.exceptionsr r r r �botocore.retriesr r �botocore.retries.baser r r� � getLoggerr8 r2 r& r r rF r r rk rv r� r� r� r� r r� r r$ r$ r$ r% �<module> s. $3S , %! __pycache__/base.cpython-310.pyc 0000644 00000002460 15030215750 0012367 0 ustar 00 o �h � @ s G d d� d�Z G dd� d�ZdS )c @ s e Zd Zdd� ZdS )�BaseRetryBackoffc C � t d��)zbCalculate how long we should delay before retrying. :type context: RetryContext � delay_amount��NotImplementedError��self�context� r �H/usr/local/CyberCP/lib/python3.10/site-packages/botocore/retries/base.pyr s z BaseRetryBackoff.delay_amountN)�__name__� __module__� __qualname__r r r r r r s r c @ s e Zd ZdZdd� ZdS )�BaseRetryableCheckeraW Base class for determining if a retry should happen. This base class checks for specific retryable conditions. A single retryable checker doesn't necessarily indicate a retry will happen. It's up to the ``RetryPolicy`` to use its ``BaseRetryableCheckers`` to make the final decision on whether a retry should happen. c C r )zVReturns True if retryable, False if not. :type context: RetryContext � is_retryabler r r r r r s z!BaseRetryableChecker.is_retryableN)r r r �__doc__r r r r r r s r N)r r r r r r �<module> s __pycache__/special.cpython-310.pyc 0000644 00000003333 15030215750 0013075 0 ustar 00 o �h� � @ sR d Z ddlZddlmZ ddlmZ e�e�ZG dd� de�Z G dd� de�Z dS ) z�Special cased retries. These are additional retry cases we still have to handle from the legacy retry handler. They don't make sense as part of the standard mode retry module. Ideally we should be able to remove this module. � N)�crc32)�BaseRetryableCheckerc @ s e Zd ZdZdd� ZdS )�RetryIDPCommunicationError�stsc C s( |j jj}|| jkr dS |�� }|dkS )NF�IDPCommunicationError)�operation_model� service_model� service_name� _SERVICE_NAME�get_error_code)�self�contextr � error_code� r �K/usr/local/CyberCP/lib/python3.10/site-packages/botocore/retries/special.py� is_retryable s z'RetryIDPCommunicationError.is_retryableN)�__name__� __module__� __qualname__r r r r r r r s r c @ s e Zd ZdZdZdd� ZdS )�RetryDDBChecksumErrorz x-amz-crc32�dynamodbc C st |j jj}|| jkr dS |jd u rdS |jj�| j�}|d u r!dS t|jj �d@ }|t |�kr8t � d||� dS d S )NFl �� z@DynamoDB crc32 checksum does not match, expected: %s, actual: %sT) r r r r � http_response�headers�get�_CHECKSUM_HEADERr �content�int�logger�debug)r r r �checksum� actual_crc32r r r r " s" ��z"RetryDDBChecksumError.is_retryableN)r r r r r r r r r r r s r ) �__doc__�logging�binasciir �botocore.retries.baser � getLoggerr r r r r r r r �<module> s __pycache__/adaptive.cpython-310.pyc 0000644 00000007027 15030215750 0013256 0 ustar 00 o �ho � @ s^ d dl Z d dlZd dlZd dlmZmZmZ e �e�Z dd� Z G dd� d�Z G dd� d�Z dS ) � N)�bucket�standard� throttlingc C sz t �� }tjd|�� d�}t jd|d�}t|�}tjt� � d�}t |||||d�}| j j � d|j� | j j � d|j� |S ) Nr )�starting_max_rate� start_time� )�max_rate�clock)�retry_event_adapter)� rate_adjustor� rate_clocker� token_bucket�throttling_detectorr z before-sendz needs-retry)r �Clockr �CubicCalculator� current_time� TokenBucket� RateClockerr �ThrottlingErrorDetector�RetryEventAdapter�ClientRateLimiter�meta�events�register�on_sending_request�on_receiving_response)�clientr r r r r �limiter� r �L/usr/local/CyberCP/lib/python3.10/site-packages/botocore/retries/adaptive.py�register_retry_handler s2 �����r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) r g @c C s2 || _ || _|| _|| _|| _d| _t�� | _d S )NF) �_rate_adjustor� _rate_clocker� _token_bucket�_throttling_detector�_clock�_enabled� threading�Lock�_lock)�selfr r r r r r r r �__init__) s zClientRateLimiter.__init__c K s | j r | j�� d S d S �N)r& r# �acquire)r* �request�kwargsr r r r 9 s �z$ClientRateLimiter.on_sending_requestc K s� | j �� }| j�� }| j�D | jjdi |��s | j�|�}n!| j s$|}nt || j j �}| j� ||�}t�d||| j j� d| _ t || j| �| j _ W d � d S 1 sTw Y d S )NzfThrottling response received, new send rate: %s measured rate: %s, token bucket capacity available: %sTr )r" �recordr% r r) r$ �is_throttling_errorr! �success_receivedr& �minr# r �error_received�logger�debug�available_capacity�_MAX_RATE_ADJUST_SCALE)r* r/ � measured_rate� timestamp�new_rate� rate_to_user r r r > s0 ��� �"�z'ClientRateLimiter.on_receiving_responseN)�__name__� __module__� __qualname__r8 r+ r r r r r r r & s r c @ s< e Zd ZdZdZdZeefdd�Zd dd�Zed d � �Z d S ) r z7Tracks the rate at which a client is sending a request.g�������?g �?c C sD || _ d| _|| _t�| j �� �| _d| j | _d| _ t � � | _ d S )Nr r ) r% �_measured_rate� _smoothing�math�floorr � _last_bucket�_TIME_BUCKET_RANGE�_time_bucket_scale�_countr' r( r) )r* r � smoothing�time_bucket_ranger r r r+ c s zRateClocker.__init__r c C s� | j �E | j�� }t�|| j �| j }| j|7 _|| jkr>| jt|| j � }|| j | j d| j | _ d| _|| _| j W d � S 1 sKw Y d S )Nr r ) r) r% r rB rC rF rG rD �floatrA r@ )r* �amount�tr � current_rater r r r0 q s �� �$�zRateClocker.recordc C s | j S r, )r@ )r* r r r r9 � s zRateClocker.measured_rateN)r ) r= r> r? �__doc__�_DEFAULT_SMOOTHINGrE r+ r0 �propertyr9 r r r r r \ s � r ) �loggingrB r' �botocore.retriesr r r � getLoggerr= r5 r r r r r r r �<module> s 6 __pycache__/bucket.cpython-310.pyc 0000644 00000006623 15030215750 0012737 0 ustar 00 o �h� � @ s@ d Z ddlZddlZddlmZ G dd� d�ZG dd� d�ZdS )zEThis module implements token buckets used for client side throttling.� N)�CapacityNotAvailableErrorc @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�Clockc C s d S �N� ��selfr r �J/usr/local/CyberCP/lib/python3.10/site-packages/botocore/retries/bucket.py�__init__ s zClock.__init__c C s t �|� d S r )�time�sleep�r �amountr r r r s z Clock.sleepc C s t � � S r )r r r r r � current_time s zClock.current_timeN)�__name__� __module__� __qualname__r r r r r r r r s r c @ sp e Zd ZdZefdd�Zedd� �Zejdd� �Zedd� �Zed d � �Z dd d�Z dd� Z dd� Z dd� Z dS )� TokenBucketg �?c C sF d | _ d | _d| _|| _d | _|| _t�� | _t� | j�| _ || _ d S )Nr ) � _fill_rate� _max_capacity�_current_capacity�_clock�_last_timestamp� _min_rate� threading�Lock�_lock� Condition�_new_fill_rate_condition�max_rate)r r �clock�min_rater r r r s zTokenBucket.__init__c C � | j S r )r r r r r r " � zTokenBucket.max_ratec C sr | j �, | �� t|| j�| _|dkr|| _nd| _t| j| j�| _| j �� W d � d S 1 s2w Y d S )N� ) r �_refill�maxr r r �minr �notify)r �valuer r r r & s � "�c C r! r )r r r r r � max_capacity; r" zTokenBucket.max_capacityc C r! r )r r r r r �available_capacity? r" z TokenBucket.available_capacityr# Tc C s8 | j � | j||d�W d � S 1 sw Y dS )aJ Acquire token or return amount of time until next token available. If block is True, then this method will block until there's sufficient capacity to acquire the desired amount. If block is False, then this method will return True is capacity was successfully acquired, False otherwise. )r �blockN)r �_acquire)r r r+ r r r �acquireC s $�zTokenBucket.acquirec C sx | � � || jkr| j|8 _dS |st� �| �|�}|dkr3| j�|� | � � | �|�}|dks | j|8 _dS )NTr )r$ r r � _sleep_amountr �wait)r r r+ � sleep_amountr r r r, P s � zTokenBucket._acquirec C s || j | j S r )r r r r r r r. g s zTokenBucket._sleep_amountc C sT | j �� }| jd u r|| _d S | j}|| j | j }t| j|| �}|| _|| _d S r )r r r r r r& r )r � timestamp�current_capacity� fill_amount� new_capacityr r r r$ j s zTokenBucket._refillN)r# T)r r r � _MIN_RATEr �propertyr �setterr) r* r- r, r. r$ r r r r r s r )�__doc__r r �botocore.exceptionsr r r r r r r �<module> s __pycache__/quota.cpython-310.pyc 0000644 00000003323 15030215750 0012605 0 ustar 00 o �h� � @ s d Z ddlZG dd� d�ZdS )zRetry quota implementation.� Nc @ s: e Zd ZdZedfdd�Zdd� Zdd� Zed d � �ZdS ) � RetryQuotai� Nc C s& || _ || _|d u rt�� }|| _d S �N)� _max_capacity�_available_capacity� threading�Lock�_lock)�self�initial_capacity�lock� r �I/usr/local/CyberCP/lib/python3.10/site-packages/botocore/retries/quota.py�__init__ s zRetryQuota.__init__c C sX | j � || jkr W d � dS | j|8 _ W d � dS 1 s%w Y dS )z�Attempt to aquire a certain amount of capacity. If there's not sufficient amount of capacity available, ``False`` is returned. Otherwise, ``True`` is returned, which indicates that capacity was successfully allocated. NFT)r r )r �capacity_amountr r r �acquire s �$�zRetryQuota.acquirec C s\ | j | jkrdS | j� t| j | j |�}| j|7 _W d � dS 1 s'w Y dS )z�Release capacity back to the retry quota. The capacity being released will be truncated if necessary to ensure the max capacity is never exceeded. N)r r r �min)r r �amountr r r �release s �"�zRetryQuota.releasec C s | j S r )r )r r r r �available_capacity4 s z RetryQuota.available_capacity) �__name__� __module__� __qualname__�INITIAL_CAPACITYr r r �propertyr r r r r r s r )�__doc__r r r r r r �<module> s bucket.py 0000644 00000007632 15030215750 0006401 0 ustar 00 """This module implements token buckets used for client side throttling.""" import threading import time from botocore.exceptions import CapacityNotAvailableError class Clock: def __init__(self): pass def sleep(self, amount): time.sleep(amount) def current_time(self): return time.time() class TokenBucket: _MIN_RATE = 0.5 def __init__(self, max_rate, clock, min_rate=_MIN_RATE): self._fill_rate = None self._max_capacity = None self._current_capacity = 0 self._clock = clock self._last_timestamp = None self._min_rate = min_rate self._lock = threading.Lock() self._new_fill_rate_condition = threading.Condition(self._lock) self.max_rate = max_rate @property def max_rate(self): return self._fill_rate @max_rate.setter def max_rate(self, value): with self._new_fill_rate_condition: # Before we can change the rate we need to fill any pending # tokens we might have based on the current rate. If we don't # do this it means everything since the last recorded timestamp # will accumulate at the rate we're about to set which isn't # correct. self._refill() self._fill_rate = max(value, self._min_rate) if value >= 1: self._max_capacity = value else: self._max_capacity = 1 # If we're scaling down, we also can't have a capacity that's # more than our max_capacity. self._current_capacity = min( self._current_capacity, self._max_capacity ) self._new_fill_rate_condition.notify() @property def max_capacity(self): return self._max_capacity @property def available_capacity(self): return self._current_capacity def acquire(self, amount=1, block=True): """Acquire token or return amount of time until next token available. If block is True, then this method will block until there's sufficient capacity to acquire the desired amount. If block is False, then this method will return True is capacity was successfully acquired, False otherwise. """ with self._new_fill_rate_condition: return self._acquire(amount=amount, block=block) def _acquire(self, amount, block): self._refill() if amount <= self._current_capacity: self._current_capacity -= amount return True else: if not block: raise CapacityNotAvailableError() # Not enough capacity. sleep_amount = self._sleep_amount(amount) while sleep_amount > 0: # Until python3.2, wait() always returned None so we can't # tell if a timeout occurred waiting on the cond var. # Because of this we'll unconditionally call _refill(). # The downside to this is that we were waken up via # a notify(), we're calling unnecessarily calling _refill() an # extra time. self._new_fill_rate_condition.wait(sleep_amount) self._refill() sleep_amount = self._sleep_amount(amount) self._current_capacity -= amount return True def _sleep_amount(self, amount): return (amount - self._current_capacity) / self._fill_rate def _refill(self): timestamp = self._clock.current_time() if self._last_timestamp is None: self._last_timestamp = timestamp return current_capacity = self._current_capacity fill_amount = (timestamp - self._last_timestamp) * self._fill_rate new_capacity = min(self._max_capacity, current_capacity + fill_amount) self._current_capacity = new_capacity self._last_timestamp = timestamp standard.py 0000644 00000047003 15030215750 0006720 0 ustar 00 """Standard retry behavior. This contains the default standard retry behavior. It provides consistent behavior with other AWS SDKs. The key base classes uses for retries: * ``BaseRetryableChecker`` - Use to check a specific condition that indicates a retry should happen. This can include things like max attempts, HTTP status code checks, error code checks etc. * ``RetryBackoff`` - Use to determine how long we should backoff until we retry a request. This is the class that will implement delay such as exponential backoff. * ``RetryPolicy`` - Main class that determines if a retry should happen. It can combine data from a various BaseRetryableCheckers to make a final call as to whether or not a retry should happen. It then uses a ``BaseRetryBackoff`` to determine how long to delay. * ``RetryHandler`` - The bridge between botocore's event system used by endpoint.py to manage retries and the interfaces defined in this module. This allows us to define an API that has minimal coupling to the event based API used by botocore. """ import logging import random from botocore.exceptions import ( ConnectionError, ConnectTimeoutError, HTTPClientError, ReadTimeoutError, ) from botocore.retries import quota, special from botocore.retries.base import BaseRetryableChecker, BaseRetryBackoff DEFAULT_MAX_ATTEMPTS = 3 logger = logging.getLogger(__name__) def register_retry_handler(client, max_attempts=DEFAULT_MAX_ATTEMPTS): retry_quota = RetryQuotaChecker(quota.RetryQuota()) service_id = client.meta.service_model.service_id service_event_name = service_id.hyphenize() client.meta.events.register( f'after-call.{service_event_name}', retry_quota.release_retry_quota ) handler = RetryHandler( retry_policy=RetryPolicy( retry_checker=StandardRetryConditions(max_attempts=max_attempts), retry_backoff=ExponentialBackoff(), ), retry_event_adapter=RetryEventAdapter(), retry_quota=retry_quota, ) unique_id = f'retry-config-{service_event_name}' client.meta.events.register( f'needs-retry.{service_event_name}', handler.needs_retry, unique_id=unique_id, ) return handler class RetryHandler: """Bridge between botocore's event system and this module. This class is intended to be hooked to botocore's event system as an event handler. """ def __init__(self, retry_policy, retry_event_adapter, retry_quota): self._retry_policy = retry_policy self._retry_event_adapter = retry_event_adapter self._retry_quota = retry_quota def needs_retry(self, **kwargs): """Connect as a handler to the needs-retry event.""" retry_delay = None context = self._retry_event_adapter.create_retry_context(**kwargs) if self._retry_policy.should_retry(context): # Before we can retry we need to ensure we have sufficient # capacity in our retry quota. if self._retry_quota.acquire_retry_quota(context): retry_delay = self._retry_policy.compute_retry_delay(context) logger.debug( "Retry needed, retrying request after delay of: %s", retry_delay, ) else: logger.debug( "Retry needed but retry quota reached, " "not retrying request." ) else: logger.debug("Not retrying request.") self._retry_event_adapter.adapt_retry_response_from_context(context) return retry_delay class RetryEventAdapter: """Adapter to existing retry interface used in the endpoints layer. This existing interface for determining if a retry needs to happen is event based and used in ``botocore.endpoint``. The interface has grown organically over the years and could use some cleanup. This adapter converts that interface into the interface used by the new retry strategies. """ def create_retry_context(self, **kwargs): """Create context based on needs-retry kwargs.""" response = kwargs['response'] if response is None: # If response is None it means that an exception was raised # because we never received a response from the service. This # could be something like a ConnectionError we get from our # http layer. http_response = None parsed_response = None else: http_response, parsed_response = response # This provides isolation between the kwargs emitted in the # needs-retry event, and what this module uses to check for # retries. context = RetryContext( attempt_number=kwargs['attempts'], operation_model=kwargs['operation'], http_response=http_response, parsed_response=parsed_response, caught_exception=kwargs['caught_exception'], request_context=kwargs['request_dict']['context'], ) return context def adapt_retry_response_from_context(self, context): """Modify response back to user back from context.""" # This will mutate attributes that are returned back to the end # user. We do it this way so that all the various retry classes # don't mutate any input parameters from the needs-retry event. metadata = context.get_retry_metadata() if context.parsed_response is not None: context.parsed_response.setdefault('ResponseMetadata', {}).update( metadata ) # Implementation note: this is meant to encapsulate all the misc stuff # that gets sent in the needs-retry event. This is mapped so that params # are more clear and explicit. class RetryContext: """Normalize a response that we use to check if a retry should occur. This class smoothes over the different types of responses we may get from a service including: * A modeled error response from the service that contains a service code and error message. * A raw HTTP response that doesn't contain service protocol specific error keys. * An exception received while attempting to retrieve a response. This could be a ConnectionError we receive from our HTTP layer which could represent that we weren't able to receive a response from the service. This class guarantees that at least one of the above attributes will be non None. This class is meant to provide a read-only view into the properties associated with a possible retryable response. None of the properties are meant to be modified directly. """ def __init__( self, attempt_number, operation_model=None, parsed_response=None, http_response=None, caught_exception=None, request_context=None, ): # 1-based attempt number. self.attempt_number = attempt_number self.operation_model = operation_model # This is the parsed response dictionary we get from parsing # the HTTP response from the service. self.parsed_response = parsed_response # This is an instance of botocore.awsrequest.AWSResponse. self.http_response = http_response # This is a subclass of Exception that will be non None if # an exception was raised when retrying to retrieve a response. self.caught_exception = caught_exception # This is the request context dictionary that's added to the # request dict. This is used to story any additional state # about the request. We use this for storing retry quota # capacity. if request_context is None: request_context = {} self.request_context = request_context self._retry_metadata = {} # These are misc helper methods to avoid duplication in the various # checkers. def get_error_code(self): """Check if there was a parsed response with an error code. If we could not find any error codes, ``None`` is returned. """ if self.parsed_response is None: return error = self.parsed_response.get('Error', {}) if not isinstance(error, dict): return return error.get('Code') def add_retry_metadata(self, **kwargs): """Add key/value pairs to the retry metadata. This allows any objects during the retry process to add metadata about any checks/validations that happened. This gets added to the response metadata in the retry handler. """ self._retry_metadata.update(**kwargs) def get_retry_metadata(self): return self._retry_metadata.copy() class RetryPolicy: def __init__(self, retry_checker, retry_backoff): self._retry_checker = retry_checker self._retry_backoff = retry_backoff def should_retry(self, context): return self._retry_checker.is_retryable(context) def compute_retry_delay(self, context): return self._retry_backoff.delay_amount(context) class ExponentialBackoff(BaseRetryBackoff): _BASE = 2 _MAX_BACKOFF = 20 def __init__(self, max_backoff=20, random=random.random): self._base = self._BASE self._max_backoff = max_backoff self._random = random def delay_amount(self, context): """Calculates delay based on exponential backoff. This class implements truncated binary exponential backoff with jitter:: t_i = rand(0, 1) * min(2 ** attempt, MAX_BACKOFF) where ``i`` is the request attempt (0 based). """ # The context.attempt_number is a 1-based value, but we have # to calculate the delay based on i based a 0-based value. We # want the first delay to just be ``rand(0, 1)``. return self._random() * min( (self._base ** (context.attempt_number - 1)), self._max_backoff, ) class MaxAttemptsChecker(BaseRetryableChecker): def __init__(self, max_attempts): self._max_attempts = max_attempts def is_retryable(self, context): under_max_attempts = context.attempt_number < self._max_attempts retries_context = context.request_context.get('retries') if retries_context: retries_context['max'] = max( retries_context.get('max', 0), self._max_attempts ) if not under_max_attempts: logger.debug("Max attempts of %s reached.", self._max_attempts) context.add_retry_metadata(MaxAttemptsReached=True) return under_max_attempts class TransientRetryableChecker(BaseRetryableChecker): _TRANSIENT_ERROR_CODES = [ 'RequestTimeout', 'RequestTimeoutException', 'PriorRequestNotComplete', ] _TRANSIENT_STATUS_CODES = [500, 502, 503, 504] _TRANSIENT_EXCEPTION_CLS = ( ConnectionError, HTTPClientError, ) def __init__( self, transient_error_codes=None, transient_status_codes=None, transient_exception_cls=None, ): if transient_error_codes is None: transient_error_codes = self._TRANSIENT_ERROR_CODES[:] if transient_status_codes is None: transient_status_codes = self._TRANSIENT_STATUS_CODES[:] if transient_exception_cls is None: transient_exception_cls = self._TRANSIENT_EXCEPTION_CLS self._transient_error_codes = transient_error_codes self._transient_status_codes = transient_status_codes self._transient_exception_cls = transient_exception_cls def is_retryable(self, context): if context.get_error_code() in self._transient_error_codes: return True if context.http_response is not None: if ( context.http_response.status_code in self._transient_status_codes ): return True if context.caught_exception is not None: return isinstance( context.caught_exception, self._transient_exception_cls ) return False class ThrottledRetryableChecker(BaseRetryableChecker): # This is the union of all error codes we've seen that represent # a throttled error. _THROTTLED_ERROR_CODES = [ 'Throttling', 'ThrottlingException', 'ThrottledException', 'RequestThrottledException', 'TooManyRequestsException', 'ProvisionedThroughputExceededException', 'TransactionInProgressException', 'RequestLimitExceeded', 'BandwidthLimitExceeded', 'LimitExceededException', 'RequestThrottled', 'SlowDown', 'PriorRequestNotComplete', 'EC2ThrottledException', ] def __init__(self, throttled_error_codes=None): if throttled_error_codes is None: throttled_error_codes = self._THROTTLED_ERROR_CODES[:] self._throttled_error_codes = throttled_error_codes def is_retryable(self, context): # Only the error code from a parsed service response is used # to determine if the response is a throttled response. return context.get_error_code() in self._throttled_error_codes class ModeledRetryableChecker(BaseRetryableChecker): """Check if an error has been modeled as retryable.""" def __init__(self): self._error_detector = ModeledRetryErrorDetector() def is_retryable(self, context): error_code = context.get_error_code() if error_code is None: return False return self._error_detector.detect_error_type(context) is not None class ModeledRetryErrorDetector: """Checks whether or not an error is a modeled retryable error.""" # There are return values from the detect_error_type() method. TRANSIENT_ERROR = 'TRANSIENT_ERROR' THROTTLING_ERROR = 'THROTTLING_ERROR' # This class is lower level than ModeledRetryableChecker, which # implements BaseRetryableChecker. This object allows you to distinguish # between the various types of retryable errors. def detect_error_type(self, context): """Detect the error type associated with an error code and model. This will either return: * ``self.TRANSIENT_ERROR`` - If the error is a transient error * ``self.THROTTLING_ERROR`` - If the error is a throttling error * ``None`` - If the error is neither type of error. """ error_code = context.get_error_code() op_model = context.operation_model if op_model is None or not op_model.error_shapes: return for shape in op_model.error_shapes: if shape.metadata.get('retryable') is not None: # Check if this error code matches the shape. This can # be either by name or by a modeled error code. error_code_to_check = ( shape.metadata.get('error', {}).get('code') or shape.name ) if error_code == error_code_to_check: if shape.metadata['retryable'].get('throttling'): return self.THROTTLING_ERROR return self.TRANSIENT_ERROR class ThrottlingErrorDetector: def __init__(self, retry_event_adapter): self._modeled_error_detector = ModeledRetryErrorDetector() self._fixed_error_code_detector = ThrottledRetryableChecker() self._retry_event_adapter = retry_event_adapter # This expects the kwargs from needs-retry to be passed through. def is_throttling_error(self, **kwargs): context = self._retry_event_adapter.create_retry_context(**kwargs) if self._fixed_error_code_detector.is_retryable(context): return True error_type = self._modeled_error_detector.detect_error_type(context) return error_type == self._modeled_error_detector.THROTTLING_ERROR class StandardRetryConditions(BaseRetryableChecker): """Concrete class that implements the standard retry policy checks. Specifically: not max_attempts and (transient or throttled or modeled_retry) """ def __init__(self, max_attempts=DEFAULT_MAX_ATTEMPTS): # Note: This class is for convenience so you can have the # standard retry condition in a single class. self._max_attempts_checker = MaxAttemptsChecker(max_attempts) self._additional_checkers = OrRetryChecker( [ TransientRetryableChecker(), ThrottledRetryableChecker(), ModeledRetryableChecker(), OrRetryChecker( [ special.RetryIDPCommunicationError(), special.RetryDDBChecksumError(), ] ), ] ) def is_retryable(self, context): return self._max_attempts_checker.is_retryable( context ) and self._additional_checkers.is_retryable(context) class OrRetryChecker(BaseRetryableChecker): def __init__(self, checkers): self._checkers = checkers def is_retryable(self, context): return any(checker.is_retryable(context) for checker in self._checkers) class RetryQuotaChecker: _RETRY_COST = 5 _NO_RETRY_INCREMENT = 1 _TIMEOUT_RETRY_REQUEST = 10 _TIMEOUT_EXCEPTIONS = (ConnectTimeoutError, ReadTimeoutError) # Implementation note: We're not making this a BaseRetryableChecker # because this isn't just a check if we can retry. This also changes # state so we have to careful when/how we call this. Making it # a BaseRetryableChecker implies you can call .is_retryable(context) # as many times as you want and not affect anything. def __init__(self, quota): self._quota = quota # This tracks the last amount self._last_amount_acquired = None def acquire_retry_quota(self, context): if self._is_timeout_error(context): capacity_amount = self._TIMEOUT_RETRY_REQUEST else: capacity_amount = self._RETRY_COST success = self._quota.acquire(capacity_amount) if success: # We add the capacity amount to the request context so we know # how much to release later. The capacity amount can vary based # on the error. context.request_context['retry_quota_capacity'] = capacity_amount return True context.add_retry_metadata(RetryQuotaReached=True) return False def _is_timeout_error(self, context): return isinstance(context.caught_exception, self._TIMEOUT_EXCEPTIONS) # This is intended to be hooked up to ``after-call``. def release_retry_quota(self, context, http_response, **kwargs): # There's three possible options. # 1. The HTTP response did not have a 2xx response. In that case we # give no quota back. # 2. The HTTP request was successful and was never retried. In # that case we give _NO_RETRY_INCREMENT back. # 3. The API call had retries, and we eventually receive an HTTP # response with a 2xx status code. In that case we give back # whatever quota was associated with the last acquisition. if http_response is None: return status_code = http_response.status_code if 200 <= status_code < 300: if 'retry_quota_capacity' not in context: self._quota.release(self._NO_RETRY_INCREMENT) else: capacity_amount = context['retry_quota_capacity'] self._quota.release(capacity_amount) special.py 0000644 00000003200 15030215750 0006527 0 ustar 00 """Special cased retries. These are additional retry cases we still have to handle from the legacy retry handler. They don't make sense as part of the standard mode retry module. Ideally we should be able to remove this module. """ import logging from binascii import crc32 from botocore.retries.base import BaseRetryableChecker logger = logging.getLogger(__name__) # TODO: This is an ideal candidate for the retryable trait once that's # available. class RetryIDPCommunicationError(BaseRetryableChecker): _SERVICE_NAME = 'sts' def is_retryable(self, context): service_name = context.operation_model.service_model.service_name if service_name != self._SERVICE_NAME: return False error_code = context.get_error_code() return error_code == 'IDPCommunicationError' class RetryDDBChecksumError(BaseRetryableChecker): _CHECKSUM_HEADER = 'x-amz-crc32' _SERVICE_NAME = 'dynamodb' def is_retryable(self, context): service_name = context.operation_model.service_model.service_name if service_name != self._SERVICE_NAME: return False if context.http_response is None: return False checksum = context.http_response.headers.get(self._CHECKSUM_HEADER) if checksum is None: return False actual_crc32 = crc32(context.http_response.content) & 0xFFFFFFFF if actual_crc32 != int(checksum): logger.debug( "DynamoDB crc32 checksum does not match, " "expected: %s, actual: %s", checksum, actual_crc32, ) return True adaptive.py 0000644 00000010157 15030215750 0006715 0 ustar 00 import logging import math import threading from botocore.retries import bucket, standard, throttling logger = logging.getLogger(__name__) def register_retry_handler(client): clock = bucket.Clock() rate_adjustor = throttling.CubicCalculator( starting_max_rate=0, start_time=clock.current_time() ) token_bucket = bucket.TokenBucket(max_rate=1, clock=clock) rate_clocker = RateClocker(clock) throttling_detector = standard.ThrottlingErrorDetector( retry_event_adapter=standard.RetryEventAdapter(), ) limiter = ClientRateLimiter( rate_adjustor=rate_adjustor, rate_clocker=rate_clocker, token_bucket=token_bucket, throttling_detector=throttling_detector, clock=clock, ) client.meta.events.register( 'before-send', limiter.on_sending_request, ) client.meta.events.register( 'needs-retry', limiter.on_receiving_response, ) return limiter class ClientRateLimiter: _MAX_RATE_ADJUST_SCALE = 2.0 def __init__( self, rate_adjustor, rate_clocker, token_bucket, throttling_detector, clock, ): self._rate_adjustor = rate_adjustor self._rate_clocker = rate_clocker self._token_bucket = token_bucket self._throttling_detector = throttling_detector self._clock = clock self._enabled = False self._lock = threading.Lock() def on_sending_request(self, request, **kwargs): if self._enabled: self._token_bucket.acquire() # Hooked up to needs-retry. def on_receiving_response(self, **kwargs): measured_rate = self._rate_clocker.record() timestamp = self._clock.current_time() with self._lock: if not self._throttling_detector.is_throttling_error(**kwargs): new_rate = self._rate_adjustor.success_received(timestamp) else: if not self._enabled: rate_to_use = measured_rate else: rate_to_use = min( measured_rate, self._token_bucket.max_rate ) new_rate = self._rate_adjustor.error_received( rate_to_use, timestamp ) logger.debug( "Throttling response received, new send rate: %s " "measured rate: %s, token bucket capacity " "available: %s", new_rate, measured_rate, self._token_bucket.available_capacity, ) self._enabled = True self._token_bucket.max_rate = min( new_rate, self._MAX_RATE_ADJUST_SCALE * measured_rate ) class RateClocker: """Tracks the rate at which a client is sending a request.""" _DEFAULT_SMOOTHING = 0.8 # Update the rate every _TIME_BUCKET_RANGE seconds. _TIME_BUCKET_RANGE = 0.5 def __init__( self, clock, smoothing=_DEFAULT_SMOOTHING, time_bucket_range=_TIME_BUCKET_RANGE, ): self._clock = clock self._measured_rate = 0 self._smoothing = smoothing self._last_bucket = math.floor(self._clock.current_time()) self._time_bucket_scale = 1 / self._TIME_BUCKET_RANGE self._count = 0 self._lock = threading.Lock() def record(self, amount=1): with self._lock: t = self._clock.current_time() bucket = ( math.floor(t * self._time_bucket_scale) / self._time_bucket_scale ) self._count += amount if bucket > self._last_bucket: current_rate = self._count / float(bucket - self._last_bucket) self._measured_rate = (current_rate * self._smoothing) + ( self._measured_rate * (1 - self._smoothing) ) self._count = 0 self._last_bucket = bucket return self._measured_rate @property def measured_rate(self): return self._measured_rate quota.py 0000644 00000003621 15030215750 0006247 0 ustar 00 """Retry quota implementation.""" import threading class RetryQuota: INITIAL_CAPACITY = 500 def __init__(self, initial_capacity=INITIAL_CAPACITY, lock=None): self._max_capacity = initial_capacity self._available_capacity = initial_capacity if lock is None: lock = threading.Lock() self._lock = lock def acquire(self, capacity_amount): """Attempt to aquire a certain amount of capacity. If there's not sufficient amount of capacity available, ``False`` is returned. Otherwise, ``True`` is returned, which indicates that capacity was successfully allocated. """ # The acquire() is only called when we encounter a retryable # response so we aren't worried about locking the entire method. with self._lock: if capacity_amount > self._available_capacity: return False self._available_capacity -= capacity_amount return True def release(self, capacity_amount): """Release capacity back to the retry quota. The capacity being released will be truncated if necessary to ensure the max capacity is never exceeded. """ # Implementation note: The release() method is called as part # of the "after-call" event, which means it gets invoked for # every API call. In the common case where the request is # successful and we're at full capacity, we can avoid locking. # We can't exceed max capacity so there's no work we have to do. if self._max_capacity == self._available_capacity: return with self._lock: amount = min( self._max_capacity - self._available_capacity, capacity_amount ) self._available_capacity += amount @property def available_capacity(self): return self._available_capacity __init__.py 0000644 00000000171 15030215750 0006652 0 ustar 00 """New retry v2 handlers. This package obsoletes the botocore/retryhandler.py module and contains new retry logic. """
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings