U ~Hjc\@sdZddlmZddlmZmZmZddlmZddl m Z ddl m Z ddl mZmZdZGd d d eZGd d d eZGd ddeZGdddZGdddee Zddd 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)Deferred TimeoutErrorfail) LineReceiver) TimeoutMixin)log) nativeString networkStringi+c@seZdZdZdS) NoSuchCommandzA Exception raised when a non existent command is called. N__name__ __module__ __qualname____doc__rr>/tmp/pip-unpacked-wheel-ewod1tgb/twisted/protocols/memcache.pyr (sr c@seZdZdZdS) ClientErrorz1 Error caused by an invalid client call. Nr rrrrr.src@seZdZdZdS) ServerErrorz* Problem happening on the server. Nr rrrrr4src@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} cKs0||_t|_|D]\}}t|||qdS)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__Gs zCommand.__init__cCs|j|dS)zB Shortcut method to fire the underlying deferred. N)rcallback)rvaluerrrsuccessVszCommand.successcCs|j|dS)z5 Make the underlying deferred fails. N)rZerrback)rerrorrrrr\sz Command.failN)r rrrrr!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 |jr|j}||qdS)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 transportZloseConnectionrrrrtimeoutConnectionsz"MemCacheProtocol.timeoutConnectioncCs d|_||t||dS)z9 Cause any outstanding commands to fail. TN) _disconnectedr/rconnectionLost)rr-rrrr4s zMemCacheProtocol.connectionLostcCs"|js||jt||dS)zA Override sendLine to add a timeout to response. N)r& setTimeoutr*rsendLine)rlinerrrr6s 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 currentKeyr Z setLineMode)rdatabufremvalr.flagscasrrrrawDataReceiveds"   z MemCacheProtocol.rawDataReceivedcCs|jddS)z? Manage a success response to a set operation. TNr&r,r!r1rrr 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. FNrHr1rrrcmd_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. getcSs i|]\}}||dddqS)Nr8r).0keyrDrrr sz,MemCacheProtocol.cmd_END..getsstatsz%Unexpected END response to {} commandN) r&r,rr>r?rr!rEr rF RuntimeErrorformatr )rr.r?rrrcmd_ENDs"     zMemCacheProtocol.cmd_ENDcCs|jddS)z= Manage error response for incr/decr/delete. FNrHr1rrr 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. rrKr9zUnexpected commands answer.N)r&rsplitintr'r(r)r>keysrQr@r?rMrErFZ setRawMode)rr7r.rMrElengthrFrrr cmd_VALUEs$      zMemCacheProtocol.cmd_VALUEcCs(|jd}|dd\}}||j|<dS)z- Reception of one stat line. r N)r&rUr?)rr7r.rMrDrrrcmd_STAT s zMemCacheProtocol.cmd_STATcCs|j|dS)z% Read version token. NrH)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)reprrr^r&r,rrrZerrTextr.rrrcmd_CLIENT_ERRORs z!MemCacheProtocol.cmd_CLIENT_ERRORcCs2t|}td||j}|t|dS)z4 An error has happened server-side. zServer error: N)r`rr^r&r,rrrarrrcmd_SERVER_ERROR(s z!MemCacheProtocol.cmd_SERVER_ERRORcCs|jddS)z> A delete command has completed successfully. TNrHr1rrr cmd_DELETED1szMemCacheProtocol.cmd_DELETEDcCs|jddS)z6 The last command has been completed. TNrHr1rrrcmd_OK7szMemCacheProtocol.cmd_OKcCs|jddS)z5 A C{checkAndSet} update has failed. FNrHr1rrr 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. rZr[rZcmd_N_) r:rUgetattrr replacer&r,rVr!r5)rr7tokenr.argsrDrrr lineReceivedCs"   zMemCacheProtocol.lineReceivedr[cCs|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 _incrdecrrrMrDrrr increment`szMemCacheProtocol.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} sdecrrmrorrr decrementqszMemCacheProtocol.decrementcCs|jrttdSt|ts4ttdt|dSt||jkrNttdSd ||dt |fg}| |t ||d}|j ||jS)z1 Internal wrapper for incr/decr. not connectedInvalid type for key: , expecting bytes Key too longrZs%drM)r3rrQ isinstancebytesrtyper<MAX_KEY_LENGTHr=rVr6rr&r;r)rr.rMrDfullcmdcmdObjrrrrns      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} sreplacer9_setrrMrDrE expireTimerrrriszMemCacheProtocol.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} saddr9r}rrrraddszMemCacheProtocol.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} ssetr9r}rrrrsetszMemCacheProtocol.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} scasr})rrMrDrFrErrrr checkAndSetszMemCacheProtocol.checkAndSetc Cs|jrttdSt|ts4ttdt|dSt||jkrNttdSt|tspttdt|dS|r|d|}t|}d ||t d|||fg|}| || |t ||||d} |j | | jS) z6 Internal wrapper for setting values. rrrsrtruzInvalid type for value: rZz%d %d %d)rMrErX)r3rrQrwrxrryr<rzr=r r6rr&r;r) rr.rMrDrErrFrXr{r|rrrr~s4       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} sappendrr9r}rorrrr;szMemCacheProtocol.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} sprependrr9r}rorrrprepend'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)rrMwithIdentifierrrrget9szMemCacheProtocol.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 Tr)rrWrrrr getMultipleQszMemCacheProtocol.getMultiplec Cst|}|jrttdS|D]H}t|tsHttdt|dSt||j krttdSq|rrd}nd}d |g|}| ||rdd |D}t |||d d }nt ||d d d ddd}|j ||jS)z> Helper method for C{get} and C{getMultiple}. rrrsrtrurOrKrZcSsi|] }|dqS))rr9Nr)rLrMrrrrNsz)MemCacheProtocol._get..T)rWr?r>rNr9F)rMr rErFr>)listr3rrQrwrxrryr<rzr=r6rr&r;r) rrWrr>rMr.r{r?r|rrrrks8    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 rPrr)r?r3rrQr6rr&r;r)rargr.r|rrrstatss     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} rrsversionrrr|rrrversions    zMemCacheProtocol.versioncCs`|jrttdSt|ts4ttdt|dS|d|td|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} rrrsrtsdelete sdeleterv) r3rrQrwrxrryr6rr&r;r)rrMr|rrrdeletes     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} rrs flush_allrrrrrflushAlls    zMemCacheProtocol.flushAll)r%)r[)r[)rr)rr)rr)rr)F)F)N)+r rrrrzr3rr/r2r4r6rGrIrJrSrTrYr\r]r_rbrcrdrerfrlrprqrnrirrrr~r;rrrrrrrrrrrrr#csP            r# DEFAULT_PORTN)r collectionsrZtwisted.internet.deferrrrZtwisted.protocols.basicrZtwisted.protocols.policiesrZtwisted.pythonrZtwisted.python.compatr r r Exceptionr rrrr#__all__rrrrs,    )y