tfc\dZddlmZddlmZmZmZddlmZddl m Z ddl m Z ddl mZmZdZGd d eZGd d eZGd deZGddZGddee ZgdZdS)ap Memcache client protocol. Memcached is a caching server, storing data in the form of pairs key/value, and memcache is the protocol to talk with it. To connect to a server, create a factory for L{MemCacheProtocol}:: from twisted.internet import reactor, protocol from twisted.protocols.memcache import MemCacheProtocol, DEFAULT_PORT d = protocol.ClientCreator(reactor, MemCacheProtocol ).connectTCP("localhost", DEFAULT_PORT) def doSomething(proto): # Here you call the memcache operations return proto.set("mykey", "a lot of data") d.addCallback(doSomething) reactor.run() All the operations of the memcache protocol are present, but L{MemCacheProtocol.set} and L{MemCacheProtocol.get} are the more important. See U{http://code.sixapart.com/svn/memcached/trunk/server/doc/protocol.txt} for more information about the protocol. )deque)Deferred TimeoutErrorfail) LineReceiver) TimeoutMixin)log) nativeString networkStringi+ceZdZdZdS) NoSuchCommandzA Exception raised when a non existent command is called. N__name__ __module__ __qualname____doc__Y/var/www/surfInsights/venv3-11/lib/python3.11/site-packages/twisted/protocols/memcache.pyr r (rr ceZdZdZdS) ClientErrorz1 Error caused by an invalid client call. Nrrrrrr.rrrceZdZdZdS) ServerErrorz* Problem happening on the server. Nrrrrrr4rrrc$eZdZdZdZdZdZdS)Commanda8 Wrap a client action into an object, that holds the values used in the protocol. @ivar _deferred: the L{Deferred} object that will be fired when the result arrives. @type _deferred: L{Deferred} @ivar command: name of the command sent to the server. @type command: L{bytes} c ||_t|_|D]\}}t |||dS)z Create a command. @param command: the name of the command. @type command: L{bytes} @param kwargs: this values will be stored as attributes of the object for future use N)commandr _deferreditemssetattr)selfrkwargskvs r__init__zCommand.__init__GsP !LLNN  DAq D!Q      rc:|j|dS)zB Shortcut method to fire the underlying deferred. N)rcallback)r"values rsuccesszCommand.successVs  &&&&&rc:|j|dS)z5 Make the underlying deferred fails. N)rerrback)r"errors rrz Command.fail\s  u%%%%%rN)rrrrr&r*rrrrrr:sK      ''' &&&&&rrc eZdZdZdZdZd-dZdZdZdZ d Z d Z d Z d Z d ZdZdZdZdZdZdZdZdZdZdZdZd.dZd.dZdZd/dZd/dZd/d Zd/d!Z d"Z!d#Z"d$Z#d0d%Z$d0d&Z%d'Z&d1d)Z'd*Z(d+Z)d,Z*d(S)2MemCacheProtocola1 MemCache protocol: connect to a memcached server to store/retrieve values. @ivar persistentTimeOut: the timeout period used to wait for a response. @type persistentTimeOut: L{int} @ivar _current: current list of requests waiting for an answer from the server. @type _current: L{deque} of L{Command} @ivar _lenExpected: amount of data expected in raw mode, when reading for a value. @type _lenExpected: L{int} @ivar _getBuffer: current buffer of data, used to store temporary data when reading in raw mode. @type _getBuffer: L{list} @ivar _bufferLength: the total amount of bytes in C{_getBuffer}. @type _bufferLength: L{int} @ivar _disconnected: indicate if the connectionLost has been called or not. @type _disconnected: L{bool} F<crt|_d|_d|_d|_|x|_|_dS)z Create the protocol. @param timeOut: the timeout to wait before detecting that the connection is dead and close it. It's expressed in seconds. @type timeOut: L{int} N)r_current _lenExpected _getBuffer _bufferLengthpersistentTimeOuttimeOut)r"r8s rr&zMemCacheProtocol.__init__s9  !077rc|jr7|j}|||j5dSdS)zW Cancel all the outstanding commands, making them fail with C{reason}. N)r3popleftr)r"reasoncmds r_cancelCommandsz MemCacheProtocol._cancelCommandssSm -''))C HHV   m     rc||td|jdS)z: Close the connection in case of timeout. zConnection timeoutN)r=r transportloseConnectionr"s rtimeoutConnectionz"MemCacheProtocol.timeoutConnections; \*>??@@@ %%'''''rchd|_||tj||dS)z9 Cause any outstanding commands to fail. TN) _disconnectedr=rconnectionLost)r"r;s rrEzMemCacheProtocol.connectionLosts9" V$$$#D&11111rcr|js||jtj||dS)zA Override sendLine to add a timeout to response. N)r3 setTimeoutr7rsendLine)r"lines rrHzMemCacheProtocol.sendLines<} 4 OOD2 3 3 3dD)))))rc||j||xjt |z c_|j|jdzkrd|j}|d|j}||jdzd}|}d|_d|_d|_|jd}|jr(|j |j \}}|||f|j |j <n||_ | |dSdS)z) Collect data for a get. rNr) resetTimeoutr5appendr6lenr4joinr3multiplevalues currentKeyr) setLineMode)r"databufremvalr<flagscass rrawDataReceivedz MemCacheProtocol.rawDataReceiveds  t$$$ c$ii'  !2Q!6 6 688DO,,D***+Ct(1,../CC $D "DO!%D -"C|  Z7 s.3S#-> 3>**   S ! ! ! ! ! 7 6rc^|jddS)z? Manage a success response to a set operation. TNr3r:r*rAs r cmd_STOREDzMemCacheProtocol.cmd_STORED, ''-----rc^|jddS)z Manage a specific 'not stored' response to a set operation: this is not an error, but some condition wasn't met. FNr\rAs rcmd_NOT_STOREDzMemCacheProtocol.cmd_NOT_STOREDs, ''.....rcv|j}|jdkrd|jr:d|jD}||dS||j|jfdS|jdkrL|jr||jdS||j|j |jfdS|jdkr||jdStd t|j)zB This the end token to a get or a stat operation. getc,i|]\}}||dddS)NrKr).0keyrWs r z,MemCacheProtocol.cmd_END..s(KKKHC#s33Q3xKKKrgetsstatsz%Unexpected END response to {} commandN) r3r:rrPrQr r*rXr)rY RuntimeErrorformatr )r"r<rQs rcmd_ENDzMemCacheProtocol.cmd_ENDs7m##%% ;& | 4KK 8H8H8J8JKKK F##### SY 233333 [G # #| = CJ''''' SY;<<<<< [H $ $ KK # # # # #7>> -- rc^|jddS)z= Manage error response for incr/decr/delete. FNr\rAs r cmd_NOT_FOUNDzMemCacheProtocol.cmd_NOT_FOUND, ''.....rc|jd}|jdkr|\}}}d}n|\}}}}t||_g|_d|_|jr9||jvrtd||_ t||g|j |<n5|j |krtdt||_ ||_|dS)z: Prepare the reading a value after a get. rrbrzUnexpected commands answer.N)r3rsplitintr4r5r6rPkeysrirRrQrerXrY setRawMode)r"rIr<rerXlengthrYs r cmd_VALUEzMemCacheProtocol.cmd_VALUEsmA ;& !% CCC&*jjll #CKK < #("""#@AAA CN"5zz3/CJsOOw#~~"#@AAAE CICG rcf|jd}|dd\}}||j|<dS)z- Reception of one stat line. r N)r3rprQ)r"rIr<rerWs rcmd_STATzMemCacheProtocol.cmd_STAT s6mA::dA&&S 3rc^|j|dS)z% Read version token. Nr\)r" versionDatas r cmd_VERSIONzMemCacheProtocol.cmd_VERSIONs, '' 44444rctjd|j}|t dS)z7 A non-existent command has been sent. zNon-existent command sent.N)r errr3r:rr )r"r<s r cmd_ERRORzMemCacheProtocol.cmd_ERRORsD ,---m##%% !!!!!rct|}tjd|z|j}|t |dS)z0 An invalid input as been sent. zInvalid input: N)reprr r~r3r:rrr"errTextr<s rcmd_CLIENT_ERRORz!MemCacheProtocol.cmd_CLIENT_ERRORsXw-- !G+,,,m##%% W%%&&&&&rct|}tjd|z|j}|t |dS)z4 An error has happened server-side. zServer error: N)rr r~r3r:rrrs rcmd_SERVER_ERRORz!MemCacheProtocol.cmd_SERVER_ERROR(sXw--  7*+++m##%% W%%&&&&&rc^|jddS)z> A delete command has completed successfully. TNr\rAs r cmd_DELETEDzMemCacheProtocol.cmd_DELETED1r^rc^|jddS)z6 The last command has been completed. TNr\rAs rcmd_OKzMemCacheProtocol.cmd_OK7r^rc^|jddS)z5 A C{checkAndSet} update has failed. FNr\rAs r cmd_EXISTSzMemCacheProtocol.cmd_EXISTS=rnrcd||ddd}t|dt|zd}|=|dddd}|r||dn|n|dd}t|dt|zd}| |n=|j}t|}|||js| ddSdS)z8 Receive line commands from the server. rwrxrcmd_N_) rLrpgetattrr replacer3r:rqr*rG)r"rItokenr<argsrWs r lineReceivedzMemCacheProtocol.lineReceivedCs8  4##A&dF\%%8%88$?? ?::dA&&qrr*D DG <<d++D$d);); ;TBBCm++--$ii C   } " OOD ! ! ! ! ! " "rrxc0|d||S)a Increment the value of C{key} by given value (default to 1). C{key} must be consistent with an int. Return the new value. @param key: the key to modify. @type key: L{bytes} @param val: the value to increment. @type val: L{int} @return: a deferred with will be called back with the new value associated with the key (after the increment). @rtype: L{Deferred} sincr _incrdecrr"rerWs r incrementzMemCacheProtocol.increment`s~~gsC000rc0|d||S)a Decrement the value of C{key} by given value (default to 1). C{key} must be consistent with an int. Return the new value, coerced to 0 if negative. @param key: the key to modify. @type key: L{bytes} @param val: the value to decrement. @type val: L{int} @return: a deferred with will be called back with the new value associated with the key (after the decrement). @rtype: L{Deferred} sdecrrrs r decrementzMemCacheProtocol.decrementqs ~~gsC000rc|jrttdSt|ts-tt dt |dSt||jkrtt dSd ||dt|fzg}| |t||}|j ||jS)z1 Internal wrapper for incr/decr. not connectedInvalid type for key: , expecting bytes Key too longrws%dre)rDrri isinstancebytesrtyperNMAX_KEY_LENGTHrOrqrHrr3rMr)r"r<rerWfullcmdcmdObjs rrzMemCacheProtocol._incrdecrs   7 _5566 6#u%% QT#YYQQQRR  s88d) ) ) N3344 4))S#uC{':;<< g#&&& V$$$rrc6|d||||dS)a Replace the given C{key}. It must already exist in the server. @param key: the key to replace. @type key: L{bytes} @param val: the new value associated with the key. @type val: L{bytes} @param flags: the flags to store with the key. @type flags: L{int} @param expireTime: if different from 0, the relative time in seconds when the key will be deleted from the store. @type expireTime: L{int} @return: a deferred that will fire with C{True} if the operation has succeeded, and C{False} with the key didn't previously exist. @rtype: L{Deferred} sreplacer_setr"rerWrX expireTimes rrzMemCacheProtocol.replaces *yyS#uj#FFFrc6|d||||dS)a Add the given C{key}. It must not exist in the server. @param key: the key to add. @type key: L{bytes} @param val: the value associated with the key. @type val: L{bytes} @param flags: the flags to store with the key. @type flags: L{int} @param expireTime: if different from 0, the relative time in seconds when the key will be deleted from the store. @type expireTime: L{int} @return: a deferred that will fire with C{True} if the operation has succeeded, and C{False} with the key already exists. @rtype: L{Deferred} saddrrrs raddzMemCacheProtocol.add *yyc5*cBBBrc6|d||||dS)a9 Set the given C{key}. @param key: the key to set. @type key: L{bytes} @param val: the value associated with the key. @type val: L{bytes} @param flags: the flags to store with the key. @type flags: L{int} @param expireTime: if different from 0, the relative time in seconds when the key will be deleted from the store. @type expireTime: L{int} @return: a deferred that will fire with C{True} if the operation has succeeded. @rtype: L{Deferred} ssetrrrs rsetzMemCacheProtocol.setrrc6|d|||||S)am Change the content of C{key} only if the C{cas} value matches the current one associated with the key. Use this to store a value which hasn't been modified since last time you fetched it. @param key: The key to set. @type key: L{bytes} @param val: The value associated with the key. @type val: L{bytes} @param cas: Unique 64-bit value returned by previous call of C{get}. @type cas: L{bytes} @param flags: The flags to store with the key. @type flags: L{int} @param expireTime: If different from 0, the relative time in seconds when the key will be deleted from the store. @type expireTime: L{int} @return: A deferred that will fire with C{True} if the operation has succeeded, C{False} otherwise. @rtype: L{Deferred} scasr)r"rerWrYrXrs r checkAndSetzMemCacheProtocol.checkAndSets 4yyc5*cBBBrc |jrttdSt|ts-tt dt |dSt||jkrtt dSt|ts-tt dt |dS|rd|z}t|}d ||td|||fzg|z}| || |t||||} |j | | jS) z6 Internal wrapper for setting values. rrrrzInvalid type for value: rwz%d %d %d)rerXrt)rDrrirrrrrNrrOr rHrr3rMr) r"r<rerWrXrrYrtrrs rrzMemCacheProtocol._sets   7 _5566 6#u%% QT#YYQQQRR  s88d) ) ) N3344 4#u%% StCyySSSTT   *CS IIc=uj&6Q)QRRS     g c#U6BBB V$$$rc6|d||dddS)a Append given data to the value of an existing key. @param key: The key to modify. @type key: L{bytes} @param val: The value to append to the current value associated with the key. @type val: L{bytes} @return: A deferred that will fire with C{True} if the operation has succeeded, C{False} otherwise. @rtype: L{Deferred} sappendrrrrs rrMzMemCacheProtocol.appends yyCaC888rc6|d||dddS)a Prepend given data to the value of an existing key. @param key: The key to modify. @type key: L{bytes} @param val: The value to prepend to the current value associated with the key. @type val: L{bytes} @return: A deferred that will fire with C{True} if the operation has succeeded, C{False} otherwise. @rtype: L{Deferred} sprependrrrrs rprependzMemCacheProtocol.prepend's yyS#q!S999rc2||g|dS)a Get the given C{key}. It doesn't support multiple keys. If C{withIdentifier} is set to C{True}, the command issued is a C{gets}, that will return the current identifier associated with the value. This identifier has to be used when issuing C{checkAndSet} update later, using the corresponding method. @param key: The key to retrieve. @type key: L{bytes} @param withIdentifier: If set to C{True}, retrieve the current identifier along with the value and the flags. @type withIdentifier: L{bool} @return: A deferred that will fire with the tuple (flags, value) if C{withIdentifier} is C{False}, or (flags, cas identifier, value) if C{True}. If the server indicates there is no value associated with C{key}, the returned value will be L{None} and the returned flags will be C{0}. @rtype: L{Deferred} F_get)r"rewithIdentifiers rgetzMemCacheProtocol.get9s,yy#666rc0|||dS)a Get the given list of C{keys}. If C{withIdentifier} is set to C{True}, the command issued is a C{gets}, that will return the identifiers associated with each values. This identifier has to be used when issuing C{checkAndSet} update later, using the corresponding method. @param keys: The keys to retrieve. @type keys: L{list} of L{bytes} @param withIdentifier: If set to C{True}, retrieve the identifiers along with the values and the flags. @type withIdentifier: L{bool} @return: A deferred that will fire with a dictionary with the elements of C{keys} as keys and the tuples (flags, value) as values if C{withIdentifier} is C{False}, or (flags, cas identifier, value) if C{True}. If the server indicates there is no value associated with C{key}, the returned values will be L{None} and the returned flags will be C{0}. @rtype: L{Deferred} @since: 9.0 Tr)r"rrrs r getMultiplezMemCacheProtocol.getMultipleQs0yy~t444rc t|}|jrttdS|D]|}t |t s/tt dt|dcSt||j krtt dcS}|rd}nd}d |g|z}| ||r d|D}t|||d }nt||d d d d d}|j ||jS)z> Helper method for C{get} and C{getMultiple}. rrrrrgrbrwci|]}|dS))rrNr)rdres rrfz)MemCacheProtocol._get..s:::cc>:::rT)rrrQrPrNrF)rer)rXrYrP)listrDrrirrrrrNrrOrHrr3rMr) r"rrrrPrer<rrQrs rrzMemCacheProtocol._getkswDzz   7 _5566 6 9 9Cc5))  Uc U U UVV3xx$---K7788888.  CCC))SEDL)) g  ::T:::FStFTJJJFFaA3F V$$$rNc|rd|z}nd}|jrttdS||t di}|j||jS)a Get some stats from the server. It will be available as a dict. @param arg: An optional additional string which will be sent along with the I{stats} command. The interpretation of this value by the server is left undefined by the memcache protocol specification. @type arg: L{None} or L{bytes} @return: a deferred that will fire with a L{dict} of the available statistics. @rtype: L{Deferred} sstats rhr)rQrDrrirHrr3rMr)r"argr<rs rstatszMemCacheProtocol.statss  c/CCC   7 _5566 6 c"--- V$$$rc|jrttdS|dt d}|j||jS)z Get the version of the server. @return: a deferred that will fire with the string value of the version. @rtype: L{Deferred} rsversionrr"rs rversionzMemCacheProtocol.versionsc   7 _5566 6 j!!!$$ V$$$rc`|jrttdSt|ts-tt dt |dS|d|ztd|}|j ||j S)a Delete an existing C{key}. @param key: the key to delete. @type key: L{bytes} @return: a deferred that will be called back with C{True} if the key was successfully deleted, or C{False} if not. @rtype: L{Deferred} rrrsdelete sdeleter) rDrrirrrrrHrr3rMr)r"rers rdeletezMemCacheProtocol.deletes   7 _5566 6#u%% QT#YYQQQRR  j3&''',,, V$$$rc|jrttdS|dt d}|j||jS)z Flush all cached values. @return: a deferred that will be called back with C{True} when the operation has succeeded. @rtype: L{Deferred} rs flush_allrrs rflushAllzMemCacheProtocol.flushAllsc   7 _5566 6 l###&& V$$$r)r1)rx)rr)F)N)+rrrrrrDr&r=rBrErHrZr]r`rkrmruryr|rrrrrrrrrrrrrrrrMrrrrrrrrrrrr/r/cs2NM 8 8 8 8(((222***""".... ///2/// 2555 """''''''... ... /// """:1111"1111$   $GGGG.CCCC.CCCC.CCCC8   >999$:::$7777055554   <    2       ,      rr/)r/ DEFAULT_PORTr rrN)r collectionsrtwisted.internet.deferrrrtwisted.protocols.basicrtwisted.protocols.policiesrtwisted.pythonr twisted.python.compatr r r Exceptionr rrrr/__all__rrrrs 0??????????000000333333======== I ) ) &&&&&&&&&&&&&&&&Rq  q  q  q  q  |\q  q  q  h   r