File: //usr/lib/python3.9/site-packages/redis/__pycache__/connection.cpython-39.opt-1.pyc
a
��b� �
@ s� d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlmZ d dl m
Z
m Z m Z d dl
m
Z
d dlmZmZmZ d dlmZ d dlmZ d dlmZmZmZmZmZm Z m Z m Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z% d d l&m'Z' d d
l(m)Z)m*Z*m+Z+ zd dl,Z,d Z-W n e.�y d Z-Y n0 e/ej0iZ1e-�rZe2e,d
��rPde1e,j3< de1e,j4< n
de1e,j5< e6e1�7� �Z8e*�r�d dl9Z9ee9j:�Z;e;ed�kZ<e;ed�kZ=e;ed�kZ>d Z?e=�s�d Z?dZ@dZAdZBdZCdZDeE� ZFdZGdZHdZIdZJG dd � d �ZKG d d � d �ZLG d d � d �ZMG d!d"� d"eL�ZNG d#d$� d$eL�ZOe*�r0eOZPneNZPG d%d&� d&�ZQG d'd(� d(eQ�ZRG d)d*� d*eQ�ZSd+ZTd,d-� ZUeVeWeWeUeUeXeVeVeUd.� ZYd/d0� ZZG d1d2� d2�Z[G d3d4� d4e[�Z\dS )5� N)�chain)�Empty�Full� LifoQueue)�time)�parse_qs�unquote�urlparse)�Version)� NoBackoff)�AuthenticationError�$AuthenticationWrongNumberOfArgsError�BusyLoadingError�ChildDeadlockedError�ConnectionError� DataError�ExecAbortError�InvalidResponse� ModuleError�NoPermissionError�
NoScriptError�
ReadOnlyError�
RedisError�
ResponseError� TimeoutError)�Retry)�CRYPTOGRAPHY_AVAILABLE�HIREDIS_AVAILABLE� str_if_bytesTF�SSLWantReadError� z0.1.3z0.1.4z1.0.0� *� $s
� z Connection closed by server.z:Error loading the extension. Please check the server logs.z5Error unloading module: no such module with that namez/Error unloading module: operation not possible.z[Error unloading module: the module exports one or more module-side data types, can't unloadc @ s* e Zd ZdZdd� Zdd� Zd
dd�Zd S ) �Encoderz=Encode strings to bytes-like and decode bytes-like to stringsc C s || _ || _|| _d S �N��encoding�encoding_errors�decode_responses)�selfr' r( r) � r+ �4/usr/lib/python3.9/site-packages/redis/connection.py�__init__X s zEncoder.__init__c C s� t |ttf�r|S t |t�r&td��n@t |ttf�rBt|��� }n$t |t �sft
|�j }td|� d���t |t �r�|�| j | j
�}|S )z=Return a bytestring or bytes-like representation of the valuezNInvalid input of type: 'bool'. Convert to a bytes, string, int or float first.zInvalid input of type: 'z2'. Convert to a bytes, string, int or float first.)�
isinstance�bytes�
memoryview�boolr �int�float�repr�encode�str�type�__name__r' r( )r* �value�typenamer+ r+ r, r5 ] s
�
�
zEncoder.encodeFc C s: | j s
|r6t|t�r |�� }t|t�r6|�| j| j�}|S )z:Return a unicode string from the bytes-like representation)r) r. r0 �tobytesr/ �decoder' r( )r* r9 �forcer+ r+ r, r< t s
zEncoder.decodeN)F)r8 �
__module__� __qualname__�__doc__r- r5 r< r+ r+ r+ r, r$ U s r$ c @ sL e Zd Zdededededeeeeee ee
ei e e e
eeed�Zdd� Zd S )
�
BaseParserz max number of clients reachedz(Client sent AUTH, but no password is setzinvalid passwordz,wrong number of arguments for 'auth' commandz,wrong number of arguments for 'AUTH' command)ZERRZ EXECABORTZLOADINGZNOSCRIPTZREADONLYZNOAUTHZNOPERMc C s\ |� d�d }|| jv rT|t|�d d� }| j| }t|t�rL|�|t�}||�S t|�S )zParse an error response� r � N)�split�EXCEPTION_CLASSES�lenr. �dict�getr )r* �responseZ
error_codeZexception_classr+ r+ r, � parse_error� s
zBaseParser.parse_errorN)r8 r> r? r r r
�MODULE_LOAD_ERRORr � MODULE_EXPORTS_DATA_TYPES_ERROR�NO_SUCH_MODULE_ERROR� MODULE_UNLOAD_NOT_POSSIBLE_ERRORr r r r r rE rJ r+ r+ r+ r, rA ~ s( ��rA c @ sX e Zd Zdd� Zedd� �Zdedfdd�Zd d
� Zd d � Z d
d� Z
dd� Z dd� Z dS )� SocketBufferc C s, || _ || _|| _t�� | _d| _d| _d S �Nr )�_sock�socket_read_size�socket_timeout�io�BytesIO�_buffer�
bytes_written�
bytes_read)r* �socketrR rS r+ r+ r, r- � s
zSocketBuffer.__init__c C s | j | j S r% )rW rX �r* r+ r+ r, �length� s zSocketBuffer.lengthNTc
C s� | j }| j}| j}|�| j� d}|tu}�zLz�|r>|�|� | j �|�} t| t �rht
| �dkrht t ��|�
| � t
| �}
| j|
7 _||
7 }|d ur�||kr�q>W W |r�|�| j� dS tjy� |r�td��Y W |r�|�| j� dS t�yb } z^t�| jd�} |�s>| j| k�r>W Y d } ~ W |�r:|�| j� dS t d| j� ���W Y d } ~ n
d } ~ 0 0 W |�r�|�| j� n|�r�|�| j� 0 d S �Nr TzTimeout reading from socketF���z!Error while reading from socket: )rQ rR rV �seekrW �SENTINEL�
settimeout�recvr. r/ rF r � SERVER_CLOSED_CONNECTION_ERROR�writerS rY �timeoutr �NONBLOCKING_EXCEPTIONS�#NONBLOCKING_EXCEPTION_ERROR_NUMBERSrH � __class__�errno�args)
r* r[ rd �raise_on_timeout�sockrR �bufZmarker�custom_timeout�dataZ data_length�ex�allowedr+ r+ r, �_read_from_socket� sR
� � �(�z SocketBuffer._read_from_socketc C s t | j�p| j|dd�S )NF�rd rj )r1 r[ rq �r* rd r+ r+ r, �can_read� s �zSocketBuffer.can_readc C sn |d }|| j kr"| �|| j � | j�| j� | j�|�}| jt|�7 _| j| jkrb| �� |d d� S )Nr ���) r[ rq rV r^ rX �readrF rW �purge)r* r[ rn r+ r+ r, rv � s
zSocketBuffer.readc C st | j }|�| j� |�� }|�t�sB| �� |�| j� |�� }q| jt|�7 _| j| jkrh| � � |d d� S )Nru )
rV r^ rX �readline�endswith�SYM_CRLFrq rF rW rw )r* rl rn r+ r+ r, rx � s
zSocketBuffer.readlinec C s& | j �d� | j �� d| _d| _d S rP )rV r^ �truncaterW rX rZ r+ r+ r, rw s
zSocketBuffer.purgec C s: z| � � | j�� W n ty( Y n0 d | _d | _d S r% )rw rV �close� ExceptionrQ rZ r+ r+ r, r| s zSocketBuffer.close)
r8 r> r? r- �propertyr[ r_ rq rt rv rx rw r| r+ r+ r+ r, rO � s
)rO c @ sB e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zdd
d�Z dS )� PythonParserzPlain Python parsing classc C s || _ d | _d | _d | _d S r% )rR �encoderrQ rV �r* rR r+ r+ r, r- s zPythonParser.__init__c C s$ z | � � W n ty Y n0 d S r% ��
on_disconnectr} rZ r+ r+ r, �__del__$ s zPythonParser.__del__c C s( |j | _ t| j | j|j�| _|j| _dS )z Called when the socket connectsN)rQ rO rR rS rV r� �r* �
connectionr+ r+ r, �
on_connect* s
�zPythonParser.on_connectc C s* d| _ | jdur | j�� d| _d| _dS )z"Called when the socket disconnectsN)rQ rV r| r� rZ r+ r+ r, r� 2 s
zPythonParser.on_disconnectc C s | j o| j �|�S r% )rV rt rs r+ r+ r, rt : s zPythonParser.can_readFc s �j �� }|stt��|d d� |dd � }}|dvrFtd|����|dkrx|jddd�}��|�}t|t�rt|�|S |dkr�np|d kr�t|�}n^|d
kr�t|�}|d kr�d S �j � |�}n4|d kr�t|�}|d kr�d S � �fd
d�t
|�D �}t|t ��r� du �r�j �|�}|S )NrC )� -� +� :r" r! zProtocol Error: r� �utf-8�replace)�errorsr� r� r" r] r! c s g | ]}�j � d ��qS )��disable_decoding)�
read_response)�.0�i�r� r* r+ r, �
<listcomp>e s �z.PythonParser.read_response.<locals>.<listcomp>F)
rV rx r rb r r< rJ r. r2 rv �ranger/ r� )r* r� �rawZbyterI �errorr[ r+ r� r, r� = s>
� zPythonParser.read_responseN)F)
r8 r> r? r@ r- r� r� r� rt r� r+ r+ r+ r, r s r c @ sP e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Ze d fd
d�Z
ddd�Z dS )�
HiredisParserz*Parser class for connections using Hiredisc C s$ t s td��|| _tr t|�| _d S )NzHiredis is not installed)r r rR �HIREDIS_USE_BYTE_BUFFER� bytearrayrV r� r+ r+ r, r- q s
zHiredisParser.__init__c C s$ z | � � W n ty Y n0 d S r% r� rZ r+ r+ r, r� y s zHiredisParser.__del__c K sh |j | _ |j| _t| jd�}ts(t|d< |jjr<|jj |d< t
rL|jj |d< t j
f i |��| _d| _d S )N)Z
protocolError�
replyErrorr� r' r� F)rQ rS �_socket_timeoutr rJ � HIREDIS_SUPPORTS_CALLABLE_ERRORSr r� r) r' � HIREDIS_SUPPORTS_ENCODING_ERRORSr( �hiredis�Reader�_reader�_next_response)r* r� �kwargsr+ r+ r, r� s zHiredisParser.on_connectc C s d | _ d | _d| _d S )NF)rQ r� r� rZ r+ r+ r, r� � s zHiredisParser.on_disconnectc C s@ | j stt��| jdu r<| j �� | _| jdu r<| j|dd�S dS )NFrr T)r� r rb r� �gets�read_from_socketrs r+ r+ r, rt � s
zHiredisParser.can_readTc
C s� | j }|tu}�zVz�|r"|�|� trX| j �| j�}|dkrDtt��| j� | jd|� n8| j �
| j �}t |t
�r|t|�dkr�tt��| j� |� W W |r�|�| j� dS tjy� |r�td��Y W |r�|�| j� dS t�yP } z^t�|jd�}|�s,|j|k�r,W Y d }~W |�r(|�| j� dS td|j� ���W Y d }~n
d }~0 0 W |�r||�| j� n|�rz|�| j� 0 d S r\ )rQ r_ r` r� Z recv_intorV r rb r� Zfeedra rR r. r/ rF r� rY rd r re rf rH rg rh ri ) r* rd rj rk rm Zbufflen�bufferro rp r+ r+ r, r� � sJ
� � �(�z HiredisParser.read_from_socketFc C s� | j stt��| jdur(| j}d| _|S |r:| j �d�}n
| j �� }|du rr| �� |rf| j �d�}qD| j �� }qDts�t|t�r�| � |j
d �}n4t|t �r�|r�t|d t�r�| � |d j
d �|d< t|t�r�|�n$t|t �r�|r�t|d t�r�|d �|S )NFr ) r� r rb r� r� r� r� r. r rJ ri �list)r* r� rI r+ r+ r, r� � sD
�� �
�� �zHiredisParser.read_responseN)F) r8 r> r? r@ r- r� r� r� rt r_ r� r� r+ r+ r+ r, r� n s
%r� c @ s� e Zd ZdZddddddddddg ddded dddddfd
d �Zd d
� Zdd� Zdd� Zdd� Z dd� Z
dd� Z dd� Z dd� Z
d d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd5d)d*�Zd+d,� Zd6d-d.�Zd7d/d0�Zd1d2� Zd3d4� ZdS )8�
Connectionz4Manages TCP communication to and from a Redis serverZ localhosti� r NFr� �strict� c C s� t �� | _|| _t|�| _|| _|| _|| _|| _ || _
|p>|| _ || _ |pNi | _
| | _|
| _|
rl| �t� | | _| r�|du r�tt� d�| _n t�|�| _| j�| � ntt� d�| _|| _d| _|| _t | |
|�| _ d| _ || _ | � |� g | _!d| _"dS )a2
Initialize a new Connection.
To specify a retry policy for specific errors, first set
`retry_on_error` to a list of the error/s to retry on, then set
`retry` to a valid `Retry` object.
To retry on TimeoutError, `retry_on_timeout` can also be set to `True`.
NrC r �p )#�os�getpid�pid�hostr2 �port�db�username� client_name�passwordrS �socket_connect_timeout�socket_keepalive�socket_keepalive_options� socket_type�retry_on_timeout�appendr �retry_on_errorr r �retry�copy�deepcopy�update_supported_errors�health_check_interval�next_health_check�redis_connect_funcr$ r� rQ �_socket_read_size�
set_parser�_connect_callbacks�_buffer_cutoff)r* r� r� r� r� rS r� r� r� r� r� r� r' r( r) � parser_classrR r� r� r� r� r� r+ r+ r, r- � s>
zConnection.__init__c C s, d� dd� | �� D ��}| jj� d|� d�S )N�,c S s g | ]\}}|� d |� ��qS )�=r+ )r� �k�vr+ r+ r, r� ? r# z'Connection.__repr__.<locals>.<listcomp>�<�>)�join� repr_piecesrg r8 )r* Z repr_argsr+ r+ r, �__repr__> s zConnection.__repr__c C s6 d| j fd| jfd| jfg}| jr2|�d| jf� |S )Nr� r� r� r� )r� r� r� r� r� �r* �piecesr+ r+ r, r� B s zConnection.repr_piecesc C s$ z | � � W n ty Y n0 d S r% )�
disconnectr} rZ r+ r+ r, r� H s zConnection.__del__c C s | j �t�|�� d S r% )r� r� �weakref�
WeakMethod)r* �callbackr+ r+ r, �register_connect_callbackN s z$Connection.register_connect_callbackc C s
g | _ d S r% )r� rZ r+ r+ r, �clear_connect_callbacksQ s z"Connection.clear_connect_callbacksc C s || j d�| _dS )z�
Creates a new instance of parser_class with socket size:
_socket_read_size and assigns it to the parser for the connection
:param parser_class: The required parser class
)rR N)r� �_parser)r* r� r+ r+ r, r� T s zConnection.set_parserc
s� � j r
dS z"� j�� fdd�� fdd��}W nL tjyH td��Y n2 tyx } zt� �|���W Y d}~n
d}~0 0 |� _ z"� j du r�� �
� n
� � � � W n t y� � � � � Y n0 � j
D ]}|� }|r�|� � q�dS )z5Connects to the Redis server if not already connectedNc s � � � S r% )�_connectr+ rZ r+ r, �<lambda>b r# z$Connection.connect.<locals>.<lambda>c s
� � | �S r% �r� )r� rZ r+ r, r� b r# z Timeout connecting to server)rQ r� �call_with_retryrY rd r �OSErrorr �_error_messager� r� r r� r� )r* rk �e�refr� r+ rZ r, �connect\ s, � $
zConnection.connectc C s d}t �| j| j| jt j�D ]�}|\}}}}}d}z�t � |||�}|�t jt jd� | j r�|�t j
t j d� | j �
� D ]\} }
|�t j| |
� qv|�| j� |�|� |�| j� |W S ty� } z | }|dur�|�� W Y d} ~ q d} ~ 0 0 q |du�r|�td��dS )z Create a TCP socket connectionNrC z)socket.getaddrinfo returned an empty list)rY Z getaddrinfor� r� r� � SOCK_STREAMZ
setsockoptZ IPPROTO_TCPZ TCP_NODELAYr� Z
SOL_SOCKETZ SO_KEEPALIVEr� �itemsr` r� r� rS r� r| ) r* �err�resZfamilyZsocktype�protoZ canonnameZsocket_addressrk r� r� �_r+ r+ r, r� } s0 �
zConnection._connectc C s� t |j�dkrXz$d| j� d| j� d|jd � d�W S tyT d|jd � � Y S 0 nTz0d|jd � d | j� d| j� d
|jd � d� W S ty� d|jd � � Y S 0 d S ) NrC zError connecting to �:z. r �.zConnection Error: �Error z connecting to �. )rF ri r� r� �AttributeError�r* � exceptionr+ r+ r, r� � s$ �
���� zConnection._error_messagec C s� | j �| � | js| jr�| jr0| j| jp*df}n| jf}| jdg|�R ddi� z | �� }W n, ty� | jd| jdd� | �� }Y n0 t|�dkr�td��| j r�| �dd | j � t| �� �dkr�t
d
��| j r�| �d | j � t| �� �dkr�t
d ��d
S )z=Initialize the connection, authenticate and select a database� ZAUTH� check_healthF�r� ZOKz Invalid Username or PasswordZCLIENTZSETNAMEzError setting client nameZSELECTzInvalid DatabaseN) r� r� r� r� � send_commandr� r
r r r� r r� )r* Z auth_argsZ
auth_responser+ r+ r, r� � s* zConnection.on_connectc G sx | j �� | jdu rdS t�� | jkrLz| j�tj� W n t yJ Y n0 z| j�
� W n t yl Y n0 d| _dS )z!Disconnects from the Redis serverN) r� r� rQ r� r� r� �shutdownrY Z SHUT_RDWRr� r| )r* ri r+ r+ r, r� � s
zConnection.disconnectc C s* | j ddd� t| �� �dkr&td��dS )z Send PING, expect PONG in returnZPINGFr� ZPONGz#Bad response from PING health checkN)r� r r� r rZ r+ r+ r, �
_send_ping� s zConnection._send_pingc C s | � � dS )z Function to call when PING failsNr� )r* r� r+ r+ r, � _ping_failed� s zConnection._ping_failedc C s( | j r$t� | jkr$| j�| j| j� dS )z3Check the health of the connection with a PING/PONGN)r� r r� r� r� r� r� rZ r+ r+ r, r� � s zConnection.check_healthTc
C s� | j s| �� |r| �� z*t|t�r,|g}|D ]}| j �|� q0W n� tjyh | �� t d��Y n� t
y� } z^| �� t |j �dkr�d|j d }}n|j d }|j d }t
d|� d|� d���W Y d}~n$d}~0 ty� | �� � Y n0 dS ) z2Send an already packed command to the Redis serverzTimeout writing to socketrC ZUNKNOWNr r� z while writing to socket. r� N)rQ r� r� r. r6 ZsendallrY rd r� r r� rF ri r �
BaseException)r* Zcommandr� �itemr� rh �errmsgr+ r+ r, �send_packed_command s,
* z Connection.send_packed_commandc O s | j | j|� |�dd�d� dS )z+Pack and send a command to the Redis serverr� Tr� N)r� � pack_commandrH )r* ri r� r+ r+ r, r� s �zConnection.send_commandc
C sr | j }|s| �� z| j�|�W S tyl } z4| �� td| j� d| j� d|j � ���W Y d}~n
d}~0 0 dS )z8Poll the socket to see if there's data that can be read.�Error while reading from r� z: N)
rQ r� r� rt r� r� r r� r� ri )r* rd rk r� r+ r+ r, rt ! s �zConnection.can_readc
C s� z| j � d| j� �}W n ty, d}Y n0 z| jj|d�}W n� tjyj | �� td|� ���Y n\ t y� } z*| �� t
d|� d|j � ���W Y d}~n$d}~0 t y� | �� � Y n0 | j
r�t� | j
| _t|t�r�|�|S )z0Read the response from a previously sent commandr� r� r� zTimeout reading from r� z : N)r� r� r� r� r� rY rd r� r r� r ri r� r� r r� r. r )r* r� ZhosterrrI r� r+ r+ r, r� . s(
*
zConnection.read_responsec G s g }t |d t�r4t|d �� �� �|dd� }n(d|d v r\t|d �� �|dd� }t�ttt|���� t f�}| j
}t | j j|�D ]|}t|�}t|�|ks�||ks�t |t
�r�t�|tt|��� t f�}|�|� |�|� t }q�t�|tt|��� t |t f�}q�|�|� |S )z2Pack a series of arguments into the Redis protocolr rC N� )r. r6 �tupler5 rD � SYM_EMPTYr� �SYM_STARrF rz r� �mapr� r0 �
SYM_DOLLARr� )r* ri �outputZbuff�
buffer_cutoff�argZ
arg_lengthr+ r+ r, r� H s@ "
����
��
zConnection.pack_commandc C s� g }g }d}| j }|D ]~}| j|� D ]n}t|�}||ksJ||ksJt|t�rb|�t�|�� d}g }||kstt|t�r�|�|� q$|�|� ||7 }q$q|r�|�t�|�� |S )z.Pack multiple commands into the Redis protocolr )r� r� rF r. r0 r� r� r� ) r* Zcommandsr r� Z
buffer_lengthr �cmd�chunkZchunklenr+ r+ r, �
pack_commandsu s. ���
zConnection.pack_commands)T)r )F)r8 r> r? r@ �
DefaultParserr- r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rt r� r� r r+ r+ r+ r, r� � sV �
D!)'
-r� c s. e Zd ZdZd � fdd� Z� fdd�Z� ZS )
�
SSLConnectionz�Manages SSL connections to and from the Redis server(s).
This class extends the Connection class, adding SSL functionality, and making
use of ssl.SSLContext (https://docs.python.org/3/library/ssl.html#ssl.SSLContext)
N�requiredFc
s� t s td��t� jf i |
�� || _|| _|du r:tj}n:t|t �rttjtj
tj d�}||vrltd|� ���|| }|| _ || _
|| _|| _|| _|| _| | _|
| _| | _| | _dS )ae Constructor
Args:
ssl_keyfile: Path to an ssl private key. Defaults to None.
ssl_certfile: Path to an ssl certificate. Defaults to None.
ssl_cert_reqs: The string value for the SSLContext.verify_mode (none, optional, required). Defaults to "required".
ssl_ca_certs: The path to a file of concatenated CA certificates in PEM format. Defaults to None.
ssl_ca_data: Either an ASCII string of one or more PEM-encoded certificates or a bytes-like object of DER-encoded certificates.
ssl_check_hostname: If set, match the hostname during the SSL handshake. Defaults to False.
ssl_ca_path: The path to a directory containing several CA certificates in PEM format. Defaults to None.
ssl_password: Password for unlocking an encrypted private key. Defaults to None.
ssl_validate_ocsp: If set, perform a full ocsp validation (i.e not a stapled verification)
ssl_validate_ocsp_stapled: If set, perform a validation on a stapled ocsp response
ssl_ocsp_context: A fully initialized OpenSSL.SSL.Context object to be used in verifying the ssl_ocsp_expected_cert
ssl_ocsp_expected_cert: A PEM armoured string containing the expected certificate to be returned from the ocsp verification service.
Raises:
RedisError
z$Python wasn't built with SSL supportN)ZnoneZoptionalr z+Invalid SSL Certificate Requirements Flag: )�
ssl_availabler �superr- �keyfile�certfile�sslZ CERT_NONEr. r6 Z
CERT_OPTIONALZ
CERT_REQUIRED� cert_reqs�ca_certs�ca_data�ca_path�check_hostname�certificate_password�ssl_validate_ocsp�ssl_validate_ocsp_stapled�ssl_ocsp_context�ssl_ocsp_expected_cert)r* Z ssl_keyfileZ ssl_certfileZ
ssl_cert_reqsZ ssl_ca_certsZ ssl_ca_data�ssl_check_hostnameZ ssl_ca_pathZ ssl_passwordr r r r r� Z CERT_REQS�rg r+ r, r- � s6 $
��zSSLConnection.__init__c
s� t � �� }t�� }| j|_| j|_| js.| jrD|j | j| j| j
d� | j dusb| j dusb| j
durx|j| j | j | j
d� |j|| jd�}| jdu r�tdu r�td��| jr�| jr�td��| j�r\d dl}d
d lm} | jdu �r|j�|jj�}|� | j� |� | j� n| j}|� || j � |j� |t!�!� �}|�"� |�#| j| j$f� |�%� |�&� |S | jdu �r�t�r�d
d lm'} ||| j| j$| j �} | �(� �r�|S t)d
��|S )z Wrap the socket with SSL support)r r r� N)ZcafileZcapathZcadata)Zserver_hostnameTFz cryptography is not installed.zKEither an OCSP staple or pure OCSP connection must be validated - not both.r rC )�ocsp_staple_verifier)� OCSPVerifierzocsp validation error)*r
r� r Zcreate_default_contextr r Z verify_moder r Zload_cert_chainr r r r Zload_verify_locationsZ wrap_socketr� r r r r �OpenSSLZocspr r ZSSLZContextZ
SSLv23_METHODZuse_certificate_fileZuse_privatekey_fileZset_ocsp_client_callbackr r� rY Z request_ocspr� r� Z do_handshaker� r Zis_validr )
r* rk �contextZsslsockr r Z
staple_ctxZconr �or r+ r, r� � sd
���� � � �
zSSLConnection._connect) NNr NNFNNFFNN)r8 r> r? r@ r- r� �
__classcell__r+ r+ r r, r
� s �Cr
c @ sN e Zd Zdddddddddg edddddfdd �Zd
d � Zd d
� Zdd� ZdS )�UnixDomainSocketConnectionr� r Nr� r� Fr� c C s� t �� | _|| _|| _|| _|| _|| _|| _| | _ | rB|
�
t � |
| _ | j r�|du rft
t� d�| _n t�|�| _| j�|
� nt
t� d�| _|
| _d| _|| _t|||�| _d| _| | _| �| � g | _d| _ dS )aB
Initialize a new UnixDomainSocketConnection.
To specify a retry policy for specific errors, first set
`retry_on_error` to a list of the error/s to retry on, then set
`retry` to a valid `Retry` object.
To retry on TimeoutError, `retry_on_timeout` can also be set to `True`.
NrC r r� ) r� r� r� �pathr� r� r� r� rS r� r� r r� r r r� r� r� r� r� r� r� r$ r� rQ r� r� r� r� )r* r$ r� r� r� rS r' r( r) r� r� r� rR r� r� r� r� r+ r+ r, r- ! s4
z#UnixDomainSocketConnection.__init__c C s. d| j fd| jfg}| jr*|�d| jf� |S )Nr$ r� r� )r$ r� r� r� r� r+ r+ r, r� [ s z&UnixDomainSocketConnection.repr_piecesc C s, t � t jt j�}|�| j� |�| j� |S )z&Create a Unix domain socket connection)rY ZAF_UNIXr� r` rS r� r$ )r* rk r+ r+ r, r� a s z#UnixDomainSocketConnection._connectc C sR t |j�dkr(d| j� d|jd � d�S d|jd � d| j� d|jd � d�S d S )NrC z!Error connecting to unix socket: r� r r� r� z connecting to unix socket: )rF ri r$ r� r+ r+ r, r� h s ���z)UnixDomainSocketConnection._error_message)r8 r> r? r r- r� r� r� r+ r+ r+ r, r# s( �
:r# )�0�FZFALSE�NZNOc C s6 | d u s| dkrd S t | t�r.| �� tv r.dS t| �S )Nr� F)r. r6 �upper�
FALSE_STRINGSr1 )r9 r+ r+ r, �to_boolw s
r* ) r� rS r� r� r� r� �max_connectionsr� r c
C s� t | �} i }t| j��� D ]t\}}|rt|�dkrt|d �}t�|�}|r�z||�||< W q� tt fy� t d|� d���Y q�0 q|||< q| j
r�t| j
�|d< | j r�t| j �|d< | j dkr�| j
r�t| j
�|d< t|d< n�| j d v �rx| j�rt| j�|d
< | j�rt| j�|d < | j
�rbd |v�rbz tt| j
��d
d��|d < W n tt f�y` Y n0 | j dk�r�t|d< nt d��|S )Nr zInvalid value for `z` in connection URL.r� r� Zunixr$ �connection_class)Zredis�redissr� r� r� �/r� r- zRRedis URL must specify one of the following schemes (redis://, rediss://, unix://))r r �queryr� rF r �URL_QUERY_ARGUMENT_PARSERSrH � TypeError�
ValueErrorr� r� �schemer$ r# �hostnamer� r2 r� r� r
)�urlr� �namer9 �parserr+ r+ r, � parse_url� sH
�r8 c @ st e Zd ZdZedd� �Zedfdd�Zdd� Zd d
� Z d d � Z
d
d� Z dd� Z dd� Z
dd� Zdd� Zddd�ZdS )�ConnectionPoola�
Create a connection pool. ``If max_connections`` is set, then this
object raises :py:class:`~redis.exceptions.ConnectionError` when the pool's
limit is reached.
By default, TCP connections are created unless ``connection_class``
is specified. Use class:`.UnixDomainSocketConnection` for
unix sockets.
Any additional keyword arguments are passed to the constructor of
``connection_class``.
c K s4 t |�}d|v r |d |d< |�|� | f i |��S )a
Return a connection pool configured from the given URL.
For example::
redis://[[username]:[password]]@localhost:6379/0
rediss://[[username]:[password]]@localhost:6379/0
unix://[[username]:[password]]@/path/to/socket.sock?db=0
Three URL schemes are supported:
- `redis://` creates a TCP socket connection. See more at:
<https://www.iana.org/assignments/uri-schemes/prov/redis>
- `rediss://` creates a SSL wrapped TCP socket connection. See more at:
<https://www.iana.org/assignments/uri-schemes/prov/rediss>
- ``unix://``: creates a Unix Domain Socket connection.
The username, password, hostname, path and all querystring values
are passed through urllib.parse.unquote in order to replace any
percent-encoded values with their corresponding characters.
There are several ways to specify a database number. The first value
found will be used:
1. A ``db`` querystring option, e.g. redis://localhost?db=0
2. If using the redis:// or rediss:// schemes, the path argument
of the url, e.g. redis://localhost/0
3. A ``db`` keyword argument to this function.
If none of these options are specified, the default db=0 is used.
All querystring options are cast to their appropriate Python types.
Boolean arguments can be specified with string values "True"/"False"
or "Yes"/"No". Values that cannot be properly cast cause a
``ValueError`` to be raised. Once parsed, the querystring arguments
and keyword arguments are passed to the ``ConnectionPool``'s
class initializer. In the case of conflicting arguments, querystring
arguments always win.
r, )r8 �update)�clsr5 r� Z url_optionsr+ r+ r, �from_url� s
)
zConnectionPool.from_urlNc K sJ |pd}t |t�r|dk r"td��|| _|| _|| _t�� | _| � � d S )Nl r z,"max_connections" must be a positive integer)
r. r2 r2 r, �connection_kwargsr+ � threading�Lock�
_fork_lock�reset)r* r, r+ r= r+ r+ r, r- � s
zConnectionPool.__init__c C s( t | �j� dt| jf i | j���� d�S )Nr� r� )r7 r8 r4 r, r= rZ r+ r+ r, r� s ��zConnectionPool.__repr__c C s, t �� | _d| _g | _t� | _t�� | _ d S rP )
r> r? �_lock�_created_connections�_available_connections�set�_in_use_connectionsr� r� r� rZ r+ r+ r, rA s
zConnectionPool.resetc C sZ | j t�� krV| jjdd�}|s$t�z$| j t�� kr<| �� W | j�� n | j�� 0 d S )N� )rd )r� r� r� r@ �acquirer rA �release)r* Zacquiredr+ r+ r, � _checkpid, s #
zConnectionPool._checkpidc O s� | � � | j�F z| j�� }W n ty8 | �� }Y n0 | j�|� W d � n1 sZ0 Y zX|�� z|� � r�t
d��W n6 t
t fy� |� � |�� |� � r�t
d��Y n0 W n t
y� | �|� � Y n0 |S )z Get a connection from the poolN�Connection has data�Connection not ready)rJ rB rD �pop�
IndexError�make_connectionrF �addr� rt r r� r� r� rI �r* Z command_name�keys�optionsr� r+ r+ r, �get_connection[ s* *
z ConnectionPool.get_connectionc C s, | j }t|�dd�|�dd�|�dd�d�S )z,Return an encoder based on encoding settingsr' r� r( r� r) Fr& )r= r$ rH )r* r� r+ r+ r, � get_encoder| s
�zConnectionPool.get_encoderc C s4 | j | jkrtd��| j d7 _ | jf i | j��S )zCreate a new connectionzToo many connectionsrC )rC r+ r r, r= rZ r+ r+ r, rO � s z ConnectionPool.make_connectionc C s� | � � | j�r z| j�|� W n ty2 Y n0 | �|�rL| j�|� n&| jd8 _|� � W d � dS W d � n1 s�0 Y dS )z(Releases the connection back to the poolrC N)
rJ rB rF �remove�KeyError�owns_connectionrD r� rC r� r� r+ r+ r, rI � s
zConnectionPool.releasec C s |j | j kS r% )r� r� r+ r+ r, rX � s z ConnectionPool.owns_connectionTc C s^ | � � | j�< |r$t| j| j�}n| j}|D ] }|�� q.W d � n1 sP0 Y dS )z�
Disconnects connections in the pool
If ``inuse_connections`` is True, disconnect connections that are
current in use, potentially by other threads. Otherwise only disconnect
connections that are idle in the pool.
N)rJ rB r rD rF r� )r* Zinuse_connectionsZ connectionsr� r+ r+ r, r� � s �zConnectionPool.disconnect)T)r8 r> r? r@ � classmethodr< r� r- r� rA rJ rT rU rO rI rX r� r+ r+ r+ r, r9 � s
1�
/! r9 c sR e Zd ZdZddeef� fdd� Zdd� Zdd � Zd
d � Z d d
� Z
dd� Z � Z S )�BlockingConnectionPoola
Thread-safe blocking connection pool::
>>> from redis.client import Redis
>>> client = Redis(connection_pool=BlockingConnectionPool())
It performs the same function as the default
:py:class:`~redis.ConnectionPool` implementation, in that,
it maintains a pool of reusable connections that can be shared by
multiple redis clients (safely across threads if required).
The difference is that, in the event that a client tries to get a
connection from the pool when all of connections are in use, rather than
raising a :py:class:`~redis.ConnectionError` (as the default
:py:class:`~redis.ConnectionPool` implementation does), it
makes the client wait ("blocks") for a specified number of seconds until
a connection becomes available.
Use ``max_connections`` to increase / decrease the pool size::
>>> pool = BlockingConnectionPool(max_connections=10)
Use ``timeout`` to tell it either how many seconds to wait for a connection
to become available, or to block forever:
>>> # Block forever.
>>> pool = BlockingConnectionPool(timeout=None)
>>> # Raise a ``ConnectionError`` after five seconds if a connection is
>>> # not available.
>>> pool = BlockingConnectionPool(timeout=5)
�2 � c s( || _ || _t� jf ||d�|�� d S )N)r, r+ )� queue_classrd r
r- )r* r+ rd r, r] r= r r+ r, r- � s ��z BlockingConnectionPool.__init__c C sL | � | j�| _z| j�d � W q ty4 Y q8Y q0 qg | _t�� | _d S r% ) r] r+ �pool�
put_nowaitr � _connectionsr� r� r� rZ r+ r+ r, rA � s z BlockingConnectionPool.resetc C s" | j f i | j��}| j�|� |S )zMake a fresh connection.)r, r= r` r� r� r+ r+ r, rO s z&BlockingConnectionPool.make_connectionc O s� | � � d}z| jjd| jd�}W n ty< td��Y n0 |du rN| �� }zX|�� z|�� rjtd��W n6 tt fy� |�
� |�� |�� r�td��Y n0 W n t y� | � |� � Y n0 |S )a7
Get a connection, blocking for ``self.timeout`` until a connection
is available from the pool.
If the connection returned is ``None`` then creates a new connection.
Because we use a last-in first-out queue, the existing connections
(having been returned to the pool after the initial ``None`` values
were added) will be returned before ``None`` values. This means we only
create new connections when we need to, i.e.: the actual number of
connections will only increase in response to demand.
NT)�blockrd zNo connection available.rK rL )
rJ r^ rH rd r r rO r� rt r� r� r� rI rQ r+ r+ r, rT
s,
z%BlockingConnectionPool.get_connectionc C sR | � � | �|�s*|�� | j�d� dS z| j�|� W n tyL Y n0 dS )z)Releases the connection back to the pool.N)rJ rX r� r^ r_ r r� r+ r+ r, rI > s
z BlockingConnectionPool.releasec C s | � � | jD ] }|�� qdS )z(Disconnects all connections in the pool.N)rJ r` r� r� r+ r+ r, r� S s
z!BlockingConnectionPool.disconnect)
r8 r> r? r@ r� r r- rA rO rT rI r� r" r+ r+ r r, rZ � s #�4rZ )]r� rh rT r� rY r> r� � itertoolsr Zqueuer r r r � urllib.parser r r Zpackaging.versionr
Z
redis.backoffr Zredis.exceptionsr r
r r r r r r r r r r r r r Z redis.retryr Z redis.utilsr r r r r � ImportError�BlockingIOErrorZ EWOULDBLOCKrf �hasattrr ZSSLWantWriteErrorZSSLErrorr� rR re r� � __version__Zhiredis_versionr� Z HIREDIS_SUPPORTS_BYTE_BUFFERr� r� r r rz r� rb �objectr_ rK rM rN rL r$ rA rO r r� r r� r
r# r) r* r2 r3 r� r0 r8 r9 rZ r+ r+ r+ r, �<module> s� D
�)'vS T �
4 z