B 0`R]@sdZddlmZddlmZddlmZddlmZm Z m Z ddl m Z ddl mZmZdZGd d d eZGd d d eZGd ddeZGdddZGdddeeZddd d dgZdS)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) LineReceiver) TimeoutMixin)Deferredfail TimeoutError)log) nativeString networkStringi+c@seZdZdZdS) NoSuchCommandzA Exception raised when a non existent command is called. N)__name__ __module__ __qualname____doc__rrI/home/dcms/DCMS/lib/python3.7/site-packages/twisted/protocols/memcache.pyr )sr c@seZdZdZdS) ClientErrorz1 Error caused by an invalid client call. N)r r rrrrrrr/src@seZdZdZdS) ServerErrorz* Problem happening on the server. N)r r rrrrrrr5src@s(eZdZdZddZddZddZdS) 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} cKs4||_t|_x |D]\}}t|||qWdS)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)selfrkwargskvrrr__init__Hs zCommand.__init__cCs|j|dS)zB Shortcut method to fire the underlying deferred. N)rcallback)rvaluerrrsuccessWszCommand.successcCs|j|dS)z5 Make the underlying deferred fails. N)rZerrback)rerrorrrrr]sz Command.failN)r r rrrr rrrrrr;s rc@sTeZdZdZdZdZdRddZddZd d Zd d Z d dZ ddZ ddZ ddZ ddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,ZdSd.d/ZdTd0d1Zd2d3ZdUd5d6ZdVd7d8ZdWd9d:ZdXd;d<Z d=d>Z!d?d@Z"dAdBZ#dYdCdDZ$dZdEdFZ%dGdHZ&d[dJdKZ'dLdMZ(dNdOZ)dPdQZ*dIS)\MemCacheProtocola1 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<cCs*t|_d|_d|_d|_||_|_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)rr*rrrrs zMemCacheProtocol.__init__cCs$x|jr|j}||qWdS)zW Cancel all the outstanding commands, making them fail with C{reason}. N)r%popleftr)rreasoncmdrrr_cancelCommandss z MemCacheProtocol._cancelCommandscCs|td|jdS)z: Close the connection in case of timeout. zConnection timeoutN)r.r transportZloseConnection)rrrrtimeoutConnectionsz"MemCacheProtocol.timeoutConnectioncCs d|_||t||dS)z9 Cause any outstanding commands to fail. TN) _disconnectedr.rconnectionLost)rr,rrrr2s zMemCacheProtocol.connectionLostcCs"|js||jt||dS)zA Override sendLine to add a timeout to response. N)r% setTimeoutr)rsendLine)rlinerrrr4s zMemCacheProtocol.sendLinecCs||j||jt|7_|j|jdkrd|j}|d|j}||jdd}|}d|_d|_d|_|jd}|jr|j |j \}}|||f|j |j <n||_ | |dS)z) Collect data for a get. Nr) resetTimeoutr'appendr(lenr&joinr%multiplevalues currentKeyrZ setLineMode)rdatabufremvalr-flagscasrrrrawDataReceiveds"   z MemCacheProtocol.rawDataReceivedcCs|jddS)z? Manage a success response to a set operation. TN)r%r+r )rrrr cmd_STOREDszMemCacheProtocol.cmd_STOREDcCs|jddS)z Manage a specific 'not stored' response to a set operation: this is not an error, but some condition wasn't met. FN)r%r+r )rrrrcmd_NOT_STOREDszMemCacheProtocol.cmd_NOT_STOREDcCs|j}|jdkrN|jr:dd|jD}||q||j|jfnb|jdkr|jrl||jq||j|j |jfn,|jdkr||jnt d t |jdS)zB This the end token to a get or a stat operation. sgetcSs i|]\}}|ddd|qS)Nr6r).0keyrBrrr sz,MemCacheProtocol.cmd_END..sgetssstatsz%Unexpected END response to {} commandN) r%r+rr<r=rr rCrrD RuntimeErrorformatr )rr-r=rrrcmd_ENDs     zMemCacheProtocol.cmd_ENDcCs|jddS)z= Manage error response for incr/decr/delete. FN)r%r+r )rrrr cmd_NOT_FOUNDszMemCacheProtocol.cmd_NOT_FOUNDcCs|jd}|jdkr(|\}}}d}n|\}}}}t||_g|_d|_|jr||jkrft d||_ t||g|j |<n"|j |krt dt||_ ||_|dS)z: Prepare the reading a value after a get. rsgetr7zUnexpected commands answer.N)r%rsplitintr&r'r(r<keysrKr>r=rIrCrDZ setRawMode)rr5r-rIrClengthrDrrr cmd_VALUEs$      zMemCacheProtocol.cmd_VALUEcCs(|jd}|dd\}}||j|<dS)z- Reception of one stat line. r N)r%rOr=)rr5r-rIrBrrrcmd_STAT s zMemCacheProtocol.cmd_STATcCs|j|dS)z% Read version token. N)r%r+r )rZ versionDatarrr cmd_VERSIONszMemCacheProtocol.cmd_VERSIONcCs$td|j}|tdS)z7 A non-existent command has been sent. zNon-existent command sent.N)rerrr%r+rr )rr-rrr cmd_ERRORs  zMemCacheProtocol.cmd_ERRORcCs2t|}td||j}|t|dS)z0 An invalid input as been sent. zInvalid input: N)reprrrXr%r+rr)rerrTextr-rrrcmd_CLIENT_ERROR s z!MemCacheProtocol.cmd_CLIENT_ERRORcCs2t|}td||j}|t|dS)z4 An error has happened server-side. zServer error: N)rZrrXr%r+rr)rr[r-rrrcmd_SERVER_ERROR)s z!MemCacheProtocol.cmd_SERVER_ERRORcCs|jddS)z> A delete command has completed successfully. TN)r%r+r )rrrr cmd_DELETED2szMemCacheProtocol.cmd_DELETEDcCs|jddS)z6 The last command has been completed. TN)r%r+r )rrrrcmd_OK8szMemCacheProtocol.cmd_OKcCs|jddS)z5 A C{checkAndSet} update has failed. FN)r%r+r )rrrr cmd_EXISTS>szMemCacheProtocol.cmd_EXISTScCs||ddd}t|dt|d}|dk rb|dddd}|rZ||dq|nL|dd}t|dt|d}|dk r|n|j}t|}|||js| ddS)z8 Receive line commands from the server. rTrUrZcmd_N_) r8rOgetattrr replacer%r+rPr r3)rr5tokenr-argsrBrrr lineReceivedDs"   zMemCacheProtocol.lineReceivedrUcCs|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) _incrdecr)rrIrBrrr incrementaszMemCacheProtocol.incrementcCs|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} sdecr)rg)rrIrBrrr decrementrszMemCacheProtocol.decrementcCs|jrttdSt|ts2ttdt|St||j krLttdSd ||dt |fg}| |t ||d}|j||jS)z1 Internal wrapper for incr/decr. z not connectedz)Invalid type for key: {}, expecting bytesz Key too longrTs%d)rI)r1rrK isinstancebytesrrLtyper:MAX_KEY_LENGTHr;rPr4rr%r9r)rr-rIrBfullcmdcmdObjrrrrgs      zMemCacheProtocol._incrdecrrcCs|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} sreplacer7)_set)rrIrBrC expireTimerrrrcszMemCacheProtocol.replacecCs|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} saddr7)rp)rrIrBrCrqrrraddszMemCacheProtocol.addcCs|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} ssetr7)rp)rrIrBrCrqrrrsetszMemCacheProtocol.setcCs|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} scas)rp)rrIrBrDrCrqrrr checkAndSetszMemCacheProtocol.checkAndSetc Cs|jrttdSt|ts2ttdt|St||j krLttdSt|tslttdt|S|rxd|}t|}d ||t d|||fg|}| || |t ||||d} |j| | jS)z6 Internal wrapper for setting values. z not connectedz)Invalid type for key: {}, expecting bytesz Key too longz+Invalid type for value: {}, expecting bytesrTz%d %d %d)rIrCrR)r1rrKrjrkrrLrlr:rmr;r r4rr%r9r) rr-rIrBrCrqrDrRrnrorrrrps.       zMemCacheProtocol._setcCs|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} sappendrr7)rp)rrIrBrrrr9szMemCacheProtocol.appendcCs|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} sprependrr7)rp)rrIrBrrrprepend.szMemCacheProtocol.prependcCs||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)rrIwithIdentifierrrrget@szMemCacheProtocol.getcCs|||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 T)rv)rrQrwrrr getMultipleXszMemCacheProtocol.getMultiplec Cst|}|jrttdSxF|D]>}t|tsDttdt|St ||j kr ttdSq W|rld}nd}d |g|}| ||rdd|D}t |||d d }nt ||d d d d dd}|j||jS)z> Helper method for C{get} and C{getMultiple}. z not connectedz)Invalid type for key: {}, expecting bytesz Key too longsgetssgetrTcSsi|] }d|qS))rr7Nr)rHrIrrrrJsz)MemCacheProtocol._get..T)rQr=r<rNr7F)rIrrCrDr<)listr1rrKrjrkrrLrlr:rmr;r4rr%r9r) rrQrwr<rIr-rnr=rorrrrvrs,     zMemCacheProtocol._getNcCsL|rd|}nd}|jr$ttdS||tdid}|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 sstatsz not connected)r=)r1rrKr4rr%r9r)rargr-rorrrstatss     zMemCacheProtocol.statscCs6|jrttdS|dtd}|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} z not connectedsversion)r1rrKr4rr%r9r)rrorrrversions    zMemCacheProtocol.versioncCs^|jrttdSt|ts2ttdt|S|d|t d|d}|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} z not connectedz)Invalid type for key: {}, expecting bytessdelete sdelete)rI) r1rrKrjrkrrLrlr4rr%r9r)rrIrorrrdeletes     zMemCacheProtocol.deletecCs6|jrttdS|dtd}|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} z not connecteds flush_all)r1rrKr4rr%r9r)rrorrrflushAlls    zMemCacheProtocol.flushAll)r$)rU)rU)rr)rr)rr)rr)F)F)N)+r r rrrmr1rr.r0r2r4rErFrGrMrNrSrVrWrYr\r]r^r_r`rfrhrirgrcrrrsrtrpr9rurxryrvr|r}r~rrrrrr"dsP         #   r" DEFAULT_PORTN)r collectionsrZtwisted.protocols.basicrZtwisted.protocols.policiesrZtwisted.internet.deferrrrZtwisted.pythonrZtwisted.python.compatr r r Exceptionr rrrr"__all__rrrrs,    )