File: //lib/python3.6/site-packages/redis/__pycache__/connection.cpython-36.opt-1.pyc
3
be�^�� � @ s� d dl mZ d dlmZ d dlmZ d dlmZ d dlZd dlZd dl Z d dl
Z
d dl Z d dl Z d dl
mZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m Z m Z m Z m Z d dl!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/ d dl0m1Z1 yd dl2Z2d Z3W n e4k
�r* d
Z3Y nX e ej5iZ6e3�rhe7e2d ��r^d e6e2j8< d e6e2j9< n
d e6e2j:< e
j;e6k�r~d3e6e
j;< e<e6j=� �Z>e1�r�d dl?Z?ee?j@�ZAeAed�kZBeAed�kZCeAed�kZDeC�s�de?j@ ZEe jFeE� d ZGeC�s�d
ZGdZHdZIdZJdZKdZLeM� ZNG dd� deM�ZOG dd� deM�ZPG dd � d eM�ZQG d d � d eP�ZRG d d � d eP�ZSe1�rdeSZTneRZTG d!d"� d"eM�ZUG d#d$� d$eU�ZVG d%d&� d&eU�ZWd4ZXd,d-� ZYeZeZeYeYe[e[eYd.�Z\G d/d0� d0eM�Z]G d1d2� d2e]�Z^dS )5� )�unicode_literals)�
StrictVersion)�chain)�timeN)�xrange�imap�unicode�long� nativestr�
basestring� iteritems� LifoQueue�Empty�Full�urlparse�parse_qs�recv� recv_into�unquote�BlockingIOError�sendall�shutdown�ssl_wrap_socket)�AuthenticationError�$AuthenticationWrongNumberOfArgsError�BusyLoadingError�ChildDeadlockedError�ConnectionError� DataError�ExecAbortError�InvalidResponse�NoPermissionError�
NoScriptError�
ReadOnlyError�
RedisError�
ResponseError� TimeoutError)�HIREDIS_AVAILABLETF�SSLWantReadError� i?B z0.1.3z0.1.4z1.0.0z`redis-py works best with hiredis >= 0.1.4. You're running hiredis %s. Please consider upgrading.� *� $s
� z Connection closed by server.c @ 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/ r0 � r2 � /usr/lib/python3.6/connection.py�__init__b s zEncoder.__init__c C s� t |ttf�r|S t |t�r&td��nTt |t�r>t|�j� }n<t |tt f�rZt
|�j� }n t |t �szt |�j
}td| ��t |t�r�|j| 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.zLInvalid input of type: '%s'. Convert to a bytes, string, int or float first.)�
isinstance�bytes�
memoryview�boolr �float�repr�encode�intr �strr �type�__name__r r. r/ )r1 �value�typenamer2 r2 r3 r; g s
zEncoder.encodeFc C s: | j s
|r6t|t�r |j� }t|t�r6|j| j| j�}|S )z:Return a unicode string from the bytes-like representation)r0 r5 r7 �tobytesr6 �decoder. r/ )r1 r@ �forcer2 r2 r3 rC } s
zEncoder.decodeN)F)r? �
__module__� __qualname__�__doc__r4 r; rC r2 r2 r2 r3 r- _ s r- c @ s4 e Zd Zeeeeed�eeee ee
d�Z dd� Z dS )�
BaseParser)z 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\ |j d�d }|| jkrT|t|�d d� }| j| }t|t�rL|j|t�}||�S t|�S )zParse an error response� r � N)�split�EXCEPTION_CLASSES�lenr5 �dict�getr% )r1 �responseZ
error_codeZexception_classr2 r2 r3 � parse_error� s
zBaseParser.parse_errorN)
r? rE rF r r r r r r" r# r! rL rQ r2 r2 r2 r3 rH � s rH c @ sX e Zd Zdd� Zedd� �Zdedfdd�Zd d
� Zd d � Z d
d� Z
dd� Z dd� Z dS )� SocketBufferc C s, || _ || _|| _tj� | _d| _d| _d S )Nr )�_sock�socket_read_size�socket_timeout�io�BytesIO�_buffer�
bytes_written�
bytes_read)r1 �socketrT rU r2 r2 r3 r4 � s
zSocketBuffer.__init__c C s | j | j S )N)rY rZ )r1 r2 r2 r3 �length� s zSocketBuffer.lengthNTc
C sB | j }| j}| j}|j| j� d}|tk }� z�y||r>|j|� xht| j |�} t| t �rjt
| �dkrjt t ��|j
| � t
| �}
| j|
7 _||
7 }|d k r�||kr�q@dS W nz tjk
r� |r�td��dS tk
�r$ } z<tj| jd�} | �r| j| k�rdS t d| jf ��W Y d d } ~ X nX W d |�r<|j| j� X d S )Nr TzTimeout reading from socketFrJ z#Error while reading from socket: %s���)rS rT rX �seekrY �SENTINEL�
settimeoutr r5 r6 rM r � SERVER_CLOSED_CONNECTION_ERROR�writer[ �timeoutr& �NONBLOCKING_EXCEPTIONS�#NONBLOCKING_EXCEPTION_ERROR_NUMBERSrO � __class__�errno�argsrU )
r1 r\ rc �raise_on_timeout�sockrT �bufZmarker�custom_timeout�dataZ data_length�ex�allowedr2 r2 r3 �_read_from_socket� s@
"z SocketBuffer._read_from_socketc C s t | j�p| j|dd�S )NF)rc ri )r8 r\ rp )r1 rc r2 r2 r3 �can_read� s
zSocketBuffer.can_readc C sn |d }|| j kr"| j|| j � | jj| j� | jj|�}| jt|�7 _| j| jkrb| j� |d d� S )Nr) ���) r\ rp rX r^ rZ �readrM rY �purge)r1 r\ rm r2 r2 r3 rs � s
zSocketBuffer.readc C sx | j }|j| j� |j� }x*|jt�sD| j� |j| j� |j� }q W | jt|�7 _| j| jkrl| j � |d d� S )Nr) rr )
rX r^ rZ �readline�endswith�SYM_CRLFrp rM rY rt )r1 rk rm r2 r2 r3 ru � s zSocketBuffer.readlinec C s& | j jd� | j j� d| _d| _d S )Nr )rX r^ �truncaterY rZ )r1 r2 r2 r3 rt
s
zSocketBuffer.purgec C s< y| j � | jj� W n tk
r* Y nX d | _d | _d S )N)rt rX �close� ExceptionrS )r1 r2 r2 r3 ry s zSocketBuffer.close)
r? rE rF r4 �propertyr\ r_ rp rq rs ru rt ry r2 r2 r2 r3 rR � s
*rR c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dS )� PythonParserzPlain Python parsing classc C s || _ d | _d | _d | _d S )N)rT �encoderrS rX )r1 rT r2 r2 r3 r4 $ s zPythonParser.__init__c C s& y | j � W n tk
r Y nX d S )N)�
on_disconnectrz )r1 r2 r2 r3 �__del__* s zPythonParser.__del__c C s( |j | _ t| j | j|j�| _|j| _dS )z Called when the socket connectsN)rS rR rT rU rX r} )r1 �
connectionr2 r2 r3 �
on_connect0 s
zPythonParser.on_connectc C s* d| _ | jdk r | jj� d| _d| _dS )z"Called when the socket disconnectsN)rS rX ry r} )r1 r2 r2 r3 r~ 8 s
zPythonParser.on_disconnectc C s | j o| j j|�S )N)rX rq )r1 rc r2 r2 r3 rq @ s zPythonParser.can_readc s � j j� }|stt��|d d� |dd � }}|d
krDtd| ��|dkrpt|�}� j|�}t|t�rl|�|S |dkrznn|dkr�t|�}n\|dkr�t |�}|d kr�d S � j j
|�}n2|dkr�t |�}|d kr�d S � fdd �t |�D �}t|t ��r � j
j|�}|S )
NrJ � -� +� :r+ r* zProtocol Error: %rc s g | ] }� j � �qS r2 )�
read_response)�.0�i)r1 r2 r3 �
<listcomp>k s z.PythonParser.read_response.<locals>.<listcomp>)r� r� r� r+ r* r] r] )rX ru r ra r r
rQ r5 r r< rs r r6 r} rC )r1 �rawZbyterP �errorr\ r2 )r1 r3 r� C s:
zPythonParser.read_responseN)
r? rE rF rG r4 r r� r~ rq r� r2 r2 r2 r3 r| " s r| c @ sN e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Ze d fd
d�Z
dd� Z dS )�
HiredisParserz*Parser class for connections using Hiredisc C s$ t s td��|| _tr t|�| _d S )NzHiredis is not installed)r' r$ rT �HIREDIS_USE_BYTE_BUFFER� bytearrayrX )r1 rT r2 r2 r3 r4 s s
zHiredisParser.__init__c C s& y | j � W n tk
r Y nX d S )N)r~ rz )r1 r2 r2 r3 r { s zHiredisParser.__del__c C sd |j | _ |j| _t| jd�}ts(t|d< |jjr<|jj |d< t
rL|jj |d< t j
f |�| _d| _d S )N)Z
protocolError�
replyErrorr� r. �errorsF)rS rU �_socket_timeoutr rQ � HIREDIS_SUPPORTS_CALLABLE_ERRORSr% r} r0 r. � HIREDIS_SUPPORTS_ENCODING_ERRORSr/ �hiredis�Reader�_reader�_next_response)r1 r� �kwargsr2 r2 r3 r� � s
zHiredisParser.on_connectc C s d | _ d | _d| _d S )NF)rS r� r� )r1 r2 r2 r3 r~ � s zHiredisParser.on_disconnectc C s@ | j stt��| jdkr<| j j� | _| jdkr<| j|dd�S dS )NF)rc ri T)r� r ra r� �gets�read_from_socket)r1 rc r2 r2 r3 rq � s
zHiredisParser.can_readTc C s( | j }|tk }� z�y�|r"|j|� trXt| j | j�}|dkrDtt��| jj | jd|� n:t
| j | j �}t |t
� s~t|�dkr�tt��| jj |� dS tjk
r� |r�td��dS tk
�r
} z8tj|jd�}| r�|j|kr�dS td|jf ��W Y d d }~X nX W d |�r"|j| j� X d S )Nr TzTimeout reading from socketFrJ z#Error while reading from socket: %sr] )rS r_ r` r� r rX r ra r� Zfeedr rT r5 r6 rM r[ rc r& rd re rO rf rg rh r� ) r1 rc ri rj rl Zbufflen�bufferrn ro r2 r2 r3 r� � s6
"z HiredisParser.read_from_socketc C s� | j stt��| jdk r(| j}d| _|S | j j� }x |dkrP| j� | j j� }q4W ts�t|t�rr| j |j
d �}n4t|t �r�|r�t|d t�r�| j |d j
d �|d< t|t�r�|�n$t|t �r�|r�t|d t�r�|d �|S )NFr ) r� r ra r� r� r� r� r5 r% rQ rh �list)r1 rP r2 r2 r3 r� � s,
zHiredisParser.read_responseN) r? rE rF rG r4 r r� r~ rq r_ r� r� r2 r2 r2 r3 r� q s &r� c @ s� e Zd ZdZddddddddddddded dddfd
d �Zd d
� Zdd� Zdd� Zdd� Z dd� Z
dd� Z dd� Z dd� Z
d d � Zd d � Zd d!� Zd/d#d$�Zd%d&� Zd0d'd(�Zd)d*� Zd+d,� Zd-d.� ZdS )1�
Connectionz4Manages TCP communication to and from a Redis serverZ localhosti� r NFzutf-8�stricti c C s� t j� | _|| _t|�| _|| _|| _|| _|| _ || _
|p>|| _ || _ |pNi | _
| | _|
| _|| _d| _t| | |
�| _d | _||d�| _g | _d| _d S )Nr )rT ip )�os�getpid�pid�hostr< �port�db�username� client_name�passwordrU �socket_connect_timeout�socket_keepalive�socket_keepalive_options� socket_type�retry_on_timeout�health_check_interval�next_health_checkr- r} rS �_parser�_connect_callbacks�_buffer_cutoff)r1 r� r� r� r� rU r� r� r� r� r� r. r/ r0 � parser_classrT r� r� r� r2 r2 r3 r4 � s(
zConnection.__init__c C s( dj dd� | j� D ��}d| jj|f S )N�,c S s g | ]\}}d ||f �qS )z%s=%sr2 )r� �k�vr2 r2 r3 r� s z'Connection.__repr__.<locals>.<listcomp>z%s<%s>)�join� repr_piecesrf r? )r1 Z repr_argsr2 r2 r3 �__repr__ s zConnection.__repr__c C s6 d| j fd| jfd| jfg}| jr2|jd| jf� |S )Nr� r� r� r� )r� r� r� r� �append)r1 �piecesr2 r2 r3 r� s zConnection.repr_piecesc C s& y | j � W n tk
r Y nX d S )N)�
disconnectrz )r1 r2 r2 r3 r s zConnection.__del__c C s | j j|� d S )N)r� r� )r1 �callbackr2 r2 r3 �register_connect_callback$ s z$Connection.register_connect_callbackc C s
g | _ d S )N)r� )r1 r2 r2 r3 �clear_connect_callbacks' s z"Connection.clear_connect_callbacksc C s� | j r
dS y | j� }W nN tjk
r4 td��Y n2 tjk
rd } zt| j|���W Y dd}~X nX || _ y | j� W n t k
r� | j
� � Y nX x| j D ] }|| � q�W dS )z5Connects to the Redis server if not already connectedNz Timeout connecting to server) rS �_connectr[ rc r& r� r �_error_messager� r$ r� r� )r1 rj �er� r2 r2 r3 �connect* s zConnection.connectc C s d}x�t j| j| j| jt j�D ]�}|\}}}}}d}y�t j |||�}|jt jt jd� | j r�|jt j
t j d� x&t | j
�D ]\} }
|jt j| |
� qzW |j| j� |j|� |j| j� |S t jk
r� } z| }|dk r�|j� W Y dd} ~ X q X q W |dk �r|�t jd��dS )z Create a TCP socket connectionNrJ z)socket.getaddrinfo returned an empty list)r[ Z getaddrinfor� r� r� � SOCK_STREAMZ
setsockoptZ IPPROTO_TCPZ TCP_NODELAYr� Z
SOL_SOCKETZ SO_KEEPALIVEr r� r` r� r� rU r� ry ) r1 �err�resZfamilyZsocktype�protoZ canonnameZsocket_addressrj r� r� �_r2 r2 r3 r� B s.
zConnection._connectc C sJ t |j�dkr&d| j| j|jd f S d|jd | j| j|jd f S d S )NrJ z Error connecting to %s:%s. %s.r z!Error %s connecting to %s:%s. %s.)rM rh r� r� )r1 � exceptionr2 r2 r3 r� j s
zConnection._error_messagec C s� | j j| � | js| jr�| jr0| j| jp*df}n| jf}| jd|�ddi� y | j� }W n. tk
r� | jd| jdd� | j� }Y nX t|�dkr�td��| j r�| jdd | j � t| j� �dkr�t
d
��| j r�| jd | j � t| j� �dkr�t
d ��d
S )z=Initialize the connection, authenticate and select a database� �AUTH� check_healthF)r� ZOKz Invalid Username or PasswordZCLIENTZSETNAMEzError setting client nameZSELECTzInvalid DatabaseN)r� ) r� r� r� r� � send_commandr� r r
r r� r r� )r1 Z auth_argsZ
auth_responser2 r2 r3 r� t s* zConnection.on_connectc C sd | j j� | jdkrdS y*tj� | jkr6t| jtj� | jj � W n tj
k
rX Y nX d| _dS )z!Disconnects from the Redis serverN) r� r~ rS r� r� r� r r[ Z SHUT_RDWRry r� )r1 r2 r2 r3 r� � s
zConnection.disconnectc C s� | j r�t� | jkr�y*| jddd� t| j� �dkr:td��W nF ttfk
r� | j� | jddd� t| j� �dkr~td��Y nX dS )z3Check the health of the connection with a PING/PONGZPINGF)r� ZPONGz#Bad response from PING health checkN) r� r r� r� r
r� r r& r� )r1 r2 r2 r3 r� � s
zConnection.check_healthTc C s� | j s| j� |r| j� y.t|t�r,|g}x|D ]}t| j |� q2W W n� tjk
rn | j� t d��Y n� tj
k
r� } zR| j� t |j �dkr�d|j d }}n|j d }|j d }t
d||f ��W Y dd}~X n tk
r� | j� � Y nX dS )z2Send an already packed command to the Redis serverzTimeout writing to socketrJ ZUNKNOWNr z%Error %s while writing to socket. %s.N)rS r� r� r5 r= r r[ rc r� r& r� rM rh r �
BaseException)r1 Zcommandr� �itemr� rg �errmsgr2 r2 r3 �send_packed_command� s.
z Connection.send_packed_commandc O s | j | j|� |jdd�d� dS )z+Pack and send a command to the Redis serverr� T)r� N)r� � pack_commandrO )r1 rh r� r2 r2 r3 r� � s zConnection.send_commandc C s$ | j }|s| j� | j }| jj|�S )z8Poll the socket to see if there's data that can be read.)rS r� r� rq )r1 rc rj r2 r2 r3 rq � s
zConnection.can_readc C s� y| j j� }W n� tjk
r@ | j� td| j| jf ��Y n` tjk
r� } z&| j� t d| j| j|j
f ��W Y dd}~X n t k
r� | j� � Y nX | j r�t
� | j | _t|t�r�|�|S )z0Read the response from a previously sent commandzTimeout reading from %s:%sz#Error while reading from %s:%s : %sN)r� r� r[ rc r� r& r� r� r� r rh r� r� r r� r5 r% )r1 rP r� r2 r2 r3 r� � s$ $
zConnection.read_responsec G s g }t |d t�r4t|d j� j� �|dd� }n(d|d kr\t|d j� �|dd� }tjttt |��j� t
f�}| j }x�t | j
j|�D ]|}t |�}t |�|ks�||ks�t |t�r�tj|tt|�j� t
f�}|j|� |j|� t
}q�tj|tt|�j� t
|t
f�}q�W |j|� |S )z2Pack a series of arguments into the Redis protocolr rJ N� )r5 r �tupler; rK � SYM_EMPTYr� �SYM_STARr= rM rw r� r r} r7 �
SYM_DOLLARr� )r1 rh �outputZbuff�
buffer_cutoff�argZ
arg_lengthr2 r2 r3 r� � s* "
zConnection.pack_commandc C s� g }g }d}| j }x�|D ]�}x|| j|� D ]n}t|�}||ksN||ksNt|t�rf|jtj|�� d}g }||ksxt|t�r�|j|� q(|j|� ||7 }q(W qW |r�|jtj|�� |S )z.Pack multiple commands into the Redis protocolr )r� r� rM r5 r7 r� r� r� ) r1 Zcommandsr� r� Z
buffer_lengthr� �cmd�chunkZchunklenr2 r2 r3 �
pack_commands s&
zConnection.pack_commands)T)r )r? rE rF rG �
DefaultParserr4 r� r� r r� r� r� r� r� r� r� r� r� r� rq r� r� r� r2 r2 r2 r3 r� � s2
(
'
"r� c s* e Zd Zd� fdd� Z� fdd�Z� ZS ) �
SSLConnectionN�requiredFc s� t s td��tt| �jf |� || _|| _|d kr:tj}n8t |t
�rrtjtj tj d�}||krjtd| ��|| }|| _
|| _|| _d S )Nz$Python wasn't built with SSL support)ZnoneZoptionalr� z-Invalid SSL Certificate Requirements Flag: %s)�
ssl_availabler$ �superr� r4 �keyfile�certfile�sslZ CERT_NONEr5 r Z
CERT_OPTIONALZ
CERT_REQUIRED� cert_reqs�ca_certs�check_hostname)r1 Z ssl_keyfileZ ssl_certfileZ
ssl_cert_reqsZ ssl_ca_certs�ssl_check_hostnamer� Z CERT_REQS)rf r2 r3 r4 6 s&
zSSLConnection.__init__c s� t t| �j� }ttd�rrtj� }| j|_| j|_| j rN| j
rN|j | j | j
d� | j r`|j
| j � t||| jd�}n tt|| j| j
| j | j d�}|S )z Wrap the socket with SSL support�create_default_context)r� r� )Zserver_hostname)r� r� r� r� )r� r� r� �hasattrr� r� r� r� Z verify_moder� r� Zload_cert_chainr� Zload_verify_locationsr r� )r1 rj �context)rf r2 r3 r� Q s$
zSSLConnection._connect)NNr� NF)r? rE rF r4 r� �
__classcell__r2 r2 )rf r3 r� 4 s r� c
@ sH e Zd Zdddddddddedddf
dd �Zd
d � Zd d
� Zdd� ZdS )�UnixDomainSocketConnectionr� r Nzutf-8r� Fi c C sp t j� | _|| _|| _|| _|
| _|| _|| _| | _ | | _
d| _ t |||�| _
d | _|
| d�| _g | _d| _d S )Nr )rT ip )r� r� r� �pathr� r� r� r� rU r� r� r� r- r} rS r� r� r� )r1 r� r� r� r� rU r. r/ r0 r� r� rT r� r� r2 r2 r3 r4 l s
z#UnixDomainSocketConnection.__init__c C s. d| j fd| jfg}| jr*|jd| jf� |S )Nr� r� r� )r� r� r� r� )r1 r� r2 r2 r3 r� � s
z&UnixDomainSocketConnection.repr_piecesc C s, t j t jt j�}|j| j� |j| j� |S )z&Create a Unix domain socket connection)r[ ZAF_UNIXr� r` rU r� r� )r1 rj r2 r2 r3 r� � s z#UnixDomainSocketConnection._connectc C sB t |j�dkr"d| j|jd f S d|jd | j|jd f S d S )NrJ z(Error connecting to unix socket: %s. %s.r z+Error %s connecting to unix socket: %s. %s.)rM rh r� )r1 r� r2 r2 r3 r� � s
z)UnixDomainSocketConnection._error_message)r? rE rF r� r4 r� r� r� r2 r2 r2 r3 r� j s r� �0�F�FALSE�N�NOc C s6 | d ks| dkrd S t | t�r.| j� tkr.dS t| �S )Nr� F)r5 r �upper�
FALSE_STRINGSr8 )r@ r2 r2 r3 �to_bool� s
r� )rU r� r� r� �max_connectionsr� r� c @ sv e Zd ZdZeddd��Zedfdd�Zdd � Zd
d � Z d d
� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zd dd�ZdS ) �ConnectionPoolzGeneric connection poolNFc
K sB t |�}i }x�tt|j��D ]t\}}|r t|�dkr tj|�}|r�y||d �||< W q� ttfk
r� t j
t d| �� Y q�X q |d ||< q W |r�|j r�t
|j �nd} |jr�t
|j�nd}
|jr�t
|j�nd} |jr�t
|j�nd} n |j p�d} |jp�d}
|j} |j} |jdk�r,|j| |
| td�� n�|jdk�r�|j| t|j�pJd�| |
d �� d
|k�r�| �r�yt| jd d ��|d
< W n ttfk
�r� Y nX |jdk�r�t|d
< ndjd�}
td|
��t|jd
|�p�d��|d
< |j|� d|k�rt j
td�� |jd�|d< d|k�r8t j
td�� |jd�|d< | f |�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://``
<https://www.iana.org/assignments/uri-schemes/prov/redis>`_ creates a
normal TCP socket connection
- ```rediss://``
<https://www.iana.org/assignments/uri-schemes/prov/rediss>`_ creates
a SSL wrapped TCP socket connection
- ``unix://`` creates a Unix Domain Socket connection
There are several ways to specify a database number. The parse function
will return the first specified option:
1. A ``db`` querystring option, e.g. redis://localhost?db=0
2. If using the redis:// scheme, the path argument of the url, e.g.
redis://localhost/0
3. The ``db`` argument to this function.
If none of these options are specified, db=0 is used.
The ``decode_components`` argument allows this function to work with
percent-encoded URLs. If this argument is set to ``True`` all ``%xx``
escapes will be replaced by their single-character equivalents after
the URL has been parsed. This only applies to the ``hostname``,
``path``, ``username`` and ``password`` components.
Any additional querystring arguments and keyword arguments will be
passed along to the ConnectionPool class's initializer. The querystring
arguments ``socket_connect_timeout`` and ``socket_timeout`` if supplied
are parsed as float values. The arguments ``socket_keepalive`` and
``retry_on_timeout`` are parsed to boolean values that accept
True/False, Yes/No values to indicate state. Invalid types cause a
``UserWarning`` to be raised. In the case of conflicting arguments,
querystring arguments always win.
r z)Invalid value for `%s` in connection URL.NZunix)r� r� r� �connection_class�redis�redissi� )r� r� r� r� r� �/r� r� z, �redis://� rediss://�unix://z8Redis URL must specify one of the following schemes (%s)�charsetz/"charset" is deprecated. Use "encoding" insteadr. r� z5"errors" is deprecated. Use "encoding_errors" insteadr/ )r� r� )r� r� r� ) r r r ZqueryrM �URL_QUERY_ARGUMENT_PARSERSrO � TypeError�
ValueError�warnings�warn� UserWarningr� r r� r� �hostname�scheme�updater� r< r� �replace�AttributeErrorr� r� �DeprecationWarning�pop)�clsZurlr� Zdecode_componentsr� Z url_options�namer@ �parserr� r� r� r Z
valid_schemesr2 r2 r3 �from_url� sl .
zConnectionPool.from_urlc K sP |pd}t |ttf� s |dk r(td��|| _|| _|| _tj� | _ | j
� dS )a�
Create a connection pool. If max_connections is set, then this
object raises redis.ConnectionError when the pool's limit is reached.
By default, TCP connections are created unless connection_class is
specified. Use redis.UnixDomainSocketConnection for unix sockets.
Any additional keyword arguments are passed to the constructor of
connection_class.
r) � r z,"max_connections" must be a positive integerNl ) r5 r< r r r� �connection_kwargsr� � threading�Lock�
_fork_lock�reset)r1 r� r� r r2 r2 r3 r4 0 s
zConnectionPool.__init__c C s dt | �jt| jf | j��f S )Nz%s<%s>)r> r? r: r� r )r1 r2 r2 r3 r� O s zConnectionPool.__repr__c C s, t j� | _d| _g | _t� | _tj� | _ d S )Nr )
r r �_lock�_created_connections�_available_connections�set�_in_use_connectionsr� r� r� )r1 r2 r2 r3 r U s
zConnectionPool.resetc
C sr | j tj� krnt� d }d}x t� |k r<| jjd�}|r P q W |sFt�z| j tj� kr^| j� W d | jj� X d S )N� F) r� r� r� r r �acquirer r �release)r1 Z
timeout_atZacquiredr2 r2 r3 � _checkpidf s #
zConnectionPool._checkpidc O s� | j � | j�> y| jj� }W n tk
r: | j� }Y nX | jj|� W dQ R X yV|j� y|j � rnt
d��W n4 t
k
r� |j � |j� |j � r�t
d��Y nX W n t k
r� | j
|� � Y nX |S )z Get a connection from the poolNzConnection has datazConnection not ready)r r r r �
IndexError�make_connectionr �addr� rq r r� r� r )r1 � command_name�keys�optionsr� r2 r2 r3 �get_connection� s*
z ConnectionPool.get_connectionc C s, | j }t|jdd�|jdd�|jdd�d�S )z,Return an encoder based on encoding settingsr. zutf-8r/ r� r0 F)r. r/ r0 )r r- rO )r1 r� r2 r2 r3 � get_encoder� s
zConnectionPool.get_encoderc C s0 | j | jkrtd��| j d7 _ | jf | j�S )zCreate a new connectionzToo many connectionsrJ )r r� r r� r )r1 r2 r2 r3 r! � s z ConnectionPool.make_connectionc C sv | j � | j�^ y| jj|� W n tk
r4 Y nX | j|�rN| jj|� n| jd8 _|j � dS W dQ R X dS )z(Releases the connection back to the poolrJ N)
r r r �remove�KeyError�owns_connectionr r� r r� )r1 r� r2 r2 r3 r � s
zConnectionPool.releasec C s |j | j kS )N)r� )r1 r� r2 r2 r3 r* � s z ConnectionPool.owns_connectionTc
C sN | j � | j�6 |r$t| j| j�}n| j}x|D ] }|j� q0W W dQ R X 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)r r r r r r� )r1 Zinuse_connectionsZ connectionsr� r2 r2 r3 r� � s
zConnectionPool.disconnect)NF)T)r? rE rF rG � classmethodr r� r4 r� r r r& r' r! r r* r� r2 r2 r2 r3 r� � s z 6! r� c sR e Zd ZdZddeef� fdd� Zdd� Zdd � Zd
d � Z d d
� Z
dd� Z � Z S )�BlockingConnectionPoola6
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.connection.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.exceptions.ConnectionError`` (as the default
``:py:class: ~redis.connection.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, || _ || _tt| �jf ||d�|�� d S )N)r� r� )� queue_classrc r� r, r4 )r1 r� rc r� r/ r )rf r2 r3 r4 s z BlockingConnectionPool.__init__c C sP | j | j�| _x,y| jjd � W q tk
r6 P Y qX qW g | _tj� | _d S )N) r/ r� �pool�
put_nowaitr � _connectionsr� r� r� )r1 r2 r2 r3 r % s z BlockingConnectionPool.resetc C s | j f | j�}| jj|� |S )zMake a fresh connection.)r� r r2 r� )r1 r� r2 r2 r3 r! = s z&BlockingConnectionPool.make_connectionc O s� | j � d}y| jjd| jd�}W n tk
r> td��Y nX |dkrP| j� }yV|j� y|j� rltd��W n4 tk
r� |j � |j� |j� r�td��Y nX W n t
k
r� | j |� � Y nX |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)�blockrc zNo connection available.zConnection has datazConnection not ready) r r0 rO rc r r r! r� rq r� r� r )r1 r# r$ r% r� r2 r2 r3 r& C s,
z%BlockingConnectionPool.get_connectionc C sT | j � | j|�s*|j� | jjd� dS y| jj|� W n tk
rN Y nX dS )z)Releases the connection back to the pool.N)r r* r� r0 r1 r )r1 r� r2 r2 r3 r w s
z BlockingConnectionPool.releasec C s$ | j � x| jD ] }|j� qW dS )z(Disconnects all connections in the pool.N)r r2 r� )r1 r� r2 r2 r3 r� � s z!BlockingConnectionPool.disconnect)
r? rE rF rG r� r
r4 r r! r& r r� r� r2 r2 )rf r3 r, � s
4r, i���)r� r� r� r� r� )_Z
__future__r Zdistutils.versionr � itertoolsr r rg rV r� r[ r r Z
redis._compatr r r r r
r r r
r r r r r r r r r r r Zredis.exceptionsr r r r r r r r r! r" r# r$ r% r& Z redis.utilsr' r� r� � ImportErrorZ EWOULDBLOCKre r� r( ZSSLWantWriteErrorZSSLErrorr� r� r$ rd r� � __version__Zhiredis_versionr� Z HIREDIS_SUPPORTS_BYTE_BUFFERr� �msgr r� r� r� rw r� ra �objectr_ r- rH rR r| r� r� r� r� r� r� r� r9 r< r r� r, r2 r2 r2 r3 �<module> s� T@
(#xOz E63 H