Ë
|
|
çúhæ ã
|
óF d dl Z d dlZd dlZd dlZd dlZd dlmZmZ d dlm Z d dl
|
m
|
Z
|
d dl m Z d dl mZ d dlmZmZmZmZmZmZmZmZ d dlmZmZ d d lm Z d d
|
l m Z m Z d d l m!Z!m"Z"m#Z#m$Z$ d d l%m&Z&m'Z'm(Z(m)Z) d d l*m+Z+m,Z, d dl-m.Z. d dl/m0Z0m1Z1m2Z2 d dl3m4Z4m5Z5 d dl6m7Z7m8Z8m9Z9m:Z: d dl;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZM d dlNmOZO d dlPmQZQ d dlRmSZS d dlTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[ de\dee\e]f de\fdZ^ eUdgd d ¬ « de)de0fd « Z_d Z`d! Zad"ed#edeee]e]f ee\ef f fd$Zbd% Zcd& Zdd'Zed(Zfd)Zgd*Zhd+Zid, Zj G d- d.« Zk G d/ d0eke,« Zl G d1 d2« Zm G d3 d4e « Zn G d5 d6« Zo G d7 d8« Zp G d9 d:e(« Zq G d; d<el« Zrd=e\ded>ef fd?Zsd@ZtetD ]2 Zueují dAdB« jï « Zu exereu eseu« « 4 G dC dD« Zy G dE dF« Zz G dG dHe« Z{ G dI dJe{« Z| G dK dLe|« Z} G dM dNe|« Z~y)Oé N)ÚABCÚabstractmethod)Ú OrderedDict)Úcopy)ÚEnum)Úchain)ÚAnyÚCallableÚDictÚListÚOptionalÚSetÚTupleÚUnion)ÚCommandsParserÚEncoder)Ú
|
parse_scan)Ú ExponentialWithJitterBackoffÚ NoBackoff)Ú CacheConfigÚ CacheFactoryÚCacheFactoryInterfaceÚCacheInterface)ÚEMPTY_RESPONSEÚCaseInsensitiveDictÚPubSubÚRedis)Ú READ_COMMANDSÚRedisClusterCommands)Ú list_or_args)Ú
|
ConnectionÚConnectionPoolÚ parse_url)ÚREDIS_CLUSTER_HASH_SLOTSÚkey_slot)Ú(AfterPooledConnectionsInstantiationEventÚ'AfterPubSubConnectionInstantiationEventÚ
|
ClientTypeÚEventDispatcher)ÚAskErrorÚAuthenticationErrorÚClusterDownErrorÚ ClusterErrorÚConnectionErrorÚCrossSlotTransactionErrorÚ DataErrorÚExecAbortErrorÚInvalidPipelineStackÚMaxConnectionsErrorÚ
|
MovedErrorÚRedisClusterExceptionÚ
|
RedisErrorÚ ResponseErrorÚSlotNotCoveredErrorÚ TimeoutErrorÚ TryAgainErrorÚ
|
WatchError©ÚLock)ÚMaintNotificationsConfig)ÚRetry)Údeprecated_argsÚ
|
dict_mergeÚlist_keys_to_dictÚ merge_resultÚsafe_strÚ str_if_bytesÚ truncate_textÚhostÚportÚreturnc ó | d| S )Nú:© ©rG rH s õ` H:\项ç®\archive\æµè¯ç»\èæ¬\Change_password\venv_build\Lib\site-packages\redis/cluster.pyÚ get_node_namerO B s ØV1TFÐ Ðó Ú
|
redis_nodez&Use get_connection(redis_node) insteadú5.3.0)Ú allowed_argsÚreasonÚversionc óR | j xs | j j « S ©N)Ú
|
connectionÚconnection_poolÚget_connection)rQ ÚargsÚoptionss rN rZ rZ F s$ ð × Ñ Ò O J×$>Ñ$>×$MÑ$MÓ$OÐOrP c ót i }g }|j « D ] \ }}t |fi |¤\ }}|||< ||z } ||fS rW )Úitemsr ) ÚcommandÚresr\ ÚcursorsÚretÚ node_nameÚresponseÚcursorÚrs rN Úparse_scan_resultrg O sX ØGØ
|
CØ "yy{ò Ñ 8Ü xÑ3¨7Ñ3 Ø # ÑØ qðð
|
C<ÐrP c óð t « }|j « D ] }|D ] \ }} ||xx |z cc< |j « D cg c] \ }}||f }}}|S # t $ r |||< Y Nw xY wc c}}w rW )r ÚvaluesÚKeyErrorr^ ) r_ r` r\ Únumsub_dÚ numsub_tupsÚchannelÚ numsubbedÚnumsubÚ
|
ret_numsubs rN Úparse_pubsub_numsubrq Z s Ü}HØzz|ò . Ø"-ò .Ñ GYð .ØÓ! YÑ.Ô!ñ .ð.ð <D¿>¹>Ó;K×L©¨°7FÒ#ÐLJÑLØ Ðøô ò .Ø$-Ó!ð .üó Ms § A Á A2Á A/Á.A/Úrespr\ c óÞ
|
|j dd«
|
dt dt t t f f
|
fd }i }| D ]. }|d d \ }}}|dd } || |D cg c] } || c} d|||f< 0 |S c c} w )NÚ current_hostÚ r[ rI c ó2 t | d « xs | d fS ©Nr é )rE )r[ rt s rN Ú
|
fix_serverz'parse_cluster_slots.<locals>.fix_serverl s ø ÜD GÓ$Ò4¨ °d¸1±gÐ=Ð=rP é )ÚprimaryÚreplicas)Úgetr r Ústr) rr r\ ry ÚslotsÚslotÚstartÚendr{ r| Úreplicart s @rN Úparse_cluster_slotsr g s ø ð ;;~¨rÓ2Lð>#ð >¤%¬¬S¨¡/õ >ð EØò
|
Ø " 2 AhÑsGØ8á! 7Ð+Ø=EÖF°' WÒ-ÒFñ
|
eSjÒð
|
ð Lùò Gs Á A*c ó t | d t « r| S g }| D ]¦ }g g d}t dt |d « d« D ]' }|d j |d | |d |dz f« ) |d }|D ]A }i }t dt |« d« D ] }||dz ||| < |d j |« C |j |« ¨ |S )z(
|
Parse CLUSTER SHARDS response.
|
r )r Únodesrx é r rz r )Ú
|
isinstanceÚdictÚrangeÚlenÚappend) rr r\ ÚshardsÚxÚshardÚir ÚnodeÚ dict_nodes rN Úparse_cluster_shardsr { sö ô $q'4Ô Ø Ø FØ ò
|
Ø rÑ*Üq#a d) QÓ'ò <AØ 'N× !Ñ ! 1 Q¡4¨¡7¨Q¨q©T°!°a±%©[Ð":Õ ;ð <à!Øò -DØIÜ1c $i¨Ó+ò 1Ø%)¨!¨a©%¡[ $q'Ò"ð 1à 'N× !Ñ ! )Õ ,ð -ð
|
eÕ ð
|
ð MrP c ó$ | j d« S )z+
|
Parse CLUSTER MYSHARDID response.
|
úutf-8)Údecode)rr r\ s rN Úparse_cluster_myshardidr s ð ;;wÓ Ð rP r{ r zslot-id)(Úconnection_classrY Úconnection_pool_classÚ client_nameÚcredential_providerÚdbÚdecode_responsesÚencodingÚencoding_errorsrG Úlib_nameÚ lib_versionÚmax_connectionsÚ
|
nodes_flagÚredis_connect_funcÚpasswordrH ÚtimeoutÚ queue_classÚretryÚretry_on_timeoutÚprotocolÚsocket_connect_timeoutÚsocket_keepaliveÚsocket_keepalive_optionsÚsocket_timeoutÚsslÚ ssl_ca_certsÚ ssl_ca_dataÚ ssl_certfileÚ ssl_cert_reqsÚssl_include_verify_flagsÚssl_exclude_verify_flagsÚ ssl_keyfileÚ ssl_passwordÚssl_check_hostnameÚunix_socket_pathÚusernameÚcacheÚ cache_config)rG rH r¨ c óx | j « D ci c] \ }}|t v r |t vr|| }}}|S c c}}w )z9
|
Remove unsupported or disabled keys from kwargs
|
)r^ ÚREDIS_ALLOWED_KEYSÚKWARGS_DISABLED_KEYS)ÚkwargsÚkÚvÚconnection_kwargss rN Úcleanup_kwargsrÄ É sN ð LLN÷á AqØ Ô"Ñ " qÔ0DÑ'Dð
|
1ðÐñ ð Ð ùó s 6c ó e Zd ZdZdZdZdZdZdZeeeeehZ e
|
e g d¢e« e g d¢e« e d ge« e g d
|
¢e « « Z g d ¢fZeeed Z e
|
e d dge« e dgd « e g d¢e« e g d¢d « e ddgd « e dgd « e dge« e dgd « e d gd « e d gd « «
|
ZeeeefZd"d#d!Z y )$ÚAbstractRedisClusteré Ú primariesr| ÚallÚrandomz default-node)VzACL CATz ACL DELUSERz
|
ACL DRYRUNz ACL GENPASSz ACL GETUSERzACL HELPzACL LISTzACL LOGzACL LOADzACL SAVEz ACL SETUSERz ACL USERSz
|
ACL WHOAMIÚAUTHú CLIENT LISTzCLIENT SETINFOúCLIENT SETNAMEúCLIENT GETNAMEú
|
CONFIG SETúCONFIG REWRITEúCONFIG RESETSTATÚTIMEúPUBSUB CHANNELSú PUBSUB NUMPATú PUBSUB NUMSUBúPUBSUB SHARDCHANNELSúPUBSUB SHARDNUMSUBÚPINGÚINFOÚSHUTDOWNÚKEYSÚDBSIZEÚBGSAVEú SLOWLOG GETú SLOWLOG LENú SLOWLOG RESETÚWAITÚWAITAOFÚSAVEú MEMORY PURGEzMEMORY MALLOC-STATSz MEMORY STATSÚLASTSAVEzCLIENT TRACKINGINFOú CLIENT PAUSEúCLIENT UNPAUSEúCLIENT UNBLOCKz CLIENT IDz CLIENT REPLYzCLIENT GETREDIRz CLIENT INFOú CLIENT KILLÚREADONLYz CLUSTER INFOz CLUSTER MEETúCLUSTER MYSHARDIDz CLUSTER NODESzCLUSTER REPLICASz CLUSTER RESETzCLUSTER SET-CONFIG-EPOCHú CLUSTER SLOTSúCLUSTER SHARDSz CLUSTER COUNT-FAILURE-REPORTSzCLUSTER KEYSLOTÚCOMMANDz COMMAND COUNTz COMMAND LISTzCOMMAND GETKEYSú
|
CONFIG GETÚDEBUGÚ RANDOMKEYrê Ú READWRITErÒ zTFUNCTION LOADzTFUNCTION DELETEzTFUNCTION LISTÚTFCALLÚ TFCALLASYNCzLATENCY HISTORYzLATENCY LATESTz LATENCY RESETz MODULE LISTz MODULE LOADz MODULE UNLOADz MODULE LOADEX) ÚFLUSHALLÚFLUSHDBzFUNCTION DELETEzFUNCTION FLUSHz FUNCTION LISTz FUNCTION LOADzFUNCTION RESTOREÚSCANú SCRIPT EXISTSú SCRIPT FLUSHú SCRIPT LOADz FUNCTION DUMP)zCLUSTER COUNTKEYSINSLOTzCLUSTER DELSLOTSzCLUSTER DELSLOTSRANGEzCLUSTER GETKEYSINSLOTzCLUSTER SETSLOT) z FT.CREATEz FT.SEARCHz FT.AGGREGATEz
|
FT.EXPLAINz FT.EXPLAINCLIz
|
FT,PROFILEzFT.ALTERz FT.DROPINDEXz FT.ALIASADDzFT.ALIASUPDATEz FT.ALIASDELz
|
FT.TAGVALSz FT.SUGADDz FT.SUGGETz FT.SUGDELz FT.SUGLENz FT.SYNUPDATEz
|
FT.SYNDUMPz FT.SPELLCHECKz
|
FT.DICTADDz
|
FT.DICTDELz FT.DICTDUMPzFT.INFOzFT._LISTz FT.CONFIGzFT.ADDzFT.DELzFT.DROPzFT.GETzFT.MGETz FT.SYNADD)rì rí rë rÕ r× rÔ c óF t t |j « « « S rW )ÚsumÚlistri ©r_ r` s rN ú<lambda>z AbstractRedisCluster.<lambda> s ´C¼¸S¿Z¹Z»\Ó8JÓ4K rP )rÛ rÓ rÖ ) rØ rÏ rÐ rÑ rÍ rÝ rà rã rä ræ rç c óX t |t « rt |j « « S |S rW )r r rÉ ri rþ s rN rÿ z AbstractRedisCluster.<lambda> ó ´jÀÄdÔ6K¤ S§Z¡Z£\Ó!2 ÐQT rP rÜ rá c óX t |t « rt |j « « S |S rW )r r rü ri rþ s rN rÿ z AbstractRedisCluster.<lambda> r rP rè c óB t |j « « dkD rdS dS rw )rü ri rþ s rN rÿ z AbstractRedisCluster.<lambda>¡ s ¼#¸c¿j¹j»lÓ:KÈaÒ:O°Q ÐUV rP r÷ rú c óP t |j « « j « S rW )rý ri Úpoprþ s rN rÿ z AbstractRedisCluster.<lambda>¥ s ´$°s·z±z³|Ó2D×2HÑ2HÓ2J rP rø c óf t |j « D cg c] }t |« c}S c c}w rW )Úzipri rÉ )r_ r` rÁ s rN rÿ z AbstractRedisCluster.<lambda>¨ s# ÄSÈ#Ï*É*Ë,ÐEWÖ4XÀ´S¸µVÒ4X ùÒ4Xs .rù c ó4 t |j « « S rW )rÉ ri rþ s rN rÿ z AbstractRedisCluster.<lambda>ª s ÄÀSÇZÁZÃ\ÓAR rP Nc ó |r|| j _ y| j « }| j « D cg c]
|
}||k7 s | }}|r%t j
|
|« | j _ y| j « D cg c]
|
}||k7 s | }}|r%t j
|
|« | j _ yyc c}w c c}w )a Replace the default cluster node.
|
A random cluster node will be chosen if target_node isn't passed, and primaries
|
will be prioritized. The default node will not be changed if there are no other
|
nodes in the cluster.
|
|
Args:
|
target_node (ClusterNode, optional): Target node to replace the default
|
node. Defaults to None.
|
N)Ú nodes_managerÚ default_nodeÚget_default_nodeÚ get_primariesrÊ ÚchoiceÚ get_replicas)ÚselfÚ target_nodeÚ curr_noder rÈ r| s rN Úreplace_default_nodez)AbstractRedisCluster.replace_default_node´ s° ñ Ø.9D× Ñ Õ +à ×-Ñ-Ó/IØ*.×*<Ñ*<Ó*>ÖT $À$È)ÓBSÐTIÐTÙä28·-±-À Ó2J×"Ñ"Õ/ð .2×->Ñ->Ó-@ÖV TÀDÈIÓDUDÐVÐVÙÜ6<·m±mÀHÓ6MD×&Ñ&Õ3ð ùò Uùò Ws ·
|
B:ÁB:Â
|
B? B?rW )r Ú ClusterNoderI N) Ú__name__Ú
|
__module__Ú __qualname__ÚRedisClusterRequestTTLÚ PRIMARIESÚREPLICASÚ ALL_NODESÚRANDOMÚ DEFAULT_NODEÚ
|
NODE_FLAGSrA rB ÚSLOT_IDÚ COMMAND_FLAGSÚSEARCH_COMMANDSr r r Ú#CLUSTER_COMMANDS_RESPONSE_CALLBACKSrq rC rg ÚRESULT_CALLBACKSr. r9 r, r8 ÚERRORS_ALLOW_RETRYr rL rP rN rÆ rÆ Ö s
Ø ÐàIØHØIØ FØ!LàX y°&¸,ÐGJá ÙòW ðp ósZ
|
ñv ò ð ó
|
ñ ?Ð+¨VÓ4Ùò ð ó
|
ó[wMòt
|
ð"OðJ -Ø.Ø 4ñ+Ð'ñ "Ù?Ð,@ÐAÐCVÓWÙØ Ð Ñ Kó
|
ñ Ú ?À ó
|
ñ ò ñ Uó
|
ñ Ø vÐ Ù Tó
|
ñ Ø Ð Ñ Vó
|
ñ 6(Ð$5Ó6ÙØ OÑ Jó
|
ñ Ø Ð Ñ Xó
|
ñ >Ð*Ñ,RÓSóM'ÐðT ØØØð ÐõNrP rÆ c " ó8 e Zd Zed « Z edgdd¬« edgdd¬« dBd
|
ee d ed ee d deded de
|
dede
|
ded de
|
dee dee e eef ge eef f dee dee dee f d« « Zd Zd Zd Zd Zd Zd d d!efd"ZdCd#Zd$ Zd% Zd& Zd' Z dDd(Z d) Z d* Z de d!d fd+Z!dEd,Z"dCd-Z#dFd.Z$ dGd/e
|
fd0Z%d1 Z&d!e d fd2Z'd3 Z(d4 Z)d5 Z*d!efd6Z+d7 Z,d8 Z-d9 Z.d: Z/d; Z0d< Z1d= Z2dHd>Z3d? Z4d@ Z5dA Z6y )IÚ RedisClusterc ó | dd|i|¤S )a
|
Return a Redis client object 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:
|
<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.
|
|
ÚurlrL rL )Úclsr( rÀ s rN Úfrom_urlzRedisCluster.from_urlÎ s ñT Ñ%sÐ%fÑ%Ð%rP Úread_from_replicasz6Please configure the 'load_balancing_strategy' insteadrR ©Ú args_to_warnrT rU Ú cluster_error_retry_attemptsú+Please configure the 'retry' object insteadú6.0.0NrG rH Ú startup_nodesr r¨ r? Úrequire_full_coverageÚreinitialize_stepsÚload_balancing_strategyÚLoadBalancingStrategyÚdynamic_startup_nodesr( Ú address_remapr» r¼ Úevent_dispatcherc ó¦ |g }d|v r t d« d|v r t d« d}| d}t | « }d|v r t d « d|v r|d d
|
k7 r t d « |j |« |j d « }|j d |« }|j t ||« « n9| | |j t ||« « nt |« d
|
k( r t d« |j dd« | _ |j d| j i« t d i |¤}|r|| _ n t t dd¬« |¬« | _ t |j dd« |j dd« |j dd« « | _ |j dd« }|s| r|dvr t! d« | j" j$ j' « | _ | j" j* j' « | _ || _ | | _ d
|
| _ || _ |t7 « | _ n|| _ || _ t= d ||||
|
| | || j8 d |¤| _ tA | j" jB « | _" tA | j" jF « | _$ tK | « | _& tO jP « | _) y) aû
|
Initialize a new RedisCluster client.
|
|
:param startup_nodes:
|
List of nodes from which initial bootstrapping can be done
|
:param host:
|
Can be used to point to a startup node
|
:param port:
|
Can be used to point to a startup node
|
:param require_full_coverage:
|
When set to False (default value): the client will not require a
|
full coverage of the slots. However, if not all slots are covered,
|
and at least one node has 'cluster-require-full-coverage' set to
|
'yes,' the server will throw a ClusterDownError for some key-based
|
commands. See -
|
https://redis.io/topics/cluster-tutorial#redis-cluster-configuration-parameters
|
When set to True: all slots must be covered to construct the
|
cluster client. If not all slots are covered, RedisClusterException
|
will be thrown.
|
:param read_from_replicas:
|
@deprecated - please use load_balancing_strategy instead
|
Enable read from replicas in READONLY mode. You can read possibly
|
stale data.
|
When set to true, read commands will be assigned between the
|
primary and its replications in a Round-Robin manner.
|
:param load_balancing_strategy:
|
Enable read from replicas in READONLY mode and defines the load balancing
|
strategy that will be used for cluster node selection.
|
The data read from replicas is eventually consistent with the data in primary nodes.
|
:param dynamic_startup_nodes:
|
Set the RedisCluster's startup nodes to all of the discovered nodes.
|
If true (default value), the cluster's discovered nodes will be used to
|
determine the cluster nodes-slots mapping in the next topology refresh.
|
It will remove the initial passed startup nodes if their endpoints aren't
|
listed in the CLUSTER SLOTS output.
|
If you use dynamic DNS endpoints for startup nodes but CLUSTER SLOTS lists
|
specific IP addresses, it is best to set it to false.
|
:param cluster_error_retry_attempts:
|
@deprecated - Please configure the 'retry' object instead
|
In case 'retry' object is set - this argument is ignored!
|
|
Number of times to retry before raising an error when
|
:class:`~.TimeoutError` or :class:`~.ConnectionError`, :class:`~.SlotNotCoveredError` or
|
:class:`~.ClusterDownError` are encountered
|
:param retry:
|
A retry object that defines the retry strategy and the number of
|
retries for the cluster client.
|
In current implementation for the cluster client (starting form redis-py version 6.0.0)
|
the retry object is not yet fully utilized, instead it is used just to determine
|
the number of retries for the cluster client.
|
In the future releases the retry object will be used to handle the cluster client retries!
|
:param reinitialize_steps:
|
Specifies the number of MOVED errors that need to occur before
|
reinitializing the whole cluster topology. If a MOVED error occurs
|
and the cluster does not need to be reinitialized on this current
|
error handling, only the MOVED slot will be patched with the
|
redirected node.
|
To reinitialize the cluster on every MOVED error, set
|
reinitialize_steps to 1.
|
To avoid reinitializing the cluster on moved errors, set
|
reinitialize_steps to 0.
|
:param address_remap:
|
An optional callable which, when provided with an internal network
|
address of a node, e.g. a `(host, port)` tuple, will return the address
|
where the node is reachable. This can be used to map the addresses at
|
which the nodes _think_ they are, to addresses at which a client may
|
reach them, such as when they sit behind a proxy.
|
|
:**kwargs:
|
Extra arguments that will be sent into Redis instance when created
|
(See Official redis-py doc for supported kwargs - the only limitation
|
is that you can't provide 'retry' object as part of kwargs.
|
[https://github.com/andymccurdy/redis-py/blob/master/redis/client.py])
|
Some kwargs are not supported and will raise a
|
RedisClusterException:
|
- db (Redis do not support database SELECT in cluster mode)
|
Nr z4Argument 'db' is not possible to use in cluster moder¨ zKThe 'retry' argument cannot be used in kwargs when running in cluster mode.FTÚpathzFRedisCluster does not currently support Unix Domain Socket connectionsr z9A ``db`` querystring option can only be 0 in cluster moderG rH a5 RedisCluster requires at least one node to discover the cluster. Please provide one of the followings:
|
1. host and port, for example:
|
RedisCluster(host='localhost', port=6379)
|
2. list of startup nodes, for example:
|
RedisCluster(startup_nodes=[ClusterNode('localhost', 6379), ClusterNode('localhost', 6378)])r¤ rx é
|
©ÚbaseÚcap©ÚbackoffÚretriesr r r Ústrictr rª ©rz Ú3z4Client caching is only supported with RESP version 3)r1 r* r2 r6 r7 r» r¼ r8 rL )*r5 r# Úupdater} r r r r Úuser_on_connect_funcÚ
|
on_connectrÄ r¨ r? r r Úencoderr6 Ú __class__r r Ú command_flagsr Ú
|
node_flagsr+ r4 Úreinitialize_counterr3 r) Ú_event_dispatcherr1 Ú NodesManagerr
|
r r" Úcluster_response_callbacksr# Úresult_callbacksr Úcommands_parserÚ threadingÚRLockÚ_lock)r rG rH r1 r. r¨ r2 r3 r+ r4 r6 r( r7 r» r¼ r8 rÀ r* Ú url_optionsrª s rN Ú__init__zRedisCluster.__init__ú sÝ ðX Ð Ø Mà 6>ä'ØFóð ð fÑ ô
|
(Ø]óð ð
|
Ø ?ØHÜ# C.KØÑ$Ü+ð)óð ð {Ñ" {°4Ñ'8¸AÒ'=ä+ØOóð ð MM+Ô &Ø::fÓ%DØ::f dÓ+DØ × Ñ ¤¨T°4Ó!8Õ 9Ø Ð $Ð"2Ø × Ñ ¤¨T°4Ó!8Õ 9Ü Ó 1Ò $ä'ð4óð ð %+§J¡JÐ/CÀTÓ$JÔ!Ø Ð+¨T¯_©_Ð=Ô>Ü Ñ) &Ñ)Ù Ø DJä Ü4¸!ÀÔDØ4ôDJô
|
Ø JJz 7Ó +Ø JJÐ(¨(Ó 3Ø JJÐ)¨5Ó 1ó
|
ð
|
::j¨$Ó/Ù E x°xÑ'?Ü Ð SÓTÐ Tà !^^× 9Ñ 9× >Ñ >Ó @ÔØ ..×3Ñ3×8Ñ8Ó:Ø"4Ô Ø'>Ô$Ø$%Ô!Ø"4Ô Ø Ð #Ü%4Ó%6DÕ "à%5DÔ "Ø *ÔÜ )ð
|
|
Ø'Ø Ø"7Ø"7Ø'ØØ%Ø !× 3Ñ 3ñ
|
|
ð ñ
|
|
Ôô +>Ø NN× >Ñ >ó+
|
Ô'ô !4°D·N±N×4SÑ4SÓ TÔ ä -¨dÓ 3Ô Ü __Ó&
|
rP c ó | S rW rL ©r s rN Ú __enter__zRedisCluster.__enter__Ð s Ø rP c ó$ | j « y rW )Úclose©r Úexc_typeÚ exc_valueÚ tracebacks rN Ú__exit__zRedisCluster.__exit__Ó ó Ø
|
|
rP c óD | j « y # t $ r Y y w xY wrW )r[ Ú ExceptionrX s rN Ú__del__zRedisCluster.__del__Ö ó" ð Ø JJLøÜò Ù ð úó c ó° | j « D ]4 }|j s |j j j « 6 y # t $ r Y Cw xY wrW )Ú get_nodesÚredis_connectionrY Ú
|
disconnectÚOSError©r r s rN Údisconnect_connection_poolsz(RedisCluster.disconnect_connection_poolsÜ sR ØNNÓ$ò DØ×$Ó$ðØ×)Ñ)×9Ñ9×DÑDÕFñ øô ò áðús ¢$A Á AÁAc ó |j « | j s | j r8|j d« t |j « « dk7 r t d« | j | j |« yy)z
|
Initialize the connection, authenticate and select a database and send
|
READONLY if it is set during object initialization.
|
rê ÚOKzREADONLY command failedN)rG r+ r4 Ú send_commandrE Ú read_responser. rF )r rX s rN rG zRedisCluster.on_connectå sr ð
|
× Ñ Ô à × "Ò " d×&BÒ&Bð × #Ñ # JÔ /ÜJ× 4Ñ 4Ó 6Ó7¸4Ò?Ü%Ð&?Ó@Ð@à × $Ñ $Ð 0Ø × %Ñ % jÕ 1ð 1rP r rI c óò |j sI| j 5 |j s | j j |g« d d d « |j S |j S # 1 sw Y |j S xY wrW )ri rT r
|
Úcreate_redis_connectionsrl s rN Úget_redis_connectionz!RedisCluster.get_redis_connectionù sk Ø×$Ò$Øñ HØ×,Ò,Ø×&Ñ&×?Ñ?ÀÀÔG÷ Hð ×$Ñ$Ð$t×$Ñ$Ð$÷ Hð ×$Ñ$Ð$ús )A"Á"A6c ó< | j j |||« S rW )r
|
Úget_node©r rG rH rc s rN rv zRedisCluster.get_node s Ø×!Ñ!×*Ñ*¨4°°yÓAÐArP c ó@ | j j t « S rW )r
|
Úget_nodes_by_server_typeÚPRIMARYrX s rN r zRedisCluster.get_primaries ó Ø×!Ñ!×:Ñ:¼7ÓCÐCrP c ó@ | j j t « S rW )r
|
ry ÚREPLICArX s rN r zRedisCluster.get_replicas r{ rP c ó t j t | j j j « « « S rW )rÊ r rý r
|
Ú nodes_cacheri rX s rN Úget_random_nodez RedisCluster.get_random_node s+ Ü}}T $×"4Ñ"4×"@Ñ"@×"GÑ"GÓ"IÓ JÓKÐKrP c ó\ t | j j j « « S rW )rý r
|
r ri rX s rN rh zRedisCluster.get_nodes s" ÜD×&Ñ&×2Ñ2×9Ñ9Ó;Ó<Ð<rP c ó | j |« }| j j j |« }|t |« dk( rt d| d« |r&t | j j | « dk ry|rd}|| S d}|| S )z
|
Get the node that holds the key's slot.
|
If replica set to True but the slot doesn't have any replicas, None is
|
returned.
|
Nr úSlot "z " is not covered by the cluster.r rx )Úkeyslotr
|
Ú slots_cacher} r r8 )r Úkeyr r Ú
|
slot_cacheÚnode_idxs rN Úget_node_from_keyz RedisCluster.get_node_from_key s ð ||CÓ Ø×'Ñ'×3Ñ3×7Ñ7¸Ó=
|
Ø Ð ¤ Z£ °AÒ!5Ü%¨¨t¨fÐ4TÐ&UÓVÐ VÙ s4×-Ñ-×9Ñ9¸$Ñ?Ó@À1ÒDØÙ ØHð
|
(Ñ#Ð#ð Hà(Ñ#Ð#rP c ó. | j j S )z0
|
Get the cluster's default node
|
)r
|
r rX s rN r z RedisCluster.get_default_node# s ð ×!Ñ!×.Ñ.Ð.rP c ód | | j |j ¬« y|| j _ y)z
|
Set the default node of the cluster.
|
:param node: 'ClusterNode'
|
:return True if the default node was set, else False
|
©rc FT)rv Únamer
|
r rl s rN Úset_default_nodez RedisCluster.set_default_node) s1 ð <4==°4·9±9=Ó=ÐEØØ*.×ÑÔ'ØrP c ó || _ y rW )r¨ )r r¨ s rN Ú set_retryzRedisCluster.set_retry4 s Ø
|
rP c ó¤ || j « }|j t d|j d« |j j « S )ai
|
Returns a Monitor object for the specified target node.
|
The default cluster node will be selected if no target node was
|
specified.
|
Monitor is useful for handling the MONITOR command to the redis server.
|
next_command() method returns one command from monitor
|
listen() method yields commands from monitor.
|
z Cluster Node z has no redis_connection)r ri r5 r Úmonitor)r r s rN r zRedisCluster.monitor7 s\ ð Ð Ø ×/Ñ/Ó1KØ × 'Ñ 'Ð /Ü'Ø × 0Ñ 0Ð 1Ð1IÐJóð ð ×+Ñ+×3Ñ3Ó5Ð5rP c ó" t | f|||d|¤S )z~
|
Allows passing a ClusterNode, or host&port, to get a pubsub instance
|
connected to the specified node
|
)r rG rH )Ú ClusterPubSub)r r rG rH rÀ s rN ÚpubsubzRedisCluster.pubsubH s ô
|
TÐM¨°4¸dÑMÀfÑMÐMrP c ó$ |r t d« t | j | j | j j | j
|
| j | j | j | j | j | j |¬« S )ac
|
Cluster impl:
|
Pipelines do not work in cluster mode the same way they
|
do in normal mode. Create a clone of this object so
|
that simulating pipelines will work correctly. Each
|
command will be called directly when used and
|
when calling execute() will only return the result stack.
|
z(shard_hint is deprecated in cluster mode) r
|
rQ r1 rP rO r+ r4 r3 r¨ ÚlockÚ transaction) r5 ÚClusterPipeliner
|
rQ r1 rP rO r+ r4 r3 r¨ rT )r r Ú
|
shard_hints rN ÚpipelinezRedisCluster.pipelineO s ñ Ü'Ð(RÓSÐ Sä Ø ×,Ñ,Ø × 0Ñ 0Ø ×,Ñ,×:Ñ:Ø !× 2Ñ 2Ø'+×'FÑ'FØ #× 6Ñ 6Ø$(×$@Ñ$@Ø #× 6Ñ 6Ø**ØØ#ô
|
ð
|
rP Úraise_on_release_errorc
|
ó2 |t } || |||||||¬« S )a}
|
Return a new Lock object using key ``name`` that mimics
|
the behavior of threading.Lock.
|
|
If specified, ``timeout`` indicates a maximum life for the lock.
|
By default, it will remain locked until release() is called.
|
|
``sleep`` indicates the amount of time to sleep per loop iteration
|
when the lock is in blocking mode and another client is currently
|
holding the lock.
|
|
``blocking`` indicates whether calling ``acquire`` should block until
|
the lock has been acquired or to fail immediately, causing ``acquire``
|
to return False and the lock not being acquired. Defaults to True.
|
Note this value can be overridden by passing a ``blocking``
|
argument to ``acquire``.
|
|
``blocking_timeout`` indicates the maximum amount of time in seconds to
|
spend trying to acquire the lock. A value of ``None`` indicates
|
continue trying forever. ``blocking_timeout`` can be specified as a
|
float or integer, both representing the number of seconds to wait.
|
|
``lock_class`` forces the specified lock implementation. Note that as
|
of redis-py 3.0, the only lock class we implement is ``Lock`` (which is
|
a Lua-based lock). So, it's unlikely you'll need this parameter, unless
|
you have created your own custom lock class.
|
|
``thread_local`` indicates whether the lock token is placed in
|
thread-local storage. By default, the token is placed in thread local
|
storage so that a thread only sees its token, not a token set by
|
another thread. Consider the following timeline:
|
|
time: 0, thread-1 acquires `my-lock`, with a timeout of 5 seconds.
|
thread-1 sets the token to "abc"
|
time: 1, thread-2 blocks trying to acquire `my-lock` using the
|
Lock instance.
|
time: 5, thread-1 has not yet completed. redis expires the lock
|
key.
|
time: 5, thread-2 acquired `my-lock` now that it's available.
|
thread-2 sets the token to "xyz"
|
time: 6, thread-1 finishes its work and calls release(). if the
|
token is *not* stored in thread local storage, then
|
thread-1 would see the token value as "xyz" and would be
|
able to successfully release the thread-2's lock.
|
|
``raise_on_release_error`` indicates whether to raise an exception when
|
the lock is no longer owned when exiting the context manager. By default,
|
this is True, meaning an exception will be raised. If False, the warning
|
will be logged and the exception will be suppressed.
|
|
In some use cases it's necessary to disable thread local storage. For
|
example, if you have code where one thread acquires a lock and passes
|
that lock instance to a worker thread to release later. If thread
|
local storage isn't disabled in this case, the worker thread won't see
|
the token set by the thread that acquired the lock. Our assumption
|
is that these cases aren't common and as such default to using
|
thread local storage.)r¦ ÚsleepÚblockingÚblocking_timeoutÚ thread_localr r< ) r r r¦ r r r Ú
|
lock_classr¡ r s rN r zRedisCluster.locki s5 ðH Ð Ü JÙØ Ø ØØØ Ø -Ø%Ø#9ô
|
ð
|
rP c ó" || j |< y)z Set a custom Response CallbackN)rO )r r_ Úcallbacks rN Úset_response_callbackz"RedisCluster.set_response_callbackº s à3;×'Ñ'¨Ò0rP c óè |d j « }t |« dk\ rB|d d|d j « | j v r|d d|d j « }|j dd « }||}n| j j |« }|| j
|
j k( r| j « gS || j
|
j k( r| j « S || j
|
j k( r| j « S || j
|
j k( r| j « S || j
|
j k( r| j j gS || j
|
j" d v r| j j gS | j$ | }| j j' || j( xr |t* v |t* v r | j, nd « }|gS ©Nr r ú rx r£ )Úupperr rJ r r} rI r r r r r r r rh r r
|
r r! Údetermine_slotÚget_node_from_slotr+ r r4 ©r r[ rÀ r_ r£ Ú command_flagr r s rN Ú_determine_nodesz RedisCluster._determine_nodes¾ sÎ ð q'--/Ü t9> a¡ ¨¨4°©7¨)Ð 4× :Ñ :Ó <À×@RÑ@RÑ RØ a 4¨¡7 )Ð,×2Ñ2Ó4GàZZ ¨dÓ3
|
Ø Ð !à%Lð ×-Ñ-×1Ñ1°'Ó:LØ 4>>×0Ñ0Ò 0à×(Ñ(Ó*Ð+Ð +Ø T^^× 5Ñ 5Ò 5à×%Ñ%Ó'Ð 'Ø T^^× 4Ñ 4Ò 4à×$Ñ$Ó&Ð &Ø T^^× 5Ñ 5Ò 5à>>Ó#Ð #Ø T^^× 8Ñ 8Ò 8à×&Ñ&×3Ñ3Ð4Ð 4Ø ×6Ñ6°qÑ9Ñ 9Ø×&Ñ&×3Ñ3Ð4Ð 4ð '4×&Ñ&¨Ð-DØ×%Ñ%×8Ñ8ØØ×'Ñ'ÒD¨G´}Ð,DØ07¼=Ñ0H×,Ò,ÈdóDð
|
6MrP c óZ | j dk( ry| j | j z dk( S )Nr F)r3 rL rX s rN Ú_should_reinitializedz"RedisCluster._should_reinitializedç s1 ð
|
× "Ñ " aÒ 'Øà×,Ñ,¨t×/FÑ/FÑFÈ!ÑKÐ KrP c óN | j j |« }t |« S )z
|
Calculate keyslot for a given key.
|
See Keys distribution model in https://redis.io/topics/cluster-spec
|
)rH Úencoder% )r r rÁ s rN r zRedisCluster.keyslotñ s" ð
|
LL× Ñ Ó $Ü{ÐrP c óp | j « j } | j j |g|¢ S )a£
|
Get the keys in the command. If the command has no keys in in, None is
|
returned.
|
|
NOTE: Due to a bug in redis<7.0, this function does not work properly
|
for EVAL or EVALSHA when the `numkeys` arg is 0.
|
- issue: https://github.com/redis/redis/issues/9493
|
- fix: https://github.com/redis/redis/pull/9733
|
|
So, don't use this function with EVAL or EVALSHA.
|
)r ri rQ Úget_keys)r r[ Ú
|
redis_conns rN Ú_get_command_keysz RedisCluster._get_command_keysù s6 ð ×*Ñ*Ó,×=Ñ=
|
Ø,t×#Ñ#×,Ñ,¨ZÐ?¸$Ò?Ð?rP c óÌ |d }| j j |« t k( r|d S |j « dv r]t |« dk rt d| « t |d « }|dd|z }t |« dk( rt j dt « S |}nY | j | }|t |« dk( r:|j « dv rt j dt « S t d| « t |« dk( r| j |d « S |D ch c] }| j |« }}t |« dk7 rt | d « |j « S c c}w )
|
a
|
Figure out what slot to use based on args.
|
|
Raises a RedisClusterException if there's a missing key and we can't
|
determine what slots to map the command to; or, if the keys don't
|
all map to the same key slot.
|
r rx )ÚEVALÚEVALSHAr zInvalid args in command: rz )ÚFCALLÚFCALL_ROzNo way to dispatch this command to Redis Cluster. Missing key.
|
You can execute the command by specifying target nodes.
|
Command: z) - all keys must map to the same key slot) rJ r} r r© r r5 ÚintrÊ Ú randranger$ r¶ r r )r r[ r_ Únum_actual_keysÚ eval_keysÚkeysr r s rN rª zRedisCluster.determine_slot sy ð q'Ø × Ñ × !Ñ ! 'Ó *¬gÒ 5à7Nð ==?Ð 1Ñ 1ä4yA~Ü+Ð.GÈÀvÐ,NÓOÐOÜ ! $ q¡'lOØ Q _Ñ!4Ð5Iô 9~ Ò"Ü ×'Ñ'¨Ô+CÓDÐDØ Dà)4×)Ñ)¨4Ð0DØ|s 4y¨A~ð ==?Ð&;Ñ;Ü!×+Ñ+¨AÔ/GÓHÐHÜ+ð/à/3¨fð6óð ô t9>Ø<< Q¡Ó(Ð (ð /3Ö3 s cÕ"Ð3Ð3Ü u:?Ü'Ø)ÐDÐEóð ð yy{Ðùò 4s ÄE!c ó | j S )z.
|
Get the connections' encoder
|
)rH rX s rN Ú get_encoderzRedisCluster.get_encoderA s ð ||ÐrP c ó. | j j S )z9
|
Get the connections' key-word arguments
|
)r
|
rà rX s rN Úget_connection_kwargsz"RedisCluster.get_connection_kwargsG s ð ×!Ñ!×3Ñ3Ð3rP c óB t |t « xr || j v S rW )r r~ rK ©r Ú target_nodess rN Ú_is_nodes_flagzRedisCluster._is_nodes_flagM s Ü,¬Ó,ÒP° ÀÇ Á Ð1PÐPrP c óÆ t |t « r|}|S t |t « r|g}|S t |t « r|j « }|S t dt |« « ©Nz°target_nodes type can be one of the following: node_flag (PRIMARIES, REPLICAS, RANDOM, ALL_NODES),ClusterNode, list<ClusterNode>, or dict<any, ClusterNode>. The passed type is ©r rý r r ri Ú TypeErrorÚtype©r rÇ r s rN Ú_parse_target_nodesz RedisCluster._parse_target_nodesP ó{ Ü l¤DÔ )Ø Eð ô ¤kÔ 2à!NEð ô ¤dÔ +ð !×'Ñ'Ó)Eð ô ð&ô '+¨<Ó&8Ð%9ð;óð rP c ó& | j |i |¤S rW )Ú_internal_execute_command©r r[ rÀ s rN Úexecute_commandz RedisCluster.execute_commandd s Ø-t×-Ñ-¨tÐ>°vÑ>Ð>rP c ó¸ d}d}d}|j dd« }|$| j |« s| j |« }d}|rdn| j j « }d|z }t |« D ] } i }
|
|sM | j |i |¤d|i¤}|st d| d « t |« dk( r|d | j « k( rd}|D ]% } | j | g|¢i |¤|
|
| j < ' | j |d |
|
fi |¤c S y# t $ rI} |dkD r=t | « | j j v r |r| j# « |dz }Y d} ~ å| d} ~ ww xY w)
|
a!
|
Wrapper for ERRORS_ALLOW_RETRY error handling.
|
|
It will try the number of times specified by the retries property from
|
config option "self.retry" which defaults to 3 unless manually
|
configured.
|
|
If it reaches the number of times, the command will raise the exception
|
|
Key argument :target_nodes: can be passed with the following types:
|
nodes_flag: PRIMARIES, REPLICAS, ALL_NODES, RANDOM
|
ClusterNode
|
list<ClusterNode>
|
dict<Any, ClusterNode>
|
FNrÇ Tr rx r£ ú!No targets were found to execute ú command on)r rÈ rÏ r¨ Ú get_retriesr r® r5 r r Ú_execute_commandr Ú_process_resultrc rÍ rI r$ r ) r r[ rÀ Útarget_nodes_specifiedÚis_default_noderÇ Úpassed_targetsÚretry_attemptsÚexecute_attemptsÚ_r` r Úes rN rÒ z&RedisCluster._internal_execute_commandg s§ ð "'Ð Ø Ø Ø N°DÓ9Ø Ð %¨d×.AÑ.AÀ.Ô.QØ ×3Ñ3°NÓCLØ%)Ð "ñ 5¸$¿*¹*×:PÑ:PÓ:Rà ~Ñ-ÐÜÐ'Ó(ò Að ØÙ-à#8 4×#8Ñ#8Ø ð$Ø!'ñ$Ø4Bò$Lñ (Ü 3Ø ?À¸vÀ[Ð Qó ð ô LÓ)¨QÒ.Ø (¨O¨t×/DÑ/DÓ/FÒ Fà*.Ø (ò RDØ%: T×%:Ñ%:¸4Ð%QÀ$Ò%QÈ&Ñ%QC NðRð ,t×+Ñ+¨D°©G°SÑC¸FÑCÒCñ) øô* ò Ø! AÒ%¬$¨q«'°T·^±^×5VÑ5VÑ*VÙ&à ×1Ñ1Ô3ð # aÑ'NÜ ð Gûð ús Á1BDÄ EÄ=EÅEÅEc ó |d }d}d}d}d}d} t | j « }
|
|
|
dkD r4|
|
dz }
|
|r| j |¬« }nX| rV | j | } | j j | | j xr |t v |t v r | j nd« }d} | j |« }t |« }|r'|j d« |j |dfi |¤ d} |j |i |¤ |j ||fi |¤} |j dd« || j v r | j | | fi |¤} | | |j j! |« S S tS d « # t" $ r t$ $ r t& t( f$ rj} ||j+ « | j j, j |j. d« d|_ | j j3 « | d} ~ wt4 $ rn} | xj6 dz c_ | j9 « r"| j j3 « d| _ n| j j; | « d} Y d} ~ nÔd} ~ wt< $ r* |
|
| j d z k rt? j@ d
|
« Y ntB $ r-} tE | jF | jH ¬ « }d}Y d} ~ nod} ~ wtJ tL f$ r1 t? j@ d « | j j3 « tN $ r tP $ r} |r|j+ « | d} ~ ww xY w|?|j j! |« n## | |j j! |« w w xY w|
|
dkD rV$)z9
|
Send a command to a node in the cluster
|
r NFrx r ÚASKINGrÀ Tr g©?rM g Ð?zTTL exhausted.)*r¼ r rv rª r
|
r« r+ r r4 rt rZ rp Úparse_responser rO rY Úreleaser+ r3 r. r9 rj r1 r ri Ú
|
initializer4 rL r° Úupdate_moved_exceptionr: Útimer r* rO rG rH r, r8 r7 rc r- )r r r[ rÀ r_ rQ rX Ú redirect_addrÚaskingÚmovedÚttlr rd rá s rN rÙ z RedisCluster._execute_command« sy ð q'Ø
|
Ø
|
Ø ØØÜ$×-Ñ-Ó.àAgØ 1HCðc CÙØ"&§-¡-¸- -Ó"HKÙð /4×.Ñ.°Ð5DØ"&×"4Ñ"4×"GÑ"GØ Ø ×/Ñ/ÒL°G¼}Ð4Là"¤mÑ3ð ×4Ò4à !ó #Kð "Eà !× 6Ñ 6°{Ó C
|
Ü +¨JÓ 7
|
ÙØ ×+Ñ+¨HÔ5Ø-J×-Ñ-¨j¸(ÑMÀfÒMØ "FØ'
|
×'Ñ'¨Ð8°Ò8Ø4:×4Ñ4°ZÀÑSÈFÑSð
|
|
6 4Ô(àd× =Ñ =Ñ=Ø Gt× >Ñ >¸wÑ GØ ñ Ø$*ñ Hð ðD Ð)Ø ×.Ñ.×6Ñ6°zÕBð *ô Ð+Ó,Ð,øôI 'ò ØÜ&ò ð
|
Ü#¤\Ð2ò ð Ð)Ø ×)Ñ)Ô+ð ×"Ñ"×0Ñ0×4Ñ4°[×5EÑ5EÀtÔLà/3 Ô,Ø×"Ñ"×-Ñ-Ô/ØûÜ ò ð ×)Ò)¨QÑ.Õ)Ø×-Ñ-Ô/Ø×&Ñ&×1Ñ1Ô3à01DÕ-à×&Ñ&×=Ñ=¸aÔ@Ø ûÜ ò %Ø×4Ñ4°qÑ8Ò8ÜJJtÔ$ùÜò Ü -°1·6±6ÀÇÁÔ G Ø ûÜ$Ô&9Ð:ò ô
|
|
4Ô Ø×"Ñ"×-Ñ-Ô/ØÜ ò ØÜ ò Ù Ø ×)Ñ)Ô+Øûð úð
|
Ð)Ø ×.Ñ.×6Ñ6°zÕBøð Ð)Ø ×.Ñ.×6Ñ6°zÕBð *úðI Agùsc ±DE* Å*!L6Æ A%G0Ç0 L6Ç<A$I%É M É%3L6ÊM ÊL6Ê"#K
|
ËM Ë
|
AL6Ì L1Ì1L6Ì6M Í M7c ó² | j 5 | j r| j j « d d d « y # 1 sw Y y xY w# t $ r Y y w xY wrW )rT r
|
r[ ÚAttributeErrorrX s rN r[ zRedisCluster.close sQ ð Øñ /Ø×%Ò%Ø×&Ñ&×,Ñ,Ô.÷ /÷ /ñ /ûô ò á ð ús+ A
|
'>µA
|
¾AÁA
|
ÁA
|
Á
|
AÁAc ó¤ || j v r | j | ||fi |¤S t |« dk( r t |j « « d S |S )a
|
Process the result of the executed command.
|
The function would return a dict or a single value.
|
|
:type command: str
|
:type res: dict
|
|
`res` should be in the following format:
|
Dict<node_name, command_result>
|
rx r )rP r rý ri )r r_ r` rÀ s rN rÚ z RedisCluster._process_result) sY ð d×+Ñ+Ñ +Ø14×(Ñ(¨Ñ1°'¸3ÑIÀ&ÑIÐ IÜ X]ô
|
|
Ó% aÑ(Ð (àJrP c ó t | ||« y)a
|
This function can be used to add externally defined redis modules,
|
and their namespaces to the redis client.
|
|
``funcname`` - A string containing the name of the function to create
|
``func`` - The function, being added to this class.
|
N)Úsetattr)r ÚfuncnameÚfuncs rN Úload_external_modulez!RedisCluster.load_external_module= s ô h Õ%rP c óx |j dd« }|j dd« }|j dd« }| j d|« 5 } |r |j | ||« }|j « } |r|n| cddd« S # t $ r ||dkD rt j |« Y bw xY w# 1 sw Y yxY w)zç
|
Convenience method for executing the callable `func` as a transaction
|
while watching all keys specified in `watches`. The 'func' callable
|
should expect a single argument which is a Pipeline object.
|
r NÚvalue_from_callableFÚ watch_delayTr )r r ÚwatchÚexecuter; rè r )
|
r ró ÚwatchesrÀ r rö r÷ ÚpipeÚ
|
func_valueÚ
|
exec_values
|
rN r zRedisCluster.transactionG sà ð ZZ ¨dÓ3
|
Ø $jjÐ)>ÀÓ FÐØ jj °Ó5 Ø ]]4 Ó ,ð °Øð Ù Ø"
|
|
GÑ,Ù!% d£JØ!%§ ¡ £ JÙ)<:À*ÐL÷ ñ øô "ò Ø"Ð.°;À²?Ü
|
|
;Ô/Ù ð ú÷ ð ús* Á B0Á .BÂ%B-Â*B0Â,B-Â-B0Â0B9)Nië Nrz NTé FNTNNNNN©NNN)FrW ©NN)Ng¹?TNNTT©rI N)7r r r Ú classmethodr* r@ r r~ r¼ r Úboolr
|
r r r r) rV rY r` rd rm rG r rt rv r r r rh r r r r? r r r r r r¥ r® r° r r¶ rª r rÄ rÈ rÏ rÔ rÒ rÙ r[ rÚ rô r rL rP rN r& r& Í s Øñ)&ó ð)&ñV Ø*Ð+ØGØôñ
|
à *ð
|
ð =Øô ð #ØØ7;Ø,-Ø#'Ø&*Ø"#Ø#(ØEIØ&*Ø !ØPTØ*.Ø.2Ø6:ñ!H'àsmðH'ð ðH'ð ]Ñ 3Ñ4ð H'ð
|
'*ð H'ð Ñ ð H'ð $ðH'ð ðH'ð !ðH'ð "*Ð*AÑ!BðH'ð $ðH'ð c]ðH'ð ¨%°°S°©/Ð):¸EÀ#ÀsÀ(¹OÐ)KÑ LÑMðH'ð Ñ'ð H'ð {Ñ+ð H'ð # ?Ñ3ò!H'óó ðH'òTòòò ò2ð(%¨ ð %¸5ó %óBòDòDòLò=ó$ò(/ò ðuð ¨ó ó6ó"Nó
|
ð: ØØØ ØØØ'+ñO
|
ð !%óO
|
òb<ð'°4¸ Ñ3Fó 'òRLòò @ð 7 só 7òr ò 4ò Qòò(?òB òHs-ójòò(&ó rP r& c ó& e Zd ZddZd Zd Zd Zy)r Nc ó |dk( rt j |« }|| _ || _ t ||« | _ || _ || _ y )NÚ localhost)ÚsocketÚ gethostbynamerG rH rO r Ú server_typeri )r rG rH r ri s rN rV zClusterNode.__init___ sF Ø ;Ò Ü×'Ñ'¨Ó-Dà Ø Ü! $¨Ó- Ø&ÔØ 0Õ rP c ó d| j d| j d| j d| j d| j d S )Nz[host=z,port=z,name=z ,server_type=z,redis_connection=ú])rG rH r r ri rX s rN Ú__repr__zClusterNode.__repr__i sW àTYYKð ØII;ð ØII;ð Ø ×+Ñ+Ð,ð - Ø $× 5Ñ 5Ð 6°að 9ð
|
rP c óX t |t « xr |j | j k( S rW )r r r )r Úobjs rN Ú__eq__zClusterNode.__eq__r s! Ü#{Ó+ÒE°·±¸D¿I¹IÑ0EÐErP c ór | j | j j « y y # t $ r Y y w xY wrW )ri r[ rc rX s rN rd zClusterNode.__del__u s< ð Ø×$Ñ$Ð0Ø×%Ñ%×+Ñ+Õ-ð 1øäò á ð ús &* ª 6µ6r )r r r rV r r rd rL rP rN r r ^ s ó1ò
|
òFórP r c ó e Zd ZdZdZdZy)r5 Ú round_robinÚround_robin_replicasÚrandom_replicaN)r r r Ú ROUND_ROBINÚROUND_ROBIN_REPLICASÚRANDOM_REPLICArL rP rN r5 r5 ~ s Ø KØ1ÐØ%NrP r5 c ó e Zd ZdZddeddfdZej fdedededefd Z dd
|
Z
|
dedefd Z deded e defd Z y)Ú LoadBalancerz$
|
Round-Robin Load Balancing
|
Ú start_indexrI Nc ó i | _ || _ y rW )Úprimary_to_idxr )r r s rN rV zLoadBalancer.__init__ s Ø ÔØ&ÕrP r{ Ú list_sizer4 c ó |t j k( r| j |« S | j |||t j k( « S rW )r5 r Ú_get_random_replica_indexÚ_get_round_robin_indexr )r r{ r r4 s rN Úget_server_indexz LoadBalancer.get_server_index sL ð #Ô&;×&JÑ&JÒ JØ×1Ñ1°)Ó<Ð <à×.Ñ.ØØØ'Ô+@×+UÑ+UÑUóð rP c ó8 | j j « y rW )r ÚclearrX s rN ÚresetzLoadBalancer.reset s Ø ×Ñ×!Ñ!Õ#rP c ó4 t j d|dz
|
« S )Nrx )rÊ Úrandint)r r s rN r z&LoadBalancer._get_random_replica_index s Ü~~a ¨Q¡ Ó/Ð/rP Ú replicas_onlyc ó | j j || j « }|r|dk( rd}|dz |z | j |< |S rw )r Ú
|
setdefaultr )r r{ r r' Ú server_indexs rN r z#LoadBalancer._get_round_robin_index¢ sQ ð ×*Ñ*×5Ñ5°g¸t×?OÑ?OÓP Ù \¨QÒ .à Là(4°qÑ(8¸IÑ'E×ÑGÑ$ØÐrP )r r )r r r Ú__doc__r¼ rV r5 r r~ r! r$ r r r rL rP rN r r s ññ' Cð '°ó 'ð :O×9ZÑ9Zñ àð ð ð ð "7ð ð
|
|
ó ó $ð0°3ð 0¸3ó 0ð Øð Ø'*ð Ø;?ð à ô rP r c ó. e Zd Zddddedddddf
|
deeeeef geeef f dee dee
|
dee dee f
|
d Z d!d
|
Zd Zd Z ed gdd¬« d"defd« Zd Zd Zd Zd Zd Zd Zd Zd#dZd Z d ed edeeef fd Z d e dee fd Z y)$rN FNTr7 r» r¼ Ú cache_factoryr8 c óÖ i | _ i | _ i | _ d | _ | j |« || _ || _ || _ || _ || _ || _
|
| | _ |
|
| _ d | _ | | _ t « | _ |t# j$ « }|| _ | t) « | _ n| | _ | j j- dd « | _ | j1 « y )Nr )r r
r1 r Úpopulate_startup_nodesr* Ú_require_full_coverageÚ_dynamic_startup_nodesr r7 Ú_cacheÚ _cache_configÚ_cache_factoryÚ_moved_exceptionrà r Úread_load_balancerrR rS rT r) rM r} Ú_credential_providerræ ) r r1 r* r2 r r6 r r7 r» r¼ r- r8 rÀ s rN rV zNodesManager.__init__¯ så ð .0ÔØ ÔØ ÔØ ÔØ ×#Ñ# MÔ2Ø Ø&;Ô#Ø&;Ô#Ø%:Ô"Ø *ÔØ Ø )ÔØ +ÔØ $Ô Ø!'Ô Ü".£.Ô Ø <Ü ??Ó$DØ
|
Ø Ð #Ü%4Ó%6DÕ "à%5DÔ "Ø$(×$:Ñ$:×$>Ñ$>Ø ! 4ó%
|
Ô!ð ÕrP c óÆ |rB|r@|dk( rt j |« }| j j t ||¬« « S |r| j j |« S y)z
|
Get the requested node from the cluster's nodes.
|
nodes.
|
:return: ClusterNode if the node exists, else None
|
r rM N)r r r r} rO rw s rN rv zNodesManager.get_nodeÚ s\ ñ Dà{Ò"Ü ×+Ñ+¨DÓ1Ø×#Ñ#×'Ñ'¬ ¸4ÀdÔ(KÓLÐ LÙ Ø×#Ñ#×'Ñ'¨ Ó2Ð 2àrP c ó || _ y rW )r5 )r Ú exceptions rN rç z#NodesManager.update_moved_exceptionê s
|
Ø )Õ rP c ó | j }| j |j |j ¬« }| |j t
|
urJt
|
|_ n>t |j |j t
|
« }|| j |j < || j |j v r±| j |j d }t |_ | j |j j |« | j |j j |« || j |j d< | j |k( r)|| _ d| _ y|g| j |j < d| _ y)z@
|
Update the slot's node with the redirected one
|
rM Nr )r5 rv rG rH r rz r r r r
Úslot_idr} r Úremover )r rá Úredirected_nodeÚ old_primarys rN Ú_update_moved_slotsz NodesManager._update_moved_slotsí sE ð × !Ñ !Ø --¨Q¯V©V¸!¿&¹&-ÓAØ Ð &à ×*Ñ*´'Ñ9ä.5Õ+ô *¨!¯&©&°!·&±&¼'Ó BOØ5DD× Ñ _× 1Ñ 1Ñ 2Ø d× .Ñ .¨q¯y©yÑ 9Ñ 9ð ×*Ñ*¨1¯9©9Ñ5°aÑ8Kô '.KÔ #Ø × Ñ QYYÑ '× .Ñ .¨{Ô ;ð × Ñ QYYÑ '× .Ñ .¨Ô ?à-<D× Ñ QYYÑ '¨Ñ *Ø× Ñ KÒ/à$3Ô!ð !%Õ ð ,;Ð*;D× Ñ QYYÑ 'à $Õ rP r z|In case you need select some load balancing strategy that will use replicas, please set it through 'load_balancing_strategy'rR r, rI c ó | j r1| j 5 | j r| j « ddd« | j j |« t | j | « dk( r t d| d| j d« |du r|t j }t | j | « dkD rR|rP| j | d j }| j j |t | j | « |« }nX|$|t k( st | j | « dk( rd}n/t j dt | j | « dz
|
« }| j | | S # 1 sw Y IxY w)z9
|
Gets a node that servers this hash slot
|
Nr r z5" not covered by the cluster. "require_full_coverage=ú"Trx )r5 rT r@ r
r} r r8 r0 r5 r r r6 r! rz rÊ r& )r r r+ r4 r Ú primary_namer s rN r« z NodesManager.get_node_from_slot s ð$ × Ò Øñ /Ø×(Ò(Ø×,Ñ,Ô.÷ /ð × Ñ × Ñ Ó %Ð -´°T×5EÑ5EÀdÑ5KÓ1LÐPQÒ1QÜ%Øð *Ø*.×*EÑ*EÐ)FÀaðIóð ð
|
Ñ %Ð*AÐ*IÜ&;×&GÑ&GÐ #ä t× Ñ Ñ%Ó &¨Ò *Ñ/Fà ×+Ñ+¨DÑ1°!Ñ4×9Ñ9LØ×.Ñ.×?Ñ?Ø c $×"2Ñ"2°4Ñ"8Ó 9Ð;RóHð Ð ØgÒ%Ü4×#Ñ# DÑ)Ó*¨aÒ/ð Hô ~~ a¬¨T×-=Ñ-=¸dÑ-CÓ)DÀqÑ)HÓIHà× Ñ Ñ% hÑ/Ð/÷? /ñ /ús E=Å=Fc óz | j j « D cg c] }|j |k( r| c}S c c}w )z
|
Get all nodes with the specified server type
|
:param server_type: 'primary' or 'replica'
|
:return: list of ClusterNode
|
)r ri r )r r r s rN ry z%NodesManager.get_nodes_by_server_typeH sA ð ×(Ñ(×/Ñ/Ó1ö
|
àØ× Ñ ;Ò.ò ò
|
ð
|
ùò
|
s 8c óD |D ] }|| j |j < y)zK
|
Populate all startup nodes and filters out any duplicates
|
N)r1 r )r r Úns rN r/ z#NodesManager.populate_startup_nodesT s' ð ò +AØ)*D× Ñ qvvÒ &ñ +rP c ó: t dt « D ] }||vs y y)Nr FT)r r$ )r r
r s rN Úcheck_slots_coveragez!NodesManager.check_slots_coverage[ s+ ô qÔ2Ó3ò AØ Ò#Ù ð ð rP c óf g }|D ]l }|j | j d|j |j d| j ¤|_ |j |j j « n | j j t |t j | j « « y)zV
|
This function will create a redis connection to all nodes in :nodes:
|
NrM rL ) ri Úcreate_redis_noderG rH rà r rY rM Údispatchr& r( ÚSYNCr7 )r r Úconnection_poolsr s rN rs z%NodesManager.create_redis_connectionsc s§ ð ÐØò ODØ×$Ñ$Ñ,Ø(>¨×(>Ñ(>ð )Ø ¨¯©ñ)Ø6:×6LÑ6Lñ)Ô%ð !×'Ñ'¨×(=Ñ(=×(MÑ(MÕNð Oð × Ñ ×'Ñ'Ü 4Ø ¤*§/¡/°4×3LÑ3Ló õ
|
rP c óÖ t t « dt f¬« }|j dd « }|dv r |j dt d¬« i« | j rt|j d|i« |j d |i« |j d
|
| j i« |j d |i« t | j di |¤¬ « }|S t d||| j |d |¤}|S )Nr )r@ rA Úsupported_errorsrª rC Úmaint_notifications_configF)ÚenabledrG rH r» r¨ )rY )rG rH r» r¨ rL )
|
r? r r. r} rE r> r* r2 r r )r rG rH rÀ Únode_retry_configrª rf s rN rJ z NodesManager.create_redis_nodeu sô ô "Ü K¨¼oÐ=Oô
|
Ðð ::j¨$Ó/Ø xÑ Ø MMØ-Ô/GÐPUÔ/VÐWô ð ==à MM6 4.Ô )Ø MM6 4.Ô )Ø MM7 D§K¡KÐ0Ô 1Ø MM7Ð$5Ð6Ô 7ÜÐ&@ d×&@Ñ&@Ñ&JÀ6Ñ&JÔKAð ô ð ØØØkkØ'ñ ð
|
ñ Að rP c óú t ||« }|j |« }|[| j j |« }| |j t |||« }|j
|
|k7 r||_ |||j < |S rW )rO r} r ri r r r )r rG rH ÚroleÚtmp_nodes_cacherc r s rN Ú_get_or_create_cluster_nodez(NodesManager._get_or_create_cluster_node s Ü! $¨Ó- à%×)Ñ)¨)Ó4 Ø Ð ð ×*Ñ*×.Ñ.¨yÓ9KØÐ" k×&BÑ&BÐ&Jä )¨$°°dÓ ; Ø×&Ñ&¨$Ò.Ø*. Ô'à0;OK× ,Ñ ,Ñ -àÐrP c
|
óh | j « i }i }g }d}d}| j }d}t | j j « « D ] } |j
|
r |j
|
} nF | j |j |j fi |¤} | | j |j _ t | j d« « }
|
| j j « d}t# |
|
« dk( rDt# |
|
d d d « dk( r-t# | j « dk( r|j |
|
d d d< |
|
D ] } | d } t | d « }|d k( r |j }t% | d « }| j' ||« \ }}g }| j) ||t* |« }|j- |« | d
|
d }|D ]\ }t |d « }t% |d « }| j' ||« \ }}| j) ||t. |« }|j- |« ^ t1 t% | d « t% | d « dz « D ] }||vr|||< || d }|j |j k7 s/|j- |j d |j d | « t# |« d kD skt ddj3 |« « | j5 |« }|s n |st dt7 |« « || j8 `| j: T| j< )t? | j: « jA « | _ n | j< jA « | _ | jC tE |j « « « |s+| jF r t dt# |« dtH d« || _% || _& | jO t* « d | _( | jR r|| _ d| _* y# t $ r t d« w xY w# t $ r } | }Y d} ~ àd} ~ ww xY w)z¬
|
Initializes the nodes cache, slots cache and redis connections.
|
:startup_nodes:
|
Responsible for discovering other nodes in the cluster
|
FNrì z(Cluster mode is not enabled on this nodeTrx r r ru rz z vs z
|
on slot: rþ z6startup_nodes could not agree on a valid slots cache: z, zORedis Cluster cannot be connected. Please provide at least one reachable node: z9All slots are not covered after query all startup_nodes. z of z covered...)+r$ rà Útupler1 ri ri rJ rG rH r rE rÔ rY rj r7 r5 rc r r¼ Úremap_host_portrV rz r r} r ÚjoinrH r~ r2 r3 r4 r Ú get_cachers rý r0 r$ r r
ry r r1 r5 )r rU Ú tmp_slotsÚ disagreementsÚstartup_nodes_reachableÚ fully_coveredrÀ r: Ú startup_noderf Ú cluster_slotsrá r Ú primary_noderG rH Únodes_for_slotr Ú replica_nodesÚ replica_nodeÚtarget_replica_noder Útmp_slots rN ræ zNodesManager.initialize¬ s ð
|
|
Ø Ø Ø Ø"'Ð Ø Ø×'Ñ'Ø ô " $×"4Ñ"4×";Ñ";Ó"=Ó >ó V Lð Ø ×0Ò0Ø$×5Ñ5Að /×.Ñ.Ø$×)Ñ)¨<×+<Ñ+<ñØ@FñAð NOD×&Ñ& |×'8Ñ'8Ñ9ÔJðÜ$0°×1BÑ1BÀ?Ó1SÓ$TMØ×%Ñ%×0Ñ0Ô2ð
|
+/Ð'ô MÓ" aÒ'Ü aÑ(¨Ñ+¨AÑ.Ó/°1Ò4Ü×*Ñ*Ó+¨qÒ0à)5×):Ñ): aÑ Ñ# AÑ&à%ó ) "Ø # Aw Ü# L°¡OÓ4Ø2:Ø'×,Ñ,DÜ<¨?Ó+Ø !× 1Ñ 1°$¸Ó =
|
dà!#à "× >Ñ >Ø$¤¨ ó ð ×%Ñ% kÔ2à $ Q R Ø$1ò ?LÜ'¨ °Q©Ó8DÜ |¨AÓ/DØ!%×!5Ñ!5°d¸DÓ!AJD$Ø*.×*JÑ*JØ d¤G¨_ó+Ð'ð #×)Ñ)Ð*=Õ>ð?ô s 4¨¡7|¬S°°a±«\¸AÑ-=Ó>ò "AØ Ñ)Ø'5 ! ð $-¨Q¡<°¡?Ø#==¨K×,<Ñ,<Ó<Ø )× 0Ñ 0Ø#+§=¡= /°°k×6FÑ6FÐ5GÀzÐRSÐQTÐ Uô ô # =Ó 1°AÓ 5Ü&;ð'4Ø48·I±I¸mÓ4LÐ3Mð%Oó'"ð !"ò"ð3) "ðV !× 5Ñ 5°iÓ @MÛ ñ ðmV ñp 'Ü'ð'Ü'*¨9£~Ð&6ð8óð ð ð
|
;;Ð 4×#5Ñ#5Ð#AØ×"Ñ"Ð*Ü *¨4×+=Ñ+=Ó >× HÑ HÓ J à "× 1Ñ 1× ;Ñ ;Ó = ð ×%Ñ%¤d¨?×+AÑ+AÓ+CÓ&DÔEñ ×!<Ò!<ô (ØKÜy>Ð" $Ô'?Ð&@ð A ð óð ð +ÔØ$Ôà × 9Ñ 9¼'Ó BÀ1Ñ EÔØ × &Ò &à!0DÔ à $Õ øôY %ò Ü/ØBóð ðûô
|
ò ð Ýûð ús1 ÁA PÂ14PÃ%PÐPÐPÐ P1Ð$P,Ð,P1c ó d | _ | j j « D ]) }|j s|j j « + y rW )r r ri ri r[ rl s rN r[ zNodesManager.close8 sC Ø ÔØ×$Ñ$×+Ñ+Ó-ò .DØ×$Ó$Ø×%Ñ%×+Ñ+Õ-ñ .rP c óX | j j « y # t $ r Y y w xY wrW )r6 r$ rÌ rX s rN r$ zNodesManager.reset> s+ ð Ø × #Ñ #× )Ñ )Õ +øÜò á ð ús )¨)rG rH c óH | j r| j ||f« S ||fS )z³
|
Remap the host and port returned from the cluster to a different
|
internal value. Useful if the client is not connecting directly
|
to the cluster.
|
)r7 )r rG rH s rN rY z NodesManager.remap_host_portE s, ð × Ò Ø×%Ñ% t¨T lÓ3Ð 3ØTzÐrP rX c óP t |j |j « }t | j j « « D ]` }|j s|j j j }|t |j d« |j d« « k( s^|c S y )NrG rH )
|
rO rG rH rX r ri ri rY rà r} )r rX rc r Ú conn_argss rN Úfind_connection_ownerz"NodesManager.find_connection_ownerO s Ü! *§/¡/°:·?±?ÓC Ü$×*Ñ*×1Ñ1Ó3Ó4ò DØ×$Ó$Ø × 1Ñ 1× AÑ A× SÑ S Ø ¤ Ø MM &Ó)¨9¯=©=¸Ó+@ó!ó ð Kñ rP rÿ )FNNr )!r r r r" r r
|
r r~ r¼ r r r r) rV rv rç r@ r@ r r« ry r/ rH rs rJ rV ræ r[ r$ rY r! r rm rL rP rN rN rN ® sI ð Ø #Ø Ø "Ø ,ØPTØ*.Ø.2Ø9=Ø6:ñ)ð ¨%°°S°©/Ð):¸EÀ#ÀsÀ(¹OÐ)KÑ LÑMð)ð Ñ'ð)ð {Ñ+ð)ð Ð 5Ñ6ð)ð # ?Ñ3ó)óVò *ò%%ñN Ø#_ð Vð ô ð !Ø $Øñ *0ð
|
ò *0óð*0òX
|
|
ò+òò
|
ò$"òHò&J%óX.ò ð Cð ¨sð °u¸SÀ#¸X±ó ð °
|
ð ¸xȹô rP rN c ó e Zd ZdZ dded f fd ZddZd Zd Zd Z d Z
|
d
|
Z d Z dd Z d Zd Zd Zd Z xZS )r zô
|
Wrapper for PubSub class.
|
|
IMPORTANT: before using ClusterPubSub, read about the known limitations
|
with pubsub in Cluster mode and learn how to workaround them:
|
https://redis-py-cluster.readthedocs.io/en/stable/pubsub.html
|
r8 r) c ój d| _ | j ||||« | j dn$|j | j « j }|| _ i | _ | j « | _ |t « | _ n|| _ t | ( d||j || j d|¤ y)aL
|
When a pubsub instance is created without specifying a node, a single
|
node will be transparently chosen for the pubsub connection on the
|
first command execution. The node will be determined by:
|
1. Hashing the channel name in the request to find its keyslot
|
2. Selecting a node that handles the keyslot: If read_from_replicas is
|
set to true or load_balancing_strategy is set, a replica can be selected.
|
|
:type redis_cluster: RedisCluster
|
:type node: ClusterNode
|
:type host: str
|
:type port: int
|
N)rY rH Úpush_handler_funcr8 rL ) r Úset_pubsub_nodert rY ÚclusterÚnode_pubsub_mappingÚ_pubsubs_generatorr) rM ÚsuperrV rH )
|
r Ú redis_clusterr rG rH rp r8 rÀ rY rI s
|
rN rV zClusterPubSub.__init__c s½ ø ð. Ø × Ñ ]¨D°$¸Ô=ð yyÐ ñ à ×3Ñ3°D·I±IÓ>×NÑNð ð
|
% Ø#%Ô Ø"&×"9Ñ"9Ó";Ô Ø Ð #Ü%4Ó%6DÕ "à%5DÔ "Ü Ñð
|
Ø +Ø!×)Ñ)Ø /Ø !× 3Ñ 3ñ
|
ð
|
ó
|
rP c ó |2| j |||j |j « |}|| _ y|3|1|j ||¬« }| j ||||« |}|| _ yt ||g« du r t d« d}|| _ y)aN
|
The pubsub node will be set according to the passed node, host and port
|
When none of the node, host, or port are specified - the node is set
|
to None and will be determined by the keyslot of the channel in the
|
first command to be executed.
|
RedisClusterException will be thrown if the passed node does not exist
|
in the cluster.
|
If host is passed without port, or vice versa, a DataError will be
|
thrown.
|
:type cluster: RedisCluster
|
:type node: ClusterNode
|
:type host: str
|
:type port: int
|
NrM Tz6Passing a host requires passing a port, and vice versa)Ú_raise_on_invalid_noderG rH rv Úanyr0 r )r rr r rG rH Ú pubsub_nodes rN rq z ClusterPubSub.set_pubsub_node s¥ ð Ð à × 'Ñ '¨°°t·y±yÀ$Ç)Á)Ô LØ Kð ð Ð $Ð"2à×#Ñ#¨°DÐ#Ó9DØ × 'Ñ '¨°°t¸TÔ BØ Kð ô $ Ó $Ñ &äÐ TÓUÐ Uð Kà rP c ó | j S )zJ
|
Get the node that is being used as the pubsub connection
|
)r rX s rN Úget_pubsub_nodez ClusterPubSub.get_pubsub_node± s ð yyÐrP c ód | |j |j ¬« t d| d| d« y)zl
|
Raise a RedisClusterException if the node is None or doesn't exist in
|
the cluster.
|
Nr zNode rK z doesn't exist in the cluster)rv r r5 )r rv r rG rH s rN rx z$ClusterPubSub._raise_on_invalid_node· sF ð
|
<=×1Ñ1¸D¿I¹IÐ1ÓFÐNÜ'ØvQtfÐ$AÐBóð ð OrP c óÄ | j ©| j Ët |« dkD rp|d }| j j |« }| j j
|
j || j j | j j « }n| j j « }|| _
|
| j j |« }|j | _ | j j « | _ | j j | j « | j /| j j j# | j « | j$ j' t) | j | j t* j, | j. « « | j } | j0 ||j2 g|¢ y)z
|
Execute a subscribe/unsubscribe command.
|
|
Taken code from redis-py and tweak to make it work within a cluster.
|
Nrx )rX rY r rr r r
|
r« r+ r4 r r rt rZ Úregister_connect_callbackrG rp Ú_parserÚset_pubsub_push_handlerrM rK r' r( rL rT Ú_executerp )r r[ rm r r ri rX s rN rÔ z ClusterPubSub.execute_commandÁ sn ð ??Ñ "Ø×#Ñ#Ð+Üt9q=ð # 1gGØ <<×/Ñ/°Ó8DØ <<×5Ñ5×HÑHØ Ø ×7Ñ7Ø ×<Ñ<ó Dð <<×7Ñ7Ó9DØ Ø#'§<¡<×#DÑ#DÀTÓ#JÐ Ø'7×'GÑ'GÔ$Ø "× 2Ñ 2× AÑ AÓ CDOð OO× 5Ñ 5°d·o±oÔ FØ×%Ñ%Ð1Ø×'Ñ'×?Ñ?À×@VÑ@VÔWØ × "Ñ "× +Ñ +Ü7ØOO T×%9Ñ%9¼:¿?¹?ÈDÏJÉJóô ð
|
__
|
Ø j *×"9Ñ"9ÐA¸DÔArP c óÖ | j |j S # t $ rD |j j | j
|
¬« }|| j |j < |cY S w xY w)N)rp )rs r rj ri r rp )r r r s rN Ú_get_node_pubsubz ClusterPubSub._get_node_pubsubë sj ð Ø×+Ñ+¨D¯I©IÑ6Ð 6øÜò Ø×*Ñ*×1Ñ1Ø"&×"8Ñ"8ð 2ó Fð 39D× $Ñ $ T§Y¡YÑ /ØMð ús A
|
A(Á'A(c ó t t | j « « D ]- }t | j « }|j « }|+|c S y rW )r r rs Únextrt Ú get_message)r rà r Úmessages rN Ú_sharded_message_generatorz(ClusterPubSub._sharded_message_generatorõ sO Üs4×3Ñ3Ó4Ó5ò AÜ$×1Ñ1Ó2FØ ×(Ñ(Ó*GØÑ"Ø ð ð
|
rP c # óV K | j j « E d { #7 wrW )rs ri rX s rN rt z ClusterPubSub._pubsubs_generatorý s) è ø ØØ×/Ñ/×6Ñ6Ó8× 8Ð 8ð Ø 8ús )¡'¢)c ó® |r+| j |j j ||¬« }n| j « }|y t |d « dk( r¶|d | j
|
v r¥| j
|
j |d « | j j |d d « | j j |d « }| j |j j du r%| j j |j « | j s2| j s&| j s| j j « | j s|ry |S )N)Úignore_subscribe_messagesr¦ rÍ Ú sunsubscriberm F)rs r r r rE Ú"pending_unsubscribe_shard_channelsr= Úshard_channelsr rr r Ú
|
subscribedÚchannelsÚpatternsÚsubscribed_eventr# r )r r r¦ r r r s rN Úget_sharded_messagez!ClusterPubSub.get_sharded_message s. ñ Ø×.Ñ.¨{×/?Ñ/?Ñ@×LÑLØ*CÈWð Mó Gð ×5Ñ5Ó7GØ ?ØÜ ' &/Ó *¨nÒ <ØyÑ! T×%LÑ%LÑLØ×7Ñ7×>Ñ>¸wÀyÑ?QÔRØ×#Ñ#×'Ñ'¨° Ñ(:¸DÔAØ||×5Ñ5°g¸iÑ6HÓIØ×+Ñ+¨D¯I©IÑ6×AÑAÀUÑJØ×,Ñ,×0Ñ0°·±Ô;Ø}} T§]¢]¸4×;NÒ;Nð × !Ñ !× 'Ñ 'Ô )Ø × )Ò )Ñ-FØØrP c óh |rt |d |dd « }t j |« }|j |« |j « D ]å \ }}| j
|
j |« }| j |« }|r |j di ||i¤ n|j |« | j j |j « | j j | j |d i« « |j s¸| j rÅ| j j « d| _ ç y )Nr rx rL )r r ÚfromkeysrE r^ rr r r Ú
|
ssubscriber r Údifference_updateÚ_normalize_keysr r ÚsetÚ health_check_response_counter)r r[ rÀ Ú
|
s_channelsÚ s_channelÚhandlerr r s rN r zClusterPubSub.ssubscribe s Ù Ü Q¡¨¨a¨b¨Ó2DÜ]] 4Ó(
|
Ø×Ñ&Ô!Ø",×"2Ñ"2Ó"4ò 7Ñ IwØ<<×1Ñ1°)Ó<DØ×*Ñ*¨4Ó0FÙØ!×!Ñ!Ñ9 Y°Ð$8Ó9à×!Ñ! )Ô,Ø × Ñ × &Ñ & v×'<Ñ'<Ô =Ø × 3Ñ 3× EÑ EØ×$Ñ$ i°Ð%6Ó7ô ð × Ó ¨¯ « Ø×%Ñ%×)Ñ)Ô+Ø56Õ2ñ 7rP c ó |rt |d |dd « }n | j }|D ]d }| j j |« }| j |« }|j |« | j j |j « f y rw )r r rr r r r r rE )r r[ r r Úps rN r zClusterPubSub.sunsubscribe/ s Ù Ü Q¡¨¨a¨b¨Ó2Dà×&Ñ&Dà ò IØ<<×1Ñ1°)Ó<DØ×%Ñ% dÓ+AØ NN9Ô %Ø × 3Ñ 3× :Ñ :Ø×4Ñ4õ ñ rP c óH | j | j j S y)zH
|
Get the Redis connection of the pubsub connected node.
|
N)r ri rX s rN rt z"ClusterPubSub.get_redis_connection= s# ð 99Ð Ø99×-Ñ-Ð -ð !rP c óÂ | j r| j j « | j j « D ] }|j j « y)z3
|
Disconnect the pubsub connection.
|
N)rX rj rs ri )r r s rN rj zClusterPubSub.disconnectD sK ð ??Ø OO× &Ñ &Ô (Ø×.Ñ.×5Ñ5Ó7ò +FØ × Ñ × (Ñ (Õ *ñ +rP )NNNNNrÿ )Fg N)r r r r+ r rV rq r| rx rÔ r r rt r r r rt rj Ú __classcell__©rI s @rN r r Z su ø ñð Ø Ø Ø Ø8<ñ+
|
ð #Ð#4Ñ5õ+
|
óZ òBò ò(BòTòò9ð
|
IMóò47ò( ò .ö+rP r c óv e Zd ZdZeeeeefZ dhZ
|
ddhZ h d£Z e dgdd¬« d.d d
|
d d d eeeef deeeef deed dedee dededee f fd « Zd Zd Zd Zd Zd Z d Z d Z d Z d Z d/d ed ee! fd!Z"d" Z# d0d#Z$d$ Z%d% Z&d& Z'd' Z(d( Z)d) Z*d* Z+d+ Z,d, Z-d- Z. xZ/S )1r z8
|
Support for Redis pipeline
|
in cluster mode
|
ÚUNWATCHÚWATCH> ÚEXECÚDISCARDr¦ r. r/ r0 r, r
|
rN rQ r rP rO r1 r r+ r4 r3 r¨ c ó¶ g | _ || _ || _ d| _ |xs$ | j j
|
j « | _ |r|ng | _ || _ || _
|
| j j j « | _ || _ d| _ | | _ |
|
|
|
| _ n t# t% dd¬« |¬« | _ t' | j) dd « | j) d
|
d « | j) d d« « | _ | t- j. « } | | _ t2 | h | _ | st9 | « | _ yt; | « | _ y) r¨ Fr Nrx r; r< r? r r r rB r ) Ú command_stackr
|
rQ Úrefresh_table_asaprI r# r rP r1 r+ r4 r rJ rO rL r3 r¨ r? r r r} rH rR rS rT ru rÔ Úparent_execute_commandÚPipelineStrategyÚTransactionStrategyÚ_execution_strategy)r r
|
rQ rP rO r1 r+ r4 r. r3 r¨ r r rÀ rI s rN rV zClusterPipeline.__init__` sC ø ð0 ÔØ *ÔØ .Ô Ø"'Ô à Ò F §¡× ?Ñ ?× DÑ DÓ Fð Ô ñ /<]ÀÔØ"4Ô Ø'>Ô$Ø !^^× 9Ñ 9× >Ñ >Ó @ÔØ*DÔ'Ø$%Ô!Ø"4Ô Ø Ð Ø DJä Ü4¸!ÀÔDØ4ôDJô
|
Ø JJz 7Ó +Ø JJÐ(¨(Ó 3Ø JJÐ)¨5Ó 1ó
|
ð
|
<Ü ??Ó$DØ
|
Ü&+¡gÑ&=Ô#á*5Ô TÓ "ð Õ Ü;NÈtÓ;Tð Õ rP c ó. t | « j S ©r¨ )rÍ r rX s rN r zClusterPipeline.__repr__ s ät*×%Ñ%Ð&Ð'rP c ó | S r² rL rX s rN rY zClusterPipeline.__enter__ s à rP c ó$ | j « y©r¨ N©r$ r\ s rN r` zClusterPipeline.__exit__£ s à
|
|
rP c óD | j « y # t $ r Y y w xY wrW )r$ rc rX s rN rd zClusterPipeline.__del__§ re rf c ó@ t | j j « S r² )r r° Ú command_queuerX s rN Ú__len__zClusterPipeline.__len__ s ä4×+Ñ+×9Ñ9Ó:Ð:rP c ó y)z?Pipeline instances should always evaluate to True on Python 3+TrL rX s rN Ú__bool__zClusterPipeline.__bool__± s àrP c ó: | j j |i |¤S )z?
|
Wrapper function for pipeline_execute_command
|
©r° rÔ rÓ s rN rÔ z ClusterPipeline.execute_commandµ s" ð 8t×'Ñ'×7Ñ7¸ÐHÀÑHÐHrP c ó: | j j |i |¤S )ar
|
Stage a command to be executed when execute() is next called
|
|
Returns the current Pipeline object back so commands can be
|
chained together, such as:
|
|
pipe = pipe.set('foo', 'bar').incr('baz').decr('bang')
|
|
At some other point, you can then run: pipe.execute(),
|
which will execute all commands queued in the pipe.
|
r¾ ©r r[ r\ s rN Úpipeline_execute_commandz(ClusterPipeline.pipeline_execute_command» s" ð 8t×'Ñ'×7Ñ7¸ÐIÀÑIÐIrP c ó> | j j |||« y)úS
|
Provides extra context to the exception prior to it being handled
|
N)r° Úannotate_exception©r r: Únumberr_ s rN rÄ z"ClusterPipeline.annotate_exceptionÉ s ð × Ñ ×3Ñ3°I¸vÀwÕOrP Úraise_on_errorrI c ó | j j |« | j « S # | j « w xY w)zB
|
Execute all the commands in the current pipeline
|
)r° rù r$ ©r rÇ s rN rù zClusterPipeline.executeÏ s. ð
|
Ø×+Ñ+×3Ñ3°NÓCà JJLøDJJLús - ?c ó8 | j j « y©z/
|
Reset back to empty pipeline.
|
N)r° r$ rX s rN r$ zClusterPipeline.resetÙ s ð × Ñ ×&Ñ&Õ(rP c ó> | j j |||¬« S )N©rÇ Úallow_redirections)r° Úsend_cluster_commands©r ÚstackrÇ rÎ s rN rÏ z%ClusterPipeline.send_cluster_commandsß s* ð ×'Ñ'×=Ñ=Ø .ÐEWð >ó
|
ð
|
rP c ó4 | j j | S rW )r° Úexists©r rÀ s rN rÓ zClusterPipeline.existsæ s Ø.t×'Ñ'×.Ñ.°Ð5Ð5rP c ó6 | j j « S r² )r° ÚevalrX s rN rÖ zClusterPipeline.evalé s à×'Ñ'×,Ñ,Ó.Ð.rP c ó8 | j j « y)z
|
Start a transactional block of the pipeline after WATCH commands
|
are issued. End the transactional block with `execute`.
|
N)r° ÚmultirX s rN rØ zClusterPipeline.multií s ð
|
× Ñ ×&Ñ&Õ(rP c ó8 | j j « yrµ )r° Ú load_scriptsrX s rN rÚ z ClusterPipeline.load_scriptsô s à × Ñ ×-Ñ-Õ/rP c ó8 | j j « yrµ )r° ÚdiscardrX s rN rÜ zClusterPipeline.discardø ó à × Ñ ×(Ñ(Õ*rP c ó6 | j j | y)z$Watches the values at keys ``names``N)r° rø ©r Únamess rN rø zClusterPipeline.watchü s à&× Ñ ×&Ñ&¨Ò.rP c ó8 | j j « y)z'Unwatches all previously specified keysN)r° ÚunwatchrX s rN râ zClusterPipeline.unwatch rÝ rP c ó< | j j |i |¤ y rW )r° Úscript_load_for_pipelinerÓ s rN rä z(ClusterPipeline.script_load_for_pipeline s Ø9× Ñ ×9Ñ9¸4ÐJÀ6ÓJrP c ó6 | j j | y rW )r° Údeleterß s rN ræ zClusterPipeline.delete ó Ø'× Ñ ×'Ñ'¨Ò/rP c ó6 | j j | y rW )r° Úunlinkrß s rN ré zClusterPipeline.unlink
|
rç rP )
|
NNNFNrz rþ NNF©T©TT)0r r r r+ r. r9 r4 r* r: r$ ÚNO_SLOTS_COMMANDSÚIMMEDIATE_EXECUTE_COMMANDSÚUNWATCH_COMMANDSr@ r r r~ r
|
r r r5 r¼ r? rV r rY r` rd rº r¼ rÔ rÁ rÄ r rù r$ rÏ rÓ rÖ rØ rÚ rÜ rø râ rä ræ ré r£ r¤ s @rN r r N s ø ñð ØØØØð Ðð # ÐØ")¨9Ð!5Ð Ú5Ðáà *ð
|
ð =Øô ð ;?ØDHØ7;Ø#(ØCGØ,-Ø"#Ø!%Ø Øñ2
|
à%ð2
|
ð *ð2
|
ð # 4¨¨X¨ Ñ#6Ñ7ð 2
|
ð
|
%-¨T°#°x°-Ñ-@Ñ$Að 2
|
ð ]Ñ 3Ñ4ð 2
|
ð !ð2
|
ð "*Ð*?Ñ!@ð2
|
ð '*ð2
|
ð ð2
|
ð ô2
|
óð2
|
òh(òòòò ;òòIò Jò Pñ dð °d¸3±ió ò)ð >Bó
|
ò6ò/ò)ò0ò+ò/ò+òKò0ö0rP r r .c ó fd}|S )zi
|
Prints error because some pipelined commands should
|
be blocked when running in cluster-mode
|
c ó" t d d« )Nz"ERROR: Calling pipelined function z1 is blocked when running redis in cluster mode...©r5 )r[ rÀ r s rN Úinnerz%block_pipeline_command.<locals>.inner s! ø Ü#Ø0°°ð 74ð 5ó
|
ð
|
rP rL )r rò s ` rN Úblock_pipeline_commandró s ø ô
|
ð LrP )EÚ BGREWRITEAOFrÝ ÚBITOPÚ
|
BRPOPLPUSHrÎ ré rÌ rÍ ÚCLIENTrï rÑ rÐ rÏ ÚCONFIGrÜ ÚECHOr¹ rõ rö rÙ rÛ rå ÚMGETzMGET NONATOMICÚMOVEÚMSETzMSET NONATOMICÚMSETNXÚPFCOUNTÚPFMERGErØ ÚPUBLISHrñ rê rò ÚRENAMEÚRENAMENXÚ RPOPLPUSHrã r÷ rø rù z SCRIPT KILLrú ÚSCRIPTÚSDIFFÚ
|
SDIFFSTOREz SENTINEL GET MASTER ADDR BY NAMEzSENTINEL MASTERzSENTINEL MASTERSzSENTINEL MONITORzSENTINEL REMOVEzSENTINEL SENTINELSz SENTINEL SETzSENTINEL SLAVESÚSENTINELrÚ ÚSINTERÚ SINTERSTOREÚSLAVEOFrÞ rß rà ÚSLOWLOGÚSMOVEÚSORTÚSUNIONÚ SUNIONSTORErÒ r¨ rà c ó e Zd ZdZddZy)ÚPipelineCommandr¨ Nc ó` || _ |i }|| _ || _ d | _ d | _ d| _ y ©NF)r[ r\ ÚpositionÚresultr rê )r r[ r\ r s rN rV zPipelineCommand.__init__n s6 Ø Ø ?ØGØ Ø Ø Ø Ø rP r )r r r r+ rV rL rP rN r r k s
|
Ù ô rP r c ó( e Zd ZdZd Zd Zd Zd Zy)Ú NodeCommandsr¨ c ó< || _ || _ || _ g | _ yrµ )rä rY rX Úcommands)r rä rY rX s rN rV zNodeCommands.__init__| s à ,ÔØ .Ô Ø$Ø rP c ó: | j j |« yrµ )r r )r Úcs rN r zNodeCommands.append s à × Ñ QÕ rP c ó | j }| j }|D ] }d|_ |j |j |D cg c] }|j
|
c}« « yc c}w # t t f$ r}|D ] }||_ Y d}~yd}~ww xY w)z=
|
Code borrowed from Redis so it can be fixed
|
N)rX r r Úsend_packed_commandÚ pack_commandsr[ r. r9 )r rX r r rá s rN ÚwritezNodeCommands.write s ð __
|
Ø==ð ò AØAHð ð
|
Ø × *Ñ *Ø×(Ñ(¸(Ö)C°Q¨!¯&«&Ò)CÓDõ ùÚ)Cøä ¤ Ð.ò Ø ò Ø õ ûð ús) ¨A& ÁA! Á A& Á!A& Á&B Á5BÂB c óp | j }| j D ]@ }|j | j ||j d fi |j
|
¤|_ B y# t t f$ r#}| j D ] }||_ Y d}~ yd}~wt $ r t j « d |_ Y w xY w)r¨ Nr rx ) rX r r rä r[ r\ r. r9 r6 ÚsysÚexc_info)r rX r rá s rN ÚreadzNodeCommands.read s¤ à__
|
Ø ò 1Að& xxÑ ð1Ø 2t× 2Ñ 2°:¸q¿v¹vÀa¹yÑ VÈAÏIÉIÑ VAHñ+ 1øô, (¬ Ð6ò Ø !]]ò %Ø#$ð%åûÜ!ò 1Ü "||~¨aÑ 0AHð1ús ª0A Á B5Á,B
|
Â
|
(B5Â4B5N)r r r r+ rV r r r# rL rP rN r r y s Ù òò ò ó, 1rP r c ó< e Zd Zeed « « Zed « Zed « Zed « Zedde de
|
e fd« Z e dd« Z ed « Zed
|
« Zed « Zed « Zed « Zed « Zed « Zed « Zed « Zed « Zed « Zy)ÚExecutionStrategyc ó y rW rL rX s rN r¹ z ExecutionStrategy.command_queue¿ s ð rP c ó y)zp
|
Execution flow for current execution strategy.
|
|
See: ClusterPipeline.execute_command()
|
NrL rÓ s rN rÔ z!ExecutionStrategy.execute_commandÄ ó ð rP c ó y)z
|
Annotate exception according to current execution strategy.
|
|
See: ClusterPipeline.annotate_exception()
|
NrL rÅ s rN rÄ z$ExecutionStrategy.annotate_exceptionÍ r( rP c ó y)z
|
Pipeline execution flow for current execution strategy.
|
|
See: ClusterPipeline.pipeline_execute_command()
|
NrL rÀ s rN rÁ z*ExecutionStrategy.pipeline_execute_commandÖ r( rP rÇ rI c ó y)z^
|
Executes current execution strategy.
|
|
See: ClusterPipeline.execute()
|
NrL rÉ s rN rù zExecutionStrategy.executeß r( rP c ó y)z
|
Sends commands according to current execution strategy.
|
|
See: ClusterPipeline.send_cluster_commands()
|
NrL rÐ s rN rÏ z'ExecutionStrategy.send_cluster_commandsè s ð rP c ó y)zZ
|
Resets current execution strategy.
|
|
See: ClusterPipeline.reset()
|
NrL rX s rN r$ zExecutionStrategy.resetó r( rP c ó y rW rL rÔ s rN rÓ zExecutionStrategy.existsü ó à rP c ó y rW rL rX s rN rÖ zExecutionStrategy.eval
|
r/ rP c ó y)zU
|
Starts transactional context.
|
|
See: ClusterPipeline.multi()
|
NrL rX s rN rØ zExecutionStrategy.multi
|
r( rP c ó y rW rL rX s rN rÚ z ExecutionStrategy.load_scripts
|
r/ rP c ó y rW rL rß s rN rø zExecutionStrategy.watch
|
r/ rP c ó y)za
|
Unwatches all previously specified keys
|
|
See: ClusterPipeline.unwatch()
|
NrL rX s rN râ zExecutionStrategy.unwatch
|
r( rP c ó y rW rL rÓ s rN rä z*ExecutionStrategy.script_load_for_pipeline
|
r/ rP c ó y)z^
|
"Delete a key specified by ``names``"
|
|
See: ClusterPipeline.delete()
|
NrL rß s rN ræ zExecutionStrategy.delete"
|
r( rP c ó y)z^
|
"Unlink a key specified by ``names``"
|
|
See: ClusterPipeline.unlink()
|
NrL rß s rN ré zExecutionStrategy.unlink+
|
r( rP c ó y rW rL rX s rN rÜ zExecutionStrategy.discard4
|
r/ rP Nrê rë )r r r Úpropertyr r¹ rÔ rÄ rÁ r r r rù rÏ r$ rÓ rÖ rØ rÚ rø râ rä ræ ré rÜ rL rP rN r% r% ¾ sq Ø Øñ ó ó ð ð ñ ó ð ð ñ ó ð ð ñ ó ð ð ñ dð °d¸3±iò ó ð ð à=Aò ó ð ð ñ ó ð ð ñ ó ð ð ñ ó ð ð ñ ó ð ð ñ ó ð ð ñ ó ð ð ñ ó ð ð ñ ó ð ð ñ ó ð ð ñ ó ð ð ñ ó ñ rP r% c óÒ e Zd ZdefdZed « Zej dee fd« Ze
|
d « Z d Z e
|
dde d ee fd
|
« Ze
|
dd « Ze
|
d « Zd Zd Zd Zd Zd Zy)ÚAbstractStrategyrû c óV g | _ || _ | j j | _ y rW )Ú_command_queueÚ_piper
|
Ú_nodes_manager)r rû s rN rV zAbstractStrategy.__init__:
|
s% ð 68ÔØ
|
Ø "jj× 6Ñ 6ÕrP c ó | j S rW ©r= rX s rN r¹ z AbstractStrategy.command_queueB
|
s à×"Ñ"Ð"rP Úqueuec ó || _ y rW rA )r rB s rN r¹ z AbstractStrategy.command_queueF
|
s
|
à #ÕrP c ó y rW rL rÓ s rN rÔ z AbstractStrategy.execute_commandJ
|
r/ rP c ó | j j t ||t | j « « « | j S rW )r= r r r r> rÀ s rN rÁ z)AbstractStrategy.pipeline_execute_commandN
|
s9 Ø ×Ñ×"Ñ"Ü D '¬3¨t×/BÑ/BÓ+CÓ Dô
|
ð zzÐrP rÇ rI c ó y rW rL rÉ s rN rù zAbstractStrategy.executeT
|
r/ rP c ó y rW rL rÐ s rN rÏ z&AbstractStrategy.send_cluster_commandsX
|
s ð rP c ó y rW rL rX s rN r$ zAbstractStrategy.reset^
|
r/ rP c ó( | j dg|¢ S )NÚEXISTS©rÔ rÔ s rN rÓ zAbstractStrategy.existsb
|
s Ø#t×#Ñ# HÐ4¨tÒ4Ð4rP c ó t d« )r¨ z method eval() is not implementedrñ rX s rN rÖ zAbstractStrategy.evale
|
s ä#Ð$FÓGÐGrP c ó t d« )r¨ z(method load_scripts() is not implementedrñ rX s rN rÚ z AbstractStrategy.load_scriptsi
|
s ä#Ð$NÓOÐOrP c ó t d« )r¨ z4method script_load_for_pipeline() is not implementedrñ rÓ s rN rä z)AbstractStrategy.script_load_for_pipelinem
|
s ä#Ø Bó
|
ð
|
rP c ó´ dj t t |« « }d| dt |« d|j d }|f|j dd z |_ y)rà r¨ z
|
Command # z (z ) of pipeline caused error: r rx N)rZ ÚmaprD rF r[ )r r: rÆ r_ ÚcmdÚmsgs rN rÄ z#AbstractStrategy.annotate_exceptions
|
se ð hhs8 WÓ-Ó.à ¤=°Ó#5Ð"6ð 7 Ø &^^¨AÑ .Ð /ð 1ð ð )§.¡.°°Ð"4Ñ4 rP Nrê rë )r r r r rV r9 r¹ Úsetterr r r rÔ rÁ r r rù rÏ r$ rÓ rÖ rÚ rä rÄ rL rP rN r; r; 9
|
sÎ ð7à ó7ð ñ#ó ð#ð ×Ñð$ 4¨Ñ#8ò $ó ð$ð ñ ó ð òð ñ dð °d¸3±iò ó ð ð à=Aò ó ð ð
|
ñ ó ð ò5òHòPò
|
ó 5rP r; c ó¤ e Zd Zdef fd Zd Zd Zddedee fdZ
|
d Z dd Z dd
|
Z d Zd Zded fdZd Zd Zd Zd Zd Zd Z xZS )r® rû c óF t | |« |j | _ y rW )ru rV rJ ©r rû rI s rN rV zPipelineStrategy.__init__
|
s ø Ü ÑÔ Ø !× /Ñ /ÕrP c ó& | j |i |¤S rW )rÁ rÓ s rN rÔ z PipelineStrategy.execute_command
|
s Ø,t×,Ñ,¨dÐ=°fÑ=Ð=rP c ó¢ |D ]J }|j }t |t « s | j ||j dz |j
|
« | y©z8
|
Raise the first exception on the stack
|
rx N)r r rc rÄ r r[ )r rÑ r rf s rN Ú_raise_first_errorz#PipelineStrategy._raise_first_error
|
sI ð ò AØAÜ!YÕ'Ø×'Ñ'¨¨1¯:©:¸©>¸1¿6¹6ÔBØñ rP rÇ rI c ó | j }|sg S | j ||« | j « S # | j « w xY wrW )r= rÏ r$ ©r rÇ rÑ s rN rù zPipelineStrategy.execute
|
s= Ø×#Ñ#ÙØIð Ø×-Ñ-¨e°^ÓDà JJLøDJJLús 4 ´Ac ó g | _ yrË rA rX s rN r$ zPipelineStrategy.reset
|
s ð !ÕrP c óÚ |sg S | j j j « } | j |||¬« S # t j
|
$ r}|dkD r|dz }n|Y d}~nd}~ww xY wC)a
|
Wrapper for RedisCluster.ERRORS_ALLOW_RETRY errors handling.
|
|
If one of the retryable exceptions has been thrown we assume that:
|
- connection_pool was disconnected
|
- connection_pool was reset
|
- refresh_table_asap set to True
|
|
It will try the number of times specified by
|
the retries in config option "self.retry"
|
which defaults to 3 unless manually configured.
|
|
If it reaches the number of times, the command will
|
raises ClusterDownException.
|
rÍ r rx N)r> r¨ rØ Ú_send_cluster_commandsr& r$ )r rÑ rÇ rÎ rÞ rá s rN rÏ z&PipelineStrategy.send_cluster_commands¡
|
s ñ$ ØIØ ×)Ñ)×5Ñ5Ó7Øð Ø×2Ñ2ØØ#1Ø'9ð 3ó ð øô
|
×2Ñ2ò Ø! AÒ%ð # aÑ'NØàGô ûð úð s «? ¿A)Á A$Á$A)c óv t |d ¬« }d}i }|D ]5 } |j j dd« }|r#| j |« s| j |« } n7 | j
|
|j d|i} | st d|j d « t | « d
|
kD rt d |j « | d }
|
|
|
| j j « k( rd}|
|
j } | |vrK| j j |
|
« } t | « } t/ | j0 | j" | « || < || j3 |« 8 |j! « }|D ] }|j5 « |D ] }|j7 « |j! « D ]' }|j" j% |j& « ) t d |D « d ¬« }|r®|r¬| j xj8 d
|
z c_ | j j; « r6| j( j+ « |r| j j- « |D ]8 } | j j< |j i |j ¤|_ : g }t |d ¬« D ]¤ }|j d | j jB v rb|j j dd« | j jB |j d |j> fi |j ¤|_ |j3 |j> « ¦ |r| jE |« |S # t t f$ rr |j! « D ]' }|j" j% |j& « ) | j( j+ « |r| j j- « w xY w# |j! « D ]' }|j" j% |j& « ) w xY w# t@ $ r}||_ Y d}~àd}~ww xY w)zò
|
Send a bunch of cluster commands to the redis cluster.
|
|
`allow_redirections` If the pipeline should follow
|
`ASK` & `MOVED` responses automatically. If set
|
to false it will raise RedisClusterException.
|
c ó | j S rW ©r ©r s rN rÿ z9PipelineStrategy._send_cluster_commands.<locals>.<lambda>Ô
|
s
|
¨a¯j©j rP )r FTrÇ NÚ node_flagrÖ r× rx z Too many targets for command r c 3 óh K | ]* }t |j t j « r| , y wrW )r r r r$ )Ú.0r s rN ú <genexpr>z:PipelineStrategy._send_cluster_commands.<locals>.<genexpr>; s, è ø ò àÜ ahh¬×(JÑ(JÔKô ñ ùs 02c ó | j S rW rb rc s rN rÿ z9PipelineStrategy._send_cluster_commands.<locals>.<lambda>@ s
|
!** rP c ó | j S rW rb rc s rN rÿ z9PipelineStrategy._send_cluster_commands.<locals>.<lambda>e s
|
¨Q¯Z©Z rP rÀ )#Úsortedr\ r rÈ rÏ r® r[ r5 r r> r r rt rZ r. r9 ri rY rå rX r? ræ r r rä r r r# rL r° r r r6 rO rZ )r rÑ rÇ rÎ ÚattemptrÜ r r rÝ rÇ r rc rQ rX rF Ú node_commandsrá rd s rN r_ z'PipelineStrategy._send_cluster_commandsÆ
|
sô ô Ñ$8Ô9Ø àð
|
ó 1 AØð
|
"#§¡§ ¡ ¨~¸tÓ!DÙ!¨$×*=Ñ*=¸nÔ*MØ#'×#;Ñ#;¸NÓ#KLà#8 4×#8Ñ#8Øð$Ø+9ñ$Lñ (Ü 3Ø ?ÀÇÁ¸xÀ{Ð Só ð ô |Ó$ qÒ(Ü/Ø7¸¿¹°xÐ@óð ð $ AØ4::×6Ñ6Ó8Ò8Ø&*Oð
|
!II Ø EÑ)Ø!%§¡×!@Ñ!@ÀÓ!FJð
|
Ü%3°JÓ%?
|
ô (4Ø"×1Ñ1Ø"×2Ñ2Ø"ó(E)Ñ$ð
|
iÑ ×'Ñ'¨Ô*Ùðc1 ðv 8Ø !LLNMØ"ò Ø ð ð #ò Øñ ð* \\^ò 8Ø×!Ñ!×)Ñ)¨!¯,©,Õ7ñ 8ô ñ à ô ñ
|
%ô
|
ñ Ñ)ð& JJ× +Ò +¨qÑ 0Õ +Øzz×/Ñ/Ô1Ø×#Ñ#×.Ñ.Ô0Ù"ØJJ×3Ñ3Ô5Ø ò !ð!ð Atzz× @Ñ @À!Ç&Á&Ð VÈAÏIÉIÑ VAHð !ð ÜÑ#7Ô8ò &AØvvayDJJ× AÑ AÑAà f dÔ+ØK4::×@Ñ@ÀÇÁÈÁÑKØHHñ Ø !§ ¡ ñ ð OOAHHÕ %ð &ñ Ø × #Ñ # EÔ *àøôg ,¬\Ð:ò Ø!&§ ¡ £ ò DAØ × -Ñ -× 5Ñ 5°a·l±lÕ CðDð ×+Ñ+×6Ñ6Ô8Ù*Ø JJ× ;Ñ ;Ô =Ø ð ûðf \\^ò 8Ø×!Ñ!×)Ñ)¨!¯,©,Õ7ñ 8ûô\ "ò !Ø AHHûð!ús1 Ä MÅ>O É5P ÍBOÏ <PÐ P8Ð&P3Ð3P8c óV t |t « xr || j j v S rW )r r~ r> rK rÆ s rN rÈ z PipelineStrategy._is_nodes_flags s# Ü,¬Ó,ÒV° ÀÇÁ×AVÑAVÐ1VÐVrP c óÆ t |t « r|}|S t |t « r|g}|S t |t « r|j « }|S t dt |« « rÊ rË rÎ s rN rÏ z$PipelineStrategy._parse_target_nodesv rÐ rP r c ó |d j « }t |« dk\ rL|d d|d j « | j j v r|d d|d j « }|j dd « }||}n%| j j j |« }|| j j k( r| j j « gS || j j k( r| j j « S || j j k( r| j j « S || j j k( r| j j « S || j j k( r| j j gS || j j" d v r| j j gS | j j$ | }| j j' || j j( xr |t* v |t* v r| j j, nd « }|gS r§ )r© r r> rJ r r} r r r r r r r rh r r? r r! rª r« r+ r r4 r¬ s rN r® z!PipelineStrategy._determine_nodes sù ð q'--/ä INØ7)1T !WIÐ&×,Ñ,Ó.°$·*±*×2JÑ2JÑJà a 4¨¡7 )Ð,×2Ñ2Ó4GàZZ ¨dÓ3
|
Ø Ð !à%Lð ::×3Ñ3×7Ñ7¸Ó@LØ 4::×,Ñ,Ò ,àJJ×.Ñ.Ó0Ð1Ð 1Ø TZZ× 1Ñ 1Ò 1à::×+Ñ+Ó-Ð -Ø TZZ× 0Ñ 0Ò 0à::×*Ñ*Ó,Ð ,Ø TZZ× 1Ñ 1Ò 1à::×'Ñ'Ó)Ð )Ø TZZ× 4Ñ 4Ò 4à×'Ñ'×4Ñ4Ð5Ð 5Ø
|
|
×2Ñ2°1Ñ5Ñ 5Ø×'Ñ'×4Ñ4Ð5Ð 5ð -4::×,Ñ,¨dÐ3DØ×&Ñ&×9Ñ9ØØ
|
|
×-Ñ-ÒJ°'¼]Ð2JàmÑ+ð
|
|
×2Ò2àó Dð 6MrP c ó t d« )Nz@method multi() is not supported outside of transactional contextrñ rX s rN rØ zPipelineStrategy.multi¸ ó Ü#Ø Nó
|
ð
|
rP c ó t d« )NzBmethod discard() is not supported outside of transactional contextrñ rX s rN rÜ zPipelineStrategy.discard½ ó Ü#Ø Pó
|
ð
|
rP c ó t d« )Nz@method watch() is not supported outside of transactional contextrñ rß s rN rø zPipelineStrategy.watch rq rP c ó t d« )NzBmethod unwatch() is not supported outside of transactional contextrñ rß s rN râ zPipelineStrategy.unwatchÇ rs rP c ó^ t |« dk7 r t d« | j d|d « S )Nrx z=deleting multiple keys is not implemented in pipeline commandÚDELr ©r r5 rÔ rß s rN ræ zPipelineStrategy.deleteÌ s6 Ü u:?Ü'ØOóð ð ×#Ñ# E¨5°©8Ó4Ð4rP c ó^ t |« dk7 r t d« | j d|d « S )Nrx z>unlinking multiple keys is not implemented in pipeline commandÚUNLINKr rx rß s rN ré zPipelineStrategy.unlinkÔ s6 Ü u:?Ü'ØPóð ð ×#Ñ# H¨e°A©hÓ7Ð7rP rê rë )r r r r rV rÔ rZ r r r rù r$ rÏ r_ rÈ rÏ r® rØ rÜ rø râ ræ ré r£ r¤ s @rN r® r®
|
s ø ð0_õ 0ò>òñ dð °d¸3±ió ò!ð >Bó# ðL >BókòZWòð(,°4¸ Ñ3Fó ,ò\
|
ò
|
|
ò
|
|
ò
|
|
ò
|
5ö8rP r® c ó e Zd ZdhZddhZh d£ZeefZe e
|
e e fZ def fd Zdeeef fdZd Zd Zd
|
Zd Zd efd Zd Zd Zd dede e fdZ de d defdZ de d defdZ d Z! d dZ"d Z#d Z$d Z%d Z&d Z'd Z( xZ)S ) r¯ r¦ r§ > r¨ r© r¦ rû c ó. t | |« d| _ d| _ t « | _ d | _ d| _ t | j j « | _ | j j t j | j z « y r )ru rV Ú_explicit_transactionÚ _watchingr Ú_pipeline_slotsÚ_transaction_connectionÚ
|
_executingr r> r¨ Ú_retryÚupdate_supported_errorsr& r$ ÚSLOT_REDIRECT_ERRORSrV s rN rV z TransactionStrategy.__init__é st ø Ü ÑÔ Ø%*Ô"Ø Ü),«Ô Ø=AÔ$Ø Ü4::×+Ñ+Ó, Ø ×+Ñ+Ü × +Ñ +¨d×.GÑ.GÑ Gõ
|
rP rI c ó" | j s t d« | j j t | j « d d« }| j
|
j |« }| j rv|j j | j « sQ| j j | j « }|j j | j « d| _ | j st |« | _ || j fS )ao
|
Find a connection for a pipeline transaction.
|
|
For running an atomic transaction, watch keys ensure that contents have not been
|
altered as long as the watch commands for those keys were sent over the same
|
connection. So once we start watching a key, we fetch a connection to the
|
node that owns that slot and reuse it.
|
z:At least a command with a key is needed to identify a noder FN) r r5 r? r« rý r> rt r rY Úowns_connectionrm rå rZ )r r rQ Ú previous_nodes rN Ú*_get_client_and_connection_for_transactionz>TransactionStrategy._get_client_and_connection_for_transactionõ sò ð ×#Ò#Ü'ØLóð ð !× /Ñ /× BÑ BÜ ×%Ñ%Ó & qÑ )¨5ó
|
ð !JJ× ;Ñ ;¸DÓ A
|
Ø × 'Ò 'Ø ×-Ñ-×=Ñ=Ø×,Ñ,ôð !%× 3Ñ 3× IÑ IØ×0Ñ0ó! ð ×-Ñ-×5Ñ5°d×6RÑ6RÔSØ/3Ô,à×+Ò+Ü+9¸*Ó+EDÔ (à4×7Ñ7Ð7Ð7rP c ó2 d }|d t j vr | j j | }| j s|d | j
|
v r| j s|d dk( r| j « |A| j r|| j vr t d« | j j |« n#|d | j vrt d|d d« | j |i |¤S || j j |« | j |i |¤S )Nr r§ z0Cannot watch or send commands on different slotsz)Cannot identify slot number for command: z(,it cannot be triggered in a transaction)r rì r> rª r~ rí r} Ú_validate_watchr r/ Úaddr5 Ú_immediate_execute_commandrÁ )r r[ rÀ Ú slot_numbers rN rÔ z#TransactionStrategy.execute_command s- Ø%) Ø 7/×;Ñ;Ñ ;Ø3$**×3Ñ3°TÐ:Kð NNd 1g¨×)HÑ)HÑ HØ×,Ò,ØAw'Ò!Ø×$Ñ$Ô&àÐ&Ø×'Ò'¨K¸t×?SÑ?SÑ,SÜ3ØJóð ð ×$Ñ$×(Ñ(¨Õ5Øa × 6Ñ 6Ñ6Ü+Ø?ÀÀQÁ¸yð I>ð >óð ð
|
34×2Ñ2°DÐC¸FÑCÐ CàÐ&Ø×$Ñ$×(Ñ(¨Ô5à04×0Ñ0°$ÐA¸&ÑAÐ ArP c ó@ | j r t d« d| _ y )Nú"Cannot issue a WATCH after a MULTIT)r} r6 r~ rX s rN r z#TransactionStrategy._validate_watch5 s Ø × %Ò %Ü Ð AÓBÐ Bà rP c ó^ j j fd j « S )Nc ó( j i ¤S rW )Ú _get_connection_and_send_command)r[ r\ r s rN rÿ z@TransactionStrategy._immediate_execute_command.<locals>.<lambda>= s ø Ð9D×9Ñ9¸4ÐKÀ7ÑK rP ©r Úcall_with_retryÚ_reinitialize_on_errorrÀ s ```rN r z.TransactionStrategy._immediate_execute_command; s& ú Ø{{×*Ñ*Ý KØ × 'Ñ 'ó
|
ð
|
rP c ó^ | j « \ }} | j |||d g|¢i |¤S )Nr )r Ú _send_command_parse_response)r r[ r\ rQ rX s rN r z4TransactionStrategy._get_connection_and_send_commandA sE Ø!%×!PÑ!PÓ!RÑ
|
JØ0t×0Ñ0Ø
|
D¨¡Gð
|
Ø.2ò
|
Ø6=ñ
|
ð
|
rP rQ c óv |j | |j ||fi |¤}|| j v rd| _ |S )z7
|
Send a command and parse the response
|
F)rp rä rî r~ )r ÚconnrQ Ú command_namer[ r\ Úoutputs rN r z0TransactionStrategy._send_command_parse_responseG sG ð ×Ñ4Ñ Ø*×*Ñ*¨4° ÑIÀÑIà 4×0Ñ0Ñ 0Ø "DNØ rP c ó" | j r.t |« | j v r| j r t d« t |« | j v st |« | j
|
v r | j rd | _ | j xj dz c_ | j j « r)| j j « d| _ d| _ y t |t « r| j j |« d| _ y )Nz-Slot rebalancing occurred while watching keysrx r F)r~ rÍ r r r; ÚCONNECTION_ERRORSr r> rL r° r? ræ r r* rç )r Úerrors rN r z*TransactionStrategy._reinitialize_on_errorU sÓ Ø >>ÜE{d× 7Ñ 7Ñ7¸D¿OºOÜ Ð!PÓQÐQô K4×4Ñ4Ñ 4ÜE{d× 4Ñ 4Ñ4à×+Ò+Ø/3Ô,à JJ× +Ò +¨qÑ 0Õ +Øzz×/Ñ/Ô1Ø×#Ñ#×.Ñ.Ô0Ø,-Ô)ð
|
ô e¤XÔ.Ø×'Ñ'×>Ñ>¸uÔEà rP c ó¤ t ||« D ]A \ }}t |t « s| j ||j dz |j
|
« | yrY )r r rc rÄ r r[ )r Ú responsesrÑ rf rQ s rN rZ z&TransactionStrategy._raise_first_errork sL ô ) UÓ+ò FAsÜ!YÕ'Ø×'Ñ'¨¨3¯<©<¸!Ñ+;¸S¿X¹XÔFØñ rP rÇ c óv | j }|s| j r | j sg S | j ||« S rW )r= r~ r Ú!_execute_transaction_with_retriesr\ s rN rù zTransactionStrategy.executet s6 Ø×#Ñ#Ùdnn°D×4HÒ4HØIà×5Ñ5°e¸^ÓLÐLrP rÑ r c ó^ j j fd j « S )Nc ó( j « S rW )Ú_execute_transaction)rÇ r rÑ s rN rÿ zGTransactionStrategy._execute_transaction_with_retries.<locals>.<lambda> s ø D×-Ñ-¨e°^ÓD rP r )r rÑ rÇ s ```rN r¢ z5TransactionStrategy._execute_transaction_with_retries{ s( ú ð {{×*Ñ*Ý DØ × 'Ñ 'ó
|
ð
|
rP c óÆ t | j « dkD r t d« d| _ | j « \ }}t t d« g|t d« g« }|D cg c]! }t |j vs|j # }}|j |« }|j |« g } |j |d« t# | j$ « D ]O \ } } t | j v r%|j | | j t f« = |j |d« } Q d } |j |d « }d
|
| _ d
|
| _ | t- d « |D ] \ } } |j/ | | « t |« t | j$ « k7 rIt1 d j3 | j$ D cg c] }|j d c}t |« « « |st |« dkD r | j5 || j$ « g }t7 || j$ « D ]w \ }}t9 |t: « sQ|j d }|| j< j> v r* | j< j> | |fi |j ¤}|j |« y |S c c}w # t $ r/} | j | dd« |j | « Y d } ~ d } ~ w| j $ r}
|
| j |
|
dd« d }
|
~
|
ww xY w# | j& $ r<}| j || dz | j « |j |« Y d }~td }~w| j $ r&}
|
| j |
|
| dz | j « d }
|
~
|
wt $ r<} | j | | dz | j « |j | « Y d } ~ êd } ~ ww xY w# t( $ r |r|d w xY wc c}w ) Nrx zDAll keys involved in a cluster transaction must map to the same slotT)ÚMULTI)r¨ r§ r rà r¨ FzWatched variable changed.zeUnexpected response length for cluster pipeline EXEC. Command stack was {} but response had length {}) r r r/ r r r r r r\ r[ r r rä r7 rÄ r r Ú enumerater= r r1 r~ r; Úinsertr2 ÚformatrZ r r rc r> rO )r rÑ rÇ rQ rX r r Úpacked_commandsÚerrorsrá Ú cluster_errorr r_ rà Ú
|
slot_errorrd Údatarf rQ r s rN r¥ z(TransactionStrategy._execute_transaction s³ ô t×#Ñ#Ó $ qÒ (Ü+ØVóð ð à!%×!PÑ!PÓ!RÑ
|
JäÜ ZÓ (Ð )Ø Ü YÓ 'Ð (ó
|
ð
|
%*ÖMq¬^À1Ç9Á9Ò-LAFFÐMÐMØ$×2Ñ2°8Ó<Ø×&Ñ& Ô7Øð Ø × %Ñ % j°'Ô :ô $ D×$7Ñ$7Ó8ò %JAwÜ § ¡ Ñ0Ø q '§/¡/´.Ñ"AÐ BÕCð
|
%Ø"×1Ñ1°*¸cÓBAð %ð ð Ø!×0Ñ0°¸VÓDHð ð à Ð Ü Ð 8Ó9Ð 9ð ò "DAqØ OOAqÕ !ð "ô x=C × 3Ñ 3Ó 4Ò 4Ü&ðCßCIÁ6Ø(,×(;Ñ(;Ö< 1QVVAYÒ<¼cÀ(»móDóð ñ S [¨1_Ø × #Ñ #ØØ×#Ñ#ô ð Ü( D×$7Ñ$7Ó8ò FAsÜ a¤Ô+Ø "xx¨{ Ø 4§:¡:×#HÑ#HÑHØK
|
|
×=Ñ=¸lÑKØñØ [[ñAð KKNð ð ùòc Nøô ò Ø × #Ñ # A q¨'Ô 2Ø MM!× Ò ûØ×%Ñ%ò Ø × #Ñ # M°1°gÔ >Ø ûð ûð ×0Ñ0ò .Ø×+Ñ+¨J¸¸A¹¸w¿|¹|ÔLØMM *×-Ò-ûØ×-Ñ-ò Ø×+Ñ+¨M¸1¸q¹5À'Ç,Á,ÔOØûÜ$ò %Ø×+Ñ+¨A¨q°1©u°g·l±lÔCØMM !×$Ò$ûð%ûô ò ÙØ QiØ ð üò* =sr Á#J Á;J Â0J$ ÄLÄ,O Æ4O Ê$ LÊ-$KËLË)K=Ë=LÌOÌ1M Í OÍ !M>Í> OÎ
|
1OÏOÏ Oc ó" g | _ | j r | j r5| j j d« | j j « | j
|
j | j « }|j j j | j « d | _ d| _ d| _ t « | _ d| _ y # | j $ r) | j r| j j « Y \w xY w)Nr¦ F)r= r r~ rp rq r? rm ri rY rå r rj r} r r r rl s rN r$ zTransactionStrategy.resetç sî Ø Ôð × 'Ò 'ð >Ø>>ð ×0Ñ0×=Ñ=¸iÔHØ×0Ñ0×>Ñ>Ô@ð ×*Ñ*×@Ñ@Ø×0Ñ0óð ×%Ñ%×5Ñ5×=Ñ=Ø×0Ñ0ôð 04Ô,ð Ø%*Ô"Ü "uÔ Ø øð ×)Ñ)ò >à×/Ò/Ø×0Ñ0×;Ñ;Ô=ùð >ús B C Ã5DÄ Dc ó t d« )NzBsend_cluster_commands cannot be executed in transactional context.)ÚNotImplementedErrorrÐ s rN rÏ z)TransactionStrategy.send_cluster_commands s ô "Ø Pó
|
ð
|
rP c ón | j r t d« | j r t d« d| _ y )Nz"Cannot issue nested calls to MULTIz:Commands without an initial WATCH have already been issuedT)r} r6 r= rX s rN rØ zTransactionStrategy.multi s: Ø × %Ò %Ü Ð AÓBÐ BØ × Ò Ü ØLóð ð &*Õ"rP c óV | j r t d« | j dg|¢ S )Nr r§ )r} r6 rÔ rß s rN rø zTransactionStrategy.watch s/ Ø × %Ò %Ü Ð AÓBÐ Bà#t×#Ñ# GÐ4¨eÒ4Ð4rP c ó> | j r| j d« S y)Nr¦ T)r~ rÔ rX s rN râ zTransactionStrategy.unwatch s Ø >>Ø×'Ñ'¨ Ó2Ð 2àrP c ó$ | j « y rW r¶ rX s rN rÜ zTransactionStrategy.discard# ra rP c ó( | j dg|¢ S )Nrw rK rß s rN ræ zTransactionStrategy.delete& s Ø#t×#Ñ# EÐ2¨EÒ2Ð2rP c ó( | j dg|¢ S )Nrz rK rß s rN ré zTransactionStrategy.unlink) s Ø#t×#Ñ# HÐ5¨uÒ5Ð5rP rê rë )*r r r rì rí rî r* r4 r r. rk r, r8 r r rV r r r! r rÔ r r r r r rZ r r r rù r¢ r¥ r$ rÏ rØ rø râ rÜ ræ ré r£ r¤ s @rN r¯ r¯ Ý s ø Ø" ÐØ")¨9Ð!5Ð Ú5ÐØ $ jÐ1ÐàØØØð Ðð
|
|
_õ
|
|
ð 8¸EÀ%ÈÐBSÑ<Tó 8òB Bò> ò
|
ò
|
ð Ø %ó ò ò,ñM dð M°d¸3±ió Mð
|
ØÐ+Ñ,ð
|
Ø>Bó
|
ðbØÐ+Ñ,ðbØ>BóbòH ðB >Bó
|
ò*ò5ò ò ò3ö6rP r¯ )rÊ r r! rR rè Úabcr r Ú collectionsr r Úenumr Ú itertoolsr Útypingr r
|
r r r r r r Úredis._parsersr r Úredis._parsers.helpersr Ú redis.backoffr r Ú redis.cacher r r r Ú redis.clientr r r r Úredis.commandsr r Úredis.commands.helpersr Úredis.connectionr! r" r# Ú redis.crcr$ r% Ú redis.eventr& r' r( r) Úredis.exceptionsr* r+ r, r- r. r/ r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r: r; Ú
|
redis.lockr= Úredis.maint_notificationsr> Ú redis.retryr? Ú redis.utilsr@ rA rB rC rD rE rF r~ r¼ rO rZ rg rq r r r rz r} r r¾ r¿ rÄ rÆ r& r r5 r rN r r ró ÚPIPELINE_BLOCKED_COMMANDSr_ ÚreplaceÚlowerrñ r r r% r; r® r¯ rL rP rN ú<module>rÐ s
ðÛ Û Û
|
Û Û ß #Ý #Ý Ý Ý ß I× IÓ Iç 2Ý -ß Aß XÓ Xß KÓ Kß >Ý /÷ñ ÷
|
9÷ó ÷ ÷ ÷ ÷ ÷ õ( Ý >Ý ÷÷ ñ ð ð 5¨¨c¨¡?ð °só ñ Ø Ø 3Ø ôð
|
Puð P¸:ò Pó ð
|
Pòò
|
ðØ
|
ðØ ðà %S/4 S >Ð
|
)Ñ*óò(ò, ð Ø
|
Ø
|
ð)Ð ðT 1Ð ò
|
÷tNñ tNônN Ð'Ð)=ô N ÷b ñ ô@&Dô &÷ ' ñ ' ÷Ti ñ i ôX q+Fô q+ôh}0lô }0ð@ ð ¨°#°s°(Ñ);ó ð F Ð ðN )ò GGØooc 3Ó'×-Ñ-Ó/Gá OWÑ&<¸WÓ&EÕFðG÷ ñ ÷ B1ñ B1ôJx ô x ôvC5Ð(ô C5ôL[8Ð'ô [8ô|
|
M6Ð*õ M6rP
|
