U gs @srUddlZddlZddlZddlZddlZddlZddlZddlmZddl m Z ddl m Z m Z mZddlmZddlmZmZmZmZmZmZmZddlmZmZmZddlmZmZmZm Z m!Z!m"Z"d d l#m$Z$m%Z%m&Z&m'Z'd d l(m)Z)d d l*m+Z+m,Z,d d l-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5d dl6m7Z7d dl8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@e:rhddlAZAdZBdZCdZDdZEdZFeGZHeee&e'e%feId<e:re%ZJne&ZJGdddZKGdddZLGdddZMGdddeMZNGdddeNZOGd d!d!eMZPGd"d#d#eOZQGd$d%d%eNZRd&ZSd'd(ZTeUeVeVeTeTeWeUeUeTeVd) ZXd*d+ZYGd,d-d-ZZGd.d/d/eZZ[dS)0N)abstractmethod)chain)EmptyFull LifoQueue)time)AnyCallableDictListOptionalTypeUnion)parse_qsunquoteurlparse) CacheEntryCacheEntryStatus CacheFactoryCacheFactoryInterfaceCacheInterfaceCacheKey)Encoder_HiredisParser _RESP2Parser _RESP3Parser) NoBackoff)CredentialProvider"UsernamePasswordCredentialProvider)AuthenticationError$AuthenticationWrongNumberOfArgsErrorChildDeadlockedErrorConnectionError DataError RedisError ResponseError TimeoutError)Retry)CRYPTOGRAPHY_AVAILABLEHIREDIS_AVAILABLE SSL_AVAILABLEcompare_versions ensure_stringformat_error_messageget_lib_version str_if_bytes*$s  DefaultParserc@seZdZedddZdS)HiredisRespSerializer)argscGsg}t|dtr4t|d|dd}n(d|dkr\t|d|dd}z|t|Wn0tk rt \}}}t | |YnX|S2Pack a series of arguments into the Redis protocolrrN ) isinstancestrtupleencodesplitappendhiredis pack_command TypeErrorsysexc_infor$with_traceback)selfr7output_value tracebackrL4/tmp/pip-unpacked-wheel-f3sx1i9r/redis/connection.pypackEs" zHiredisRespSerializer.packN)__name__ __module__ __qualname__r rNrLrLrLrMr6Dsr6c@s"eZdZddddZddZdS)PythonRespSerializerNreturncCs||_||_dSN)_buffer_cutoffr>)rG buffer_cutoffr>rLrLrM__init__WszPythonRespSerializer.__init__c Gsg}t|dtr4t|d|dd}n(d|dkr\t|d|dd}tttt|t f}|j }t |j|D]|}t|}t||ks||kst|t rt|t t|t f}||||t }qt|t t|t |t f}q|||Sr8)r;r<r=r>r? SYM_EMPTYjoinSYM_STARlenSYM_CRLFrVmap memoryview SYM_DOLLARr@)rGr7rHZbuffrWargZ arg_lengthrLrLrMrN[s@"      zPythonRespSerializer.pack)rOrPrQrXrNrLrLrLrMrRVsrRc@seZdZeddZeddZeddZeddZed d Zed d Z ed dZ eddZ ed%ddZ eddZ ed&ddZed'dddddZeddZedd Zeeeeeefeeeffd!d"d#Zd$S)(ConnectionInterfacecCsdSrUrLrGrLrLrM repr_piecesszConnectionInterface.repr_piecescCsdSrUrLrGcallbackrLrLrMregister_connect_callbacksz-ConnectionInterface.register_connect_callbackcCsdSrUrLrerLrLrMderegister_connect_callbacksz/ConnectionInterface.deregister_connect_callbackcCsdSrUrLrG parser_classrLrLrM set_parserszConnectionInterface.set_parsercCsdSrUrLrcrLrLrMconnectszConnectionInterface.connectcCsdSrUrLrcrLrLrM on_connectszConnectionInterface.on_connectcGsdSrUrLrGr7rLrLrM disconnectszConnectionInterface.disconnectcCsdSrUrLrcrLrLrM check_healthsz ConnectionInterface.check_healthTcCsdSrUrLrGcommandrprLrLrMsend_packed_commandsz'ConnectionInterface.send_packed_commandcOsdSrUrLrGr7kwargsrLrLrM send_commandsz ConnectionInterface.send_commandrcCsdSrUrLrGtimeoutrLrLrMcan_readszConnectionInterface.can_readFdisconnect_on_error push_requestcCsdSrUrL)rGdisable_decodingr{r|rLrLrM read_responsesz!ConnectionInterface.read_responsecGsdSrUrLrnrLrLrMrBsz ConnectionInterface.pack_commandcCsdSrUrLrGcommandsrLrLrM pack_commandssz!ConnectionInterface.pack_commandsrScCsdSrUrLrcrLrLrMhandshake_metadatasz&ConnectionInterface.handshake_metadataN)T)r)F)rOrPrQrrdrgrhrkrlrmrorprsrvryr~rBrpropertyrr bytesr<rrLrLrLrMrbsF              rbc@seZdZdZdddddedddeddddeddddd dfeee ee ee e e e e eeee ee ee ee e e dfeegdfeeeeeegdfd d d Zd dZeddZddZddZddZddZddZddZeddZedd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Z d+d,Z!dBd.d/Z"d0d1Z#dCd2d3Z$dDd-dd4d5d6Z%d7d8Z&d9d:Z'epe d;dd?Z,e,j-e e*e+e+fe*e e ffd@dAd?Z,dS)EAbstractConnectionz0Manages communication to and from a Redis serverrNFutf-8strictizredis-pyr4)dbpasswordsocket_timeoutsocket_connect_timeoutretry_on_timeoutencodingencoding_errorsdecode_responsessocket_read_sizehealth_check_interval client_namelib_name lib_versionusernameretryredis_connect_funccredential_providerprotocolcommand_packercCs|s|r|dk rtdt|_||_| |_||_||_||_||_ ||_ ||_ |dkr^|}||_ ||_ |tkrvg}|r|t||_|s|r|dkrttd|_n t||_|j|nttd|_| |_d|_||_t||| |_d|_d|_| |_| | g|_!d|_"zHz t%|}Wn6t&k rBt'}Ynt(k r^t#d YnXW5|dksx|dkrt#d||_$X|)||_*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`. Nz'username' and 'password' cannot be passed along with 'credential_provider'. Please provide only one of the following arguments: 1. 'password' and (optional) 'username' 2. 'credential_provider'rripr4zprotocol must be either 2 or 3zprotocol must be an integer)+r$osgetpidpidrrrrrrrrrrSENTINELr@r'retry_on_errorr(rrcopydeepcopyZupdate_supported_errorsrnext_health_checkrrencoderr_sock_socket_read_sizerk_connect_callbacksrVr#rintrCDEFAULT_RESP_VERSION ValueError_construct_command_packer_command_packer)rGrrrrrrrrrrjrrrrrrrrrrrprLrLrMrXs`     zAbstractConnection.__init__cCs8ddd|D}d|jjd|jjd|dS)N,cSsg|]\}}|d|qS)=rL).0kvrLrLrM ,sz/AbstractConnection.__repr__..<.()>)rZrd __class__rPrO)rGZ repr_argsrLrLrM__repr__+szAbstractConnection.__repr__cCsdSrUrLrcrLrLrMrd/szAbstractConnection.repr_piecescCs&z |Wntk r YnXdSrU)ro ExceptionrcrLrLrM__del__3s zAbstractConnection.__del__cCs*|dk r |StrtSt|j|jjSdSrU)r*r6rRrVrr>)rGpackerrLrLrMr9s z,AbstractConnection._construct_command_packercCs$t|}||jkr |j|dS)a^ Register a callback to be called when the connection is established either initially or reconnected. This allows listeners to issue commands that are ephemeral to the connection, for example pub/sub subscription or key tracking. The callback must be a _method_ and will be kept as a weak reference. N)weakref WeakMethodrr@)rGrfZwmrLrLrMrgAs  z,AbstractConnection.register_connect_callbackcCs0z|jt|Wntk r*YnXdS)z De-register a previously registered callback. It will no-longer receive notifications on connection events. Calling this is not required when the listener goes away, since the callbacks are kept as weak methods. N)rremoverrrrerLrLrMrhMsz.AbstractConnection.deregister_connect_callbackcCs||jd|_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 )rN)r_parserrirLrLrMrkXszAbstractConnection.set_parserc sjr dSz"jfddfdd}WnLtjk rJtdYn0tk rx}zt|W5d}~XYnX|_z"j dkr n Wnt k r YnXddj D_ j D]}|}|r|qdS)z5Connects to the Redis server if not already connectedNcsSrU)_connectrLrcrLrMfr3z,AbstractConnection.connect..cs |SrUro)errorrcrLrMrfr3zTimeout connecting to servercSsg|]}|r|qSrLrL)rrefrLrLrMr}sz.AbstractConnection.connect..)rrcall_with_retrysocketrxr'OSErrorr#_error_messagerrmr%ror)rGsockerrfrLrcrMrl`s0      zAbstractConnection.connectcCsdSrUrLrcrLrLrMrszAbstractConnection._connectcCsdSrUrLrcrLrLrM _host_errorszAbstractConnection._host_errorcCst||SrU)r.r)rG exceptionrLrLrMrsz!AbstractConnection._error_messagecCs|j||j}d}|js(|js(|jrD|jp:t|j|j}|}|r|jdkrt|jt r~| t |j |j_ |j|t |dkrd|dg}|jd|jdf|||_n|r*|jd|dd iz |}Wn2tk r|jd|d d d |}YnXt|d krtd n|jdkrt|jt rd| t |j |j_ |j||d|j||_|jd|jkr|jd|jkrtd|jr|dd|jt|d krtdz&|jr|ddd|j|Wntk rYnXz&|jr@|ddd|j|Wntk rXYnX|jr|d|jt|d krtddS)z=Initialize the connection, authenticate and select a databaseN)r42rdefaultrZHELLOAUTHrpFrpOKzInvalid Username or PasswordsprotoprotozInvalid RESP versionCLIENTZSETNAMEzError setting client nameZSETINFOzLIB-NAMEzLIB-VERZSELECTzInvalid Database)r)rrmrrrrZget_credentialsrr;rrkrZEXCEPTION_CLASSESr\rvr~rr!r0r getr#rrr&rr)rGparserZ auth_argsZ cred_providerZ auth_responserLrLrMrmst                  zAbstractConnection.on_connectc Gs|j|j}d|_|dkr"dSt|jkrZz|tjWnt t fk rXYnXz | Wnt k rzYnXdS)z!Disconnects from the Redis serverN) rZ on_disconnectrrrrshutdownr SHUT_RDWRrrCclose)rGr7Z conn_sockrLrLrMros  zAbstractConnection.disconnectcCs*|jdddt|dkr&tddS)z Send PING, expect PONG in returnZPINGFrZPONGz#Bad response from PING health checkN)rvr0r~r#rcrLrLrM _send_pingszAbstractConnection._send_pingcCs |dS)z Function to call when PING failsNr)rGrrLrLrM _ping_failedszAbstractConnection._ping_failedcCs(|jr$t|jkr$|j|j|jdS)z3Check the health of the connection with a PING/PONGN)rrrrrrrrcrLrLrMrpszAbstractConnection.check_healthTc Cs|js||r|z*t|tr,|g}|D]}|j|q0Wntjk rj|t dYnt k r}zV|t |j dkrd|j d}}n|j d}|j d}t d|d|dW5d}~XYntk r|YnXdS) z2Send an already packed command to the Redis serverzTimeout writing to socketrUNKNOWNrzError z while writing to socket. rN)rrlrpr;r<sendallrrxror'rr\r7r# BaseException)rGrrrpitemrerrnoerrmsgrLrLrMrs s,    &z&AbstractConnection.send_packed_commandcOs"|j|jj||ddddS)z+Pack and send a command to the Redis serverrpTrN)rsrrNrrtrLrLrMrv*s  zAbstractConnection.send_commandc Csn|j}|s||}z|j|WStk rh}z"|td|d|jW5d}~XYnXdS)z8Poll the socket to see if there's data that can be read.Error while reading from z: N) rrlrrryrror#r7)rGrxr host_errorrrLrLrMry1szAbstractConnection.can_readrzc Cs|}z2|jdkr*ts*|jj||d}n|jj|d}Wntjk rj|rX|td|Yndt k r}z&|r|t d|d|j W5d}~XYn"t k r|r|YnX|j rt|j |_t|trz|W5~X|S)z0Read the response from a previously sent command)3r)r}r|)r}zTimeout reading from rz : N)rrr*rr~rrxror'rr#r7rrrrr;r&)rGr}r{r|rresponserrLrLrMr~?s:  z AbstractConnection.read_responsecGs |jj|S)r9)rrNrnrLrLrMrBmszAbstractConnection.pack_commandc Csg}g}d}|j}|D]}|jj|D]r}t|}||ksL||ksLt|trh|r`|t|d}g}||kszt|tr||q&||||7}q&q|r|t||S)z.Pack multiple commands into the Redis protocolr) rVrrNr\r;r_r@rYrZ) rGrrHpieces buffer_lengthrWcmdchunkZchunklenrLrLrMrqs0   z AbstractConnection.pack_commandsrScCs|jSrU)rrcrLrLrM get_protocolszAbstractConnection.get_protocolcCs|jSrUZ_handshake_metadatarcrLrLrMrsz%AbstractConnection.handshake_metadatarJcCs ||_dSrUr)rGrJrLrLrMrs)T)r)F).rOrPrQ__doc__rr5r/rr r<floatboolrrr rrXrrrdrrrgrhrkrlrrrrmrorrrprsrvryr~rBrrrr rrsetterrLrLrLrMrs  Z   #  Z   .(rcs:eZdZdZdfdd Zd d Zd d Zd dZZS) Connectionz4Manages TCP communication to and from a Redis server localhostFNrc s8||_t||_||_|pi|_||_tjf|dSrU)hostrportsocket_keepalivesocket_keepalive_options socket_typesuperrX)rGrrrrrrurrLrMrXs   zConnection.__init__cCs6d|jfd|jfd|jfg}|jr2|d|jf|S)Nrrrr)rrrrr@rGrrLrLrMrdszConnection.repr_piecesc Csd}t|j|j|jtjD]}|\}}}}}d}zt|||}|tjtjd|j r|tj tj d|j D]\} } |tj| | qv||j||||j|WStk r} z| }|dk r|W5d} ~ XYqXq|dk r|tddS)zCreate a TCP socket connectionNrz)socket.getaddrinfo returned an empty list)r getaddrinforrr SOCK_STREAM setsockopt IPPROTO_TCP TCP_NODELAYr SOL_SOCKET SO_KEEPALIVEritems settimeoutrrlrrr) rGerrresfamilysocktyper canonnameZsocket_addressrrrrIrLrLrMrs6     zConnection._connectcCs|jd|jS)N:)rrrcrLrLrMrszConnection._host_error)rrFNr rOrPrQrrXrdrr __classcell__rLrLrrMrs)rc@seZdZdZdZdZeeej dddZ ddZ d d Z d d Z d dZddZddZddZddZd7ddZddZd8ddZd9ddd d!d"Zd#d$Zd%d&Zeeeeefeeeffd'd(d)Zd*d+Zd,d-Z ed.d/d0d1Z!d2d3Z"e#eee$e#efd4d5d6Z%d.S):CacheProxyConnectionsfooz7.4.0Zredis)conncache pool_lockcCs`t|_||_|jj|_|jj|_|jj|_||_||_t |_ d|_ d|_ ||jdSrU)rrr_connrrr _pool_lock_cache threadingLock _cache_lock_current_command_cache_keyZ_current_optionsrg_enable_tracking_callback)rGrrrrLrLrMrXs     zCacheProxyConnection.__init__cCs |jSrU)rrdrcrLrLrMrdsz CacheProxyConnection.repr_piecescCs|j|dSrU)rrgrerLrLrMrgsz.CacheProxyConnection.register_connect_callbackcCs|j|dSrU)rrhrerLrLrMrhsz0CacheProxyConnection.deregister_connect_callbackcCs|j|dSrU)rrkrirLrLrMrkszCacheProxyConnection.set_parsercCs|j|jjdd}|dkr2|jjdd}|jjdd}|dkrZ|jjdd}|dksj|dkrrtdt|}t|}||jkst||jdkrtddS)Nsserverserversversionversionz0Cannot retrieve information about server versionrziTo maximize compatibility with all Redis products, client-side caching is supported by Redis 7.4 or later) rrlrrr#r-DEFAULT_SERVER_NAMEr,MIN_ALLOWED_VERSION)rGZ server_nameZ server_verrLrLrMrls$ zCacheProxyConnection.connectcCs|jdSrU)rrmrcrLrLrMrmszCacheProxyConnection.on_connectc Gs,|j|jW5QRX|jj|dSrU)rrflushrrornrLrLrMroszCacheProxyConnection.disconnectcCs|jdSrU)rrprcrLrLrMrp#sz!CacheProxyConnection.check_healthTcCs|j|dSrU)rrsrqrLrLrMrs&sz(CacheProxyConnection.send_packed_commandc Os,||j@|jt|dddsJd|_|jj||W5QRdSW5QRX|ddkrjt dt|dt |dd|_|j|j|jr|j|j}|j |jkr|j |j r|j jddqW5QRXW5QRdS|jt|j|jtj|jdW5QRX|jj||dS) NrrL)rrZ redis_keyskeyszCannot create cache key.Tr|) cache_key cache_valuestatusconnection_ref)_process_pending_invalidationsrrZ is_cachablerrrrvrrr=r$rryr~setrDUMMY_CACHE_VALUEr IN_PROGRESS)rGr7ruentryrLrLrMrv+s:    z!CacheProxyConnection.send_commandrcCs |j|SrU)rryrwrLrLrMry[szCacheProxyConnection.can_readFrzc Cs|jZ|jdk r\|j|jdk r\|j|jjtjkr\t|j|jj W5QRSW5QRX|j j |||d}|jx|jdkr|W5QRS|dkr|j |jg|W5QRS|j|j}|dk rtj |_||_ |j|W5QRX|S)N)r}r{r|)rrrrr#rr(rrr"rr~Zdelete_by_cache_keysZVALIDr&)rGr}r{r|rZ cache_entryrLrLrMr~^s: z"CacheProxyConnection.read_responsecGs |jj|SrU)rrBrnrLrLrMrBsz!CacheProxyConnection.pack_commandcCs |j|SrU)rrrrLrLrMrsz"CacheProxyConnection.pack_commandsrScCs|jjSrU)rrrcrLrLrMrsz'CacheProxyConnection.handshake_metadatacCs|jdSrU)rrrcrLrLrMrszCacheProxyConnection._connectcCs|jdSrU)rrrcrLrLrMrsz CacheProxyConnection._host_errorN)rrTcCs(|ddd||j|jdS)NrZTRACKINGON)rvr~rZset_invalidation_push_handler_on_invalidation_callback)rGrrLrLrMrsz.CacheProxyConnection._enable_tracking_callbackcCs|r|jjddqdS)NTr )ryrr~rcrLrLrMr%sz3CacheProxyConnection._process_pending_invalidations)datac Cs>|j.|ddkr |jn|j|dW5QRXdS)Nr)rrrZdelete_by_redis_keys)rGr,rLrLrMr+s  z.CacheProxyConnection._on_invalidation_callback)T)r)F)&rOrPrQr'rrrbrrrrXrdrgrhrkrlrmrorprsrvryr~rBrrrr rr<rrrrr%r r r+rLrLrLrMrs@  0  )(rcs6eZdZdZd fdd ZfddZd d ZZS) SSLConnectionzManages 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) NrequiredFc sts td||_||_|dkr(tj}n:t|trbtjtjtj d}||krZtd|||}||_ ||_ ||_ ||_ ||_||_| |_| |_| |_| |_| |_||_tjf|dS)aConstructor 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. ssl_min_version: The lowest supported SSL version. It affects the supported SSL versions of the SSLContext. None leaves the default provided by ssl module. ssl_ciphers: A string listing the ciphers that are allowed to be used. Defaults to None, which means that the default ciphers are used. See https://docs.python.org/3/library/ssl.html#ssl.SSLContext.set_ciphers for more information. Raises: RedisError z$Python wasn't built with SSL supportN)noneoptionalr.z+Invalid SSL Certificate Requirements Flag: )r+r%keyfilecertfilessl CERT_NONEr;r< CERT_OPTIONAL CERT_REQUIRED cert_reqsca_certsca_dataca_pathcheck_hostnamecertificate_passwordssl_validate_ocspssl_validate_ocsp_stapledssl_ocsp_contextssl_ocsp_expected_certssl_min_version ssl_ciphersrrX)rGZ ssl_keyfileZ ssl_certfileZ ssl_cert_reqsZ ssl_ca_certsZ ssl_ca_datassl_check_hostnameZ ssl_ca_pathZ ssl_passwordr=r>r?r@rArBruZ CERT_REQSrrLrMrXs:( zSSLConnection.__init__c s>t}z ||WSttfk r8|YnXdS)zN Wrap the socket with SSL support, handling potential errors. N)rr_wrap_socket_with_sslrr%rrGrrrLrMrs   zSSLConnection._connectc Cst}|j|_|j|_|js$|jr:|j|j|j|jd|j dk sX|j dk sX|j dk rn|j |j |j |j d|j dk r|j |_|jr||j|jdkrtdkrtd|jr|jrtd|j||jd}|jrvd dl}d d lm}|jdkr"|j|jj}||j||jn|j}| ||j!|j"|t##}|$|%|j|j&f|'|(|S|jdkrtrd d lm)}|||j|j&|j } | *r|St+d |S)z Wraps the socket with SSL support. Args: sock: The plain socket to wrap with SSL. Returns: An SSL wrapped socket. )r2r1rN)cafilecapathcadataTFzcryptography is not installed.zKEither an OCSP staple or pure OCSP connection must be validated - not both.)server_hostnamerr)ocsp_staple_verifier) OCSPVerifierzocsp validation error),r3create_default_contextr;r7 verify_moder2r1load_cert_chainr<r8r:r9load_verify_locationsrAminimum_versionrB set_ciphersr=r)r%r> wrap_socketrOpenSSLocsprJr?SSLContext SSLv23_METHODuse_certificate_fileuse_privatekey_fileset_ocsp_client_callbackr@rr request_ocsprlr do_handshakerrKZis_validr#) rGrcontextsslsockrSrJZ staple_ctxconrKorLrLrMrDsp          z#SSLConnection._wrap_socket_with_ssl)NNr.NNFNNFFNNNN)rOrPrQrrXrrDr rLrLrrMr-s$H r-cs:eZdZdZd fdd ZddZdd Zd d ZZS) UnixDomainSocketConnectionz4Manages UDS communication to and from a Redis serverNc stjf|||_||_dSrU)rrXpathr)rGrcrrurrLrMrXUsz#UnixDomainSocketConnection.__init__cCs.d|jfd|jfg}|jr*|d|jf|S)Nrcrr)rcrrr@rrLrLrMrdZsz&UnixDomainSocketConnection.repr_piecescCs\ttjtj}||jz||jWntk rJ|YnX||j |S)z&Create a Unix domain socket connection) rAF_UNIXrrrrlrcrrrrErLrLrMr`s  z#UnixDomainSocketConnection._connectcCs|jSrU)rcrcrLrLrMrmsz&UnixDomainSocketConnection._host_error)rbNr rLrLrrMraRs  ra)0FFALSENNOcCs6|dks|dkrdSt|tr.|tkr.dSt|S)NrbF)r;r<upper FALSE_STRINGSrrrLrLrMto_boolts rl) rrrrrrmax_connectionsrrCrxc Cs|ds&|ds&|ds&tdt|}i}t|jD]v\}}|r@t|dkr@t|d}t |}|rz||||<Wqt tfk rtd|dYqXq@|||<q@|j rt|j |d<|j rt|j |d <|j d kr |jrt|j|d <t|d <n|jr"t|j|d <|jr8t|j|d<|jrd|krztt|jdd|d<Wnttfk rYnX|j dkrt|d <|S)Nzredis://z rediss://zunix://zRRedis URL must specify one of the following schemes (redis://, rediss://, unix://)rzInvalid value for 'z' in connection URL.rrunixrcconnection_classrrr/rbZrediss) startswithrrrqueryrr\rURL_QUERY_ARGUMENT_PARSERSrrCrrschemercrahostnamerrreplaceAttributeErrorr-)urlrunamerJrrLrLrM parse_urlsR      rzc@seZdZdZeddZeddfeeee dddZ e e fdd d Z d d Z ddd dZddddZe ddddZedddZddddZdddddZdedddZd)edd d!d"Zddd#d$Zd%dd&d'd(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``. cKs0t|}d|kr|d|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@]/path/to/socket.sock?db=0[&password=password] Three URL schemes are supported: - `redis://` creates a TCP socket connection. See more at: - `rediss://` creates a SSL wrapped TCP socket connection. See more at: - ``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. ro)rzupdate)clsrxruZ url_optionsrLrLrMfrom_urls )  zConnectionPool.from_urlN)rm cache_factorycKs|pd}t|tr|dkr"td||_||_||_d|_||_|dsT|dr|ddkrjt d|jd}|dk rt|t std ||_n.|jdk r|j |_nt |jd |_| dd| ddt|_|dS) Nlrz,"max_connections" must be a positive integerZ cache_configrr)rrz4Client caching is only supported with RESP version 3z#Cache must implement CacheInterface)r;rrroconnection_kwargsrmrZ_cache_factoryrr%rZ get_cacherpoprr _fork_lockreset)rGrormrrrrLrLrMrXs2      zConnectionPool.__init__rSc Cs2dt|jdt|jdt|jf|jdS)Nrrrr)typerPrOreprrorrcrLrLrMr4s0zConnectionPool.__repr__cCs|jddS)z Returns: The RESP protocol version, or ``None`` if the protocol is not specified, in which case the server default will be used. rN)rrrcrLrLrMr:szConnectionPool.get_protocolcCs,t|_d|_g|_t|_t|_ dS)Nr) rr_lock_created_connections_available_connectionsr&_in_use_connectionsrrrrcrLrLrMrBs   zConnectionPool.resetcCsP|jtkrL|jjdd}|s$tz|jtkr<|W5|jXdS)N)rx)rrrracquirer"releaser)rGZacquiredrLrLrM _checkpidSs# zConnectionPool._checkpidr) command_namerTc Os||j>z|j}Wntk r:|}YnX|j|W5QRXzd|z| rx|j dkrxt dWn8t t fk r| || rt dYnXWn tk r||YnX|S)zGet a connection from the poolNConnection has dataConnection not ready)rrrr IndexErrormake_connectionraddrlryrr#rrorrrGrroptions connectionrLrLrMget_connections*  zConnectionPool.get_connectioncCs,|j}t|dd|dd|dddS)z,Return an encoder based on encoding settingsrrrrrF)rrr)rrr)rGrurLrLrM get_encoders    zConnectionPool.get_encoderrbcCsT|j|jkrtd|jd7_|jdk rFt|jf|j|j|jS|jf|jS)zCreate a new connectionzToo many connectionsrN)rrmr#rrrorrrcrLrLrMrs   zConnectionPool.make_connection)rrTc Cs||jhz|j|Wntk r4YnX||rN|j|n$|jd8_| W5QRdSW5QRXdS)z(Releases the connection back to the poolrN) rrrrKeyErrorowns_connectionrr@rrorGrrLrLrMrs zConnectionPool.releasecCs |j|jkSrU)rrrLrLrMrszConnectionPool.owns_connectionT)inuse_connectionsrTc CsJ||j2|r$t|j|j}n|j}|D] }|q.W5QRXdS)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)rrrrrro)rGr connectionsrrLrLrMroszConnectionPool.disconnectcCs |dS)z-Close the pool, disconnecting all connectionsNrrcrLrLrMrszConnectionPool.closer()rrTcCs8|jd|i|jD] }||_q|jD] }||_q(dS)Nr)rr|rrr)rGrrrLrLrM set_retrys   zConnectionPool.set_retry)T)rOrPrQr classmethodr~rr rrrXr<rrrrrrrrrrrrorrrLrLrLrMr{s,  2 2/!  r{csReZdZdZddeeffdd ZddZdd Zd d Z d d Z ddZ 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) 2c s(||_||_tjf||d|dS)N)rorm) queue_classrxrrX)rGrmrxrorrrrLrMrXszBlockingConnectionPool.__init__cCsN||j|_z|jdWqtk r6Yq:YqXqg|_t|_dSrU) rrmpool put_nowaitr _connectionsrrrrcrLrLrMr#s  zBlockingConnectionPool.resetcCsD|jdk r&t|jf|j|j|j}n|jf|j}|j||S)zMake a fresh connection.N)rrrorrrr@rrLrLrMr;s   z&BlockingConnectionPool.make_connectionc Os|d}z|jjd|jd}Wntk r>tdYnX|dkrP|}zZ|z|rltdWn8tt fk r| ||rtdYnXWn t k r| |YnX|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)blockrxzNo connection available.rr) rrrrxrr#rrlryrrorrrrLrLrMrFs,   z%BlockingConnectionPool.get_connectioncCsT|||s*||jddSz|j|Wntk rNYnXdS)z)Releases the connection back to the pool.N)rrrorrrrrLrLrMrzs  zBlockingConnectionPool.releasecCs ||jD] }|qdS)z(Disconnects all connections in the pool.N)rrrorrLrLrMros z!BlockingConnectionPool.disconnect) rOrPrQrrrrXrrrrror rLrLrrMrs# 4r)\rrrr3rDrrabcr itertoolsrqueuerrrrtypingrr r r r r r urllib.parserrrZ redis.cacherrrrrr_parsersrrrrbackoffr credentialsrr exceptionsr r!r"r#r$r%r&r'rr(utilsr)r*r+r,r-r.r/r0rAr[r`r]rYrobjectr__annotations__r5r6rRrbrrrr-rarkrlrrlistrsrzr{rrLrLrLrMs~   $  ( ( 3EPFI* 90