U be@sUddlZddlZddlZddlmZddlmZddlmZddl m Z m Z m Z m Z mZmZmZmZddlmZddlmZmZmZmZmZmZddlmZd Zd d d d d d d Zd hZdddddZ eee!e"fe!fZ#ee$e!fZ%e$e&dddZ'e$e&dddZ(e$e)dddZ*e$e"dddZ+e$e*e*e'e'e$e)e$e+e'e'e(e'e'e'dZ,e e$e e$ge ffe-d<d5e%e&e$e$dddZ.e#e#d d!d"Z/Gd#d$d$Z0Gd%d&d&Z1Gd'd(d(Z2eje$ee$e$fd)d*d+Z3eje$e"d,d-d.Z4eje$e$ee$e$fd/d0d1Z5eje"e$d2d3d4Z6dS)6N)partial) SSLContext) ModuleType)AnyCallableDictIterableListOptionalTupleUnion)pool)MemcacheClientErrorMemcacheIllegalInputErrorMemcacheServerErrorMemcacheUnexpectedCloseErrorMemcacheUnknownCommandErrorMemcacheUnknownError)LegacyWrappingSerdei)STORED NOT_STORED)rEXISTS NOT_FOUND)setaddreplaceappendprependcasLinuxTF)rrrr)valuereturncCs t|dkS)Nrintr r%X/var/www/html/services/stratfitenv/lib/python3.8/site-packages/pymemcache/client/base.py_parse_bool_int=sr'cCs|dkS)Nsyesr%r$r%r%r&_parse_bool_string_is_yesAsr(cCst|ddS)N:.)floatreplacer$r%r%r& _parse_floatEsr-cCs t|dS)Nr"r$r%r%r& _parse_hexIsr/)versions rusage_users rusage_systemshash_is_expandingsslab_reassign_runningsinters growth_factorsstat_key_prefixsumasksdetail_enableds cas_enabledsauth_enabled_sasls maxconns_fasts slab_reassigns slab_automove STAT_TYPES)keyallow_unicode_keys key_prefixr!c Cs|rt|trX|d}n>t|trXz|d}Wn$ttfk rVtd|YnX||}|}t|dkrtd|n>t|dks|r|d|krtd|nd |krtd ||S) Checks key and add key_prefix.utf8asciizNon-ASCII key: %rzKey is too long: %rrzKey contains whitespace: %rzKey contains null: %r) isinstancestrencodeUnicodeEncodeErrorUnicodeDecodeErrorrsplitlen)r3r4r5partsr%r%r&check_key_helperds"     rD)serverr!cCst|tr|St|ts&td||dr<|ddS|drJ|Sd|ks\|drh|d}}n"|dd}|d t|d}}|d r|d }||fS) Nz"Unsupported server specification: zunix:/:]i+r:r[z[]) r<tupler= ValueError startswithendswithrsplitr#strip)rEhostportrCr%r%r&normalize_server_specs         rSc@s*eZdZdZdZd eeeddddZdS) KeepaliveOptsa A configuration structure to define the socket keepalive. This structure must be passed to a client. The client will configure its socket keepalive by using the elements of the structure. Args: idle: The time (in seconds) the connection needs to remain idle before TCP starts sending keepalive probes. Should be a positive integer most greater than zero. intvl: The time (in seconds) between individual keepalive probes. Should be a positive integer most greater than zero. cnt: The maximum number of keepalive probes TCP should send before dropping the connection. Should be a positive integer most greater than zero. )idleintvlcntr:rFN)rUrVrWr!cCsF|dkrtd||_|dkr&td||_|dkrZ,d?d@Z-ed dAdBZ.e d dCdDZ/d{e0e e fe0e e fe dFdGdHZ1d|eeeedIdJdKZ2dd dLdMZ3d}eddNdOdPZ4e e ddQdRdSZ5ee e dTdUdVZ6e0ee e fe dWdXdYZ7ee e ee efee e$ee0ee$ee ffe fdZd[d\Z8d~e e!eee eeefd]d^d_Z9de eeefeeeeee eeeefd`dadbZ:de!e e eeee dcdddeZ;edfdgdhZdS)Clienta A client for a single memcached server. *Server Connection* The ``server`` parameter controls how the client connects to the memcached server. You can either use a (host, port) tuple for a TCP connection or a string containing the path to a UNIX domain socket. The ``connect_timeout`` and ``timeout`` parameters can be used to set socket timeout values. By default, timeouts are disabled. When the ``no_delay`` flag is set, the ``TCP_NODELAY`` socket option will also be set. This only applies to TCP-based connections. Lastly, the ``socket_module`` allows you to specify an alternate socket implementation (such as `gevent.socket`_). .. _gevent.socket: http://www.gevent.org/api/gevent.socket.html *Keys and Values* Keys must have a __str__() method which should return a str with no more than 250 ASCII characters and no whitespace or control characters. Unicode strings must be encoded (as UTF-8, for example) unless they consist only of ASCII characters that are neither whitespace nor control characters. Values must have a __str__() method to convert themselves to a byte string. Unicode objects can be a problem since str() on a Unicode object will attempt to encode it as ASCII (which will fail if the value contains code points larger than U+127). You can fix this with a serializer or by just calling encode on the string (using UTF-8, for instance). If you intend to use anything but str as a value, it is a good idea to use a serializer. The pymemcache.serde library has an already implemented serializer which pickles and unpickles data. *Serialization and Deserialization* The constructor takes an optional object, the "serializer/deserializer" ("serde"), which is responsible for both serialization and deserialization of objects. That object must satisfy the serializer interface by providing two methods: `serialize` and `deserialize`. `serialize` takes two arguments, a key and a value, and returns a tuple of two elements, the serialized value, and an integer in the range 0-65535 (the "flags"). `deserialize` takes three parameters, a key, value, and flags, and returns the deserialized value. Here is an example using JSON for non-str values: .. code-block:: python class JSONSerde(object): def serialize(self, key, value): if isinstance(value, str): return value, 1 return json.dumps(value), 2 def deserialize(self, key, value, flags): if flags == 1: return value if flags == 2: return json.loads(value) raise Exception("Unknown flags for value: {1}".format(flags)) .. note:: Most write operations allow the caller to provide a ``flags`` value to support advanced interaction with the server. This will **override** the "flags" value returned by the serializer and should therefore only be used when you have a complete understanding of how the value should be serialized, stored, and deserialized. *Error Handling* All of the methods in this class that talk to memcached can throw one of the following exceptions: * :class:`pymemcache.exceptions.MemcacheUnknownCommandError` * :class:`pymemcache.exceptions.MemcacheClientError` * :class:`pymemcache.exceptions.MemcacheServerError` * :class:`pymemcache.exceptions.MemcacheUnknownError` * :class:`pymemcache.exceptions.MemcacheUnexpectedCloseError` * :class:`pymemcache.exceptions.MemcacheIllegalInputError` * :class:`socket.timeout` * :class:`socket.error` Instances of this class maintain a persistent connection to memcached which is terminated when any of these exceptions are raised. The next call to a method on the object will result in a new connection being made to memcached. NFr2Tr8) rEconnect_timeouttimeoutno_delay ignore_exc socket_modulesocket_keepaliver5default_noreplyr4encoding tls_contextcCst||_|pt|||_||_||_||_||_| |_| |_ t }|j dk r|t krtt dj|dtt dt|j tstdd|_t| tr| d} t| tstd| |_| |_| |_||_||_dS)a Constructor. Args: server: tuple(hostname, port) or string containing a UNIX socket path. serde: optional serializer object, see notes in the class docs. serializer: deprecated serialization function deserializer: deprecated deserialization function connect_timeout: optional float, seconds to wait for a connection to the memcached server. Defaults to "forever" (uses the underlying default socket timeout, which can be very long). timeout: optional float, seconds to wait for send or recv calls on the socket connected to memcached. Defaults to "forever" (uses the underlying default socket timeout, which can be very long). no_delay: optional bool, set the TCP_NODELAY flag, which may help with performance in some cases. Defaults to False. ignore_exc: optional bool, True to cause the "get", "gets", "get_many" and "gets_many" calls to treat any errors as cache misses. Defaults to False. socket_module: socket module to use, e.g. gevent.socket. Defaults to the standard library's socket module. socket_keepalive: Activate the socket keepalive feature by passing a KeepaliveOpts structure in this parameter. Disabled by default (None). This feature is only supported on Linux platforms. key_prefix: Prefix of key. You can use this as namespace. Defaults to b''. default_noreply: bool, the default value for 'noreply' as passed to store commands (except from cas, incr, and decr, which default to False). allow_unicode_keys: bool, support unicode (utf8) keys encoding: optional str, controls data encoding (defaults to 'ascii'). Notes: The constructor does not make a connection to memcached. The first call to a method on the object will do that. Na-Pymemcache's socket keepalive mechanism doesn't support your system ({user_system}). If you see this message it mean that you tried to configure your socket keepalive on an unsupported system. To fix the problem pass `socket_keepalive=False` or use a supported system. Supported systems are: {systems}z, ) user_systemZsystemsa Unsupported keepalive options. If you see this message it means that you passed an unsupported object within the param `socket_keepalive`. To fix it please instantiate and pass to socket_keepalive a KeepaliveOpts object. That's the only supported type of structure.r8key_prefix should be bytes.)rSrErserder`rarbrcrdreplatformsystem!SOCKET_KEEPALIVE_SUPPORTED_SYSTEM SystemErrorformatjoinsortedr<rTrLsockr=r>bytes TypeErrorr5rfr4rgrh)rXrErk serializer deserializerr`rarbrcrdrer5rfr4rgrhrir%r%r&rYs>6       zClient.__init__)r3r5r!cCst||j|dSr6)r4r5)rDr4)rXr3r5r%r%r& check_keyss zClient.check_keyr!c Cs||j}t|jts2|j}||j|j}nd}d}|j\}}||||j |j|j }|D]\}} } } }zD||| | }|j r| |j |j d|jr|j} | j||d}Wn:tk r} z| }|dk r|d}W5d} ~ XYq`Xqq`|dk r|z||j|jdk rp| tjtjd| tj tj|jj| tj tj|jj| tj tj|jj||||jWn tk r|YnX||_dS)Nr:)server_hostname)closerdr<rErKsocketAF_UNIX SOCK_STREAM getaddrinfo AF_UNSPEC IPPROTO_TCPrb setsockopt TCP_NODELAYrh wrap_socket Exception settimeoutr`re SOL_SOCKET SO_KEEPALIVE TCP_KEEPIDLErU TCP_KEEPINTVLrV TCP_KEEPCNTrWconnectrars)rXssockaddrrserrorrQrRinfofamilysocktypeproto_contexter%r%r&_connectysd      zClient._connectcCs@|jdk rsz#Client.set_many..)rfritems)rXrrrrresultr%r%r&set_manyszClient.set_manycCs:|dkr|j}|jd||i|||d|}|dk s6t|S)a1 The memcached "add" command. Args: key: str, see class docs for details. value: str, see class docs for details. expire: optional int, number of seconds until the item is expired from the cache, or zero for no expiry (the default). noreply: optional bool, True to not wait for the reply (defaults to self.default_noreply). flags: optional int, arbitrary bit field used for server-specific flags Returns: If ``noreply`` is True (or if it is unset and ``self.default_noreply`` is True), the return value is always True. Otherwise the return value is True if the value was stored, and False if it was not (because the key already existed). NrrrfrAssertionErrorrXr3r rrrresponser%r%r&adds z Client.add)r3rrrr!cCs:|dkr|j}|jd||i|||d|}|dk s6t|S)a* The memcached "replace" command. Args: key: str, see class docs for details. value: str, see class docs for details. expire: optional int, number of seconds until the item is expired from the cache, or zero for no expiry (the default). noreply: optional bool, True to not wait for the reply (defaults to self.default_noreply). flags: optional int, arbitrary bit field used for server-specific flags Returns: If ``noreply`` is True (or if it is unset and ``self.default_noreply`` is True), the return value is always True. Otherwise returns True if the value was stored and False if it wasn't (because the key didn't already exist). Nrrrrr%r%r&r, s zClient.replacecCs:|dkr|j}|jd||i|||d|}|dk s6t|S)a1 The memcached "append" command. Args: key: str, see class docs for details. value: str, see class docs for details. expire: optional int, number of seconds until the item is expired from the cache, or zero for no expiry (the default). noreply: optional bool, True to not wait for the reply (defaults to self.default_noreply). flags: optional int, arbitrary bit field used for server-specific flags Returns: True. Nrrrrr%r%r&appendDs z Client.appendrrrcCs*|dkr|j}|jd||i|||d|S)a2 The memcached "prepend" command. Args: key: str, see class docs for details. value: str, see class docs for details. expire: optional int, number of seconds until the item is expired from the cache, or zero for no expiry (the default). noreply: optional bool, True to not wait for the reply (defaults to self.default_noreply). flags: optional int, arbitrary bit field used for server-specific flags Returns: True. Nrrrrr%r%r&prependes zClient.prepend)rrr!cCs(||}|jd||i||||d|S)a\ The memcached "cas" command. Args: key: str, see class docs for details. value: str, see class docs for details. cas: int or str that only contains the characters '0'-'9'. expire: optional int, number of seconds until the item is expired from the cache, or zero for no expiry (the default). noreply: optional bool, False to wait for the reply (the default). flags: optional int, arbitrary bit field used for server-specific flags Returns: If ``noreply`` is True (or if it is unset and ``self.default_noreply`` is True), the return value is always True. Otherwise returns None if the key didn't exist, False if it existed but had a different cas value and True if it existed and was changed. r)rcas) _check_casr)rXr3r rrrrr%r%r&rs z Client.casr3defaultr!cCs|jd|gd|jd||S)a5 The memcached "get" command, but only for one key, as a convenience. Args: key: str, see class docs for details. default: value that will be returned if the key was not found. Returns: The value for the key, or default if the key wasn't found. getFr5 _fetch_cmdr5get)rXr3rr%r%r&rs z Client.getkeysr!cCs|siS|jd|d|jdS)aJ The memcached "get" command. Args: keys: list(str), see class docs for details. Returns: A dict in which the keys are elements of the "keys" argument list and the values are values from the cache. The dict may contain all, some or none of the given keys. rFrrr5rXrr%r%r&get_manys zClient.get_many)r3r cas_defaultr!cCs&||f}|jd|gd|jd||S)a The memcached "gets" command for one key, as a convenience. Args: key: str, see class docs for details. default: value that will be returned if the key was not found. cas_default: same behaviour as default argument. Returns: A tuple of (value, cas) or (default, cas_defaults) if the key was not found. getsTrr)rXr3rrdefaultsr%r%r&getss z Client.getscCs|siS|jd|d|jdS)a[ The memcached "gets" command. Args: keys: list(str), see class docs for details. Returns: A dict in which the keys are elements of the "keys" argument list and the values are tuples of (value, cas) from the cache. The dict may contain all, some or none of the given keys. rTrrrr%r%r& gets_manys zClient.gets_manyr3rr!cCsX|dkr|j}d|||j}|r,|d7}|d7}||gd|}|rLdS|ddkS) a The memcached "delete" command. Args: key: str, see class docs for details. noreply: optional bool, True to not wait for the reply (defaults to self.default_noreply). Returns: If ``noreply`` is True (or if it is unset and ``self.default_noreply`` is True), the return value is always True. Otherwise returns True if the key was deleted, and False if it wasn't found. Ndelete  noreply deleteTrsDELETED)rfryr5 _misc_cmd)rXr3rcmdresultsr%r%r&deletesz Client.deleterrr!cCs^|sdS|dkr|j}g}|D],}|d|||j|r>dnddq||d|dS)a A convenience function to delete multiple keys. Args: keys: list(str), the list of keys to delete. noreply: optional bool, True to not wait for the reply (defaults to self.default_noreply). Returns: True. If an exception is raised then all, some or none of the keys may have been deleted. Otherwise all the keys have been sent to memcache for deletion and if noreply is False, they have been acknowledged by memcache. TNrrr2rr)rfrryr5r)rXrrcmdsr3r%r%r& delete_manys"  zClient.delete_many)r3r rr!cCsr|||j}||d}d|d|}|r6|d7}|d7}||gd|}|rVdS|dd krfdSt|dS) a The memcached "incr" command. Args: key: str, see class docs for details. value: int, the amount by which to increment the value. noreply: optional bool, False to wait for the reply (the default). Returns: If noreply is True, always returns None. Otherwise returns the new value of the key, or None if the key wasn't found. r sincr  rrsincrNrrryr5_check_integerrr#rXr3r rvalrrr%r%r&incr&s  z Client.incrcCsr|||j}||d}d|d|}|r6|d7}|d7}||gd|}|rVdS|dd krfdSt|dS) a The memcached "decr" command. Args: key: str, see class docs for details. value: int, the amount by which to decrement the value. noreply: optional bool, False to wait for the reply (the default). Returns: If noreply is True, always returns None. Otherwise returns the new value of the key, or None if the key wasn't found. r sdecr rrrsdecrNrrrrr%r%r&decrBs  z Client.decr)r3rrr!cCsp|dkr|j}|||j}||d}d|d|}|rD|d7}|d7}||gd|}|rddS|d d kS) a The memcached "touch" command. Args: key: str, see class docs for details. expire: optional int, number of seconds until the item is expired from the cache, or zero for no expiry (the default). noreply: optional bool, True to not wait for the reply (defaults to self.default_noreply). Returns: True if the expiration time was updated, False if the key wasn't found. Nrstouch rrrstouchTrsTOUCHED)rfryr5rr)rXr3rr expire_bytesrrr%r%r&touch^s z Client.touchc GsV|d|d}|D]:\}}t|t}z||||<Wqtk rNYqXq|S)a The memcached "stats" command. The returned keys depend on what the "stats" command returns. A best effort is made to convert values to appropriate Python types, defaulting to strings when a conversion cannot be made. Args: *arg: extra string arguments to the "stats" command. See the memcached protocol documentation for more information. Returns: A dict of the returned stats. statsF)rrr1rr#r)rXargsrr3r converterr%r%r&statszs z Client.statscCs ||d}|d|gddS)z The memcached "cache_memlimit" command. Args: memlimit: int, the number of megabytes to set as the new cache memory limit. Returns: If no exception is raised, always returns True. memlimitscache_memlimitFT)rr)rXrr%r%r&cache_memlimits zClient.cache_memlimitcCsFd}||gdd}|dd\}}}|dkrBtd|d|S)zs The memcached "version" command. Returns: A string of the memcached version. s version r0FrrsVERSIONzReceived unexpected response: )r partitionr)rXrrbeforerafterr%r%r&versions zClient.version )command end_tokensr!cCs\|jr dnd}t|tr"||n|}t|tr:||n|}|d|dg|d|dS)a Sends an arbitrary command to the server and parses the response until a specified token is encountered. Args: command: str|bytes: The command to send. end_tokens: str|bytes: The token expected at the end of the response. If the `end_token` is not found, the client will wait until the timeout specified in the constructor. Returns: The response from the server, with the `end_token` removed. r7r8r2rFr)r4r<r=r>r)rXrrrgr%r%r& raw_commands zClient.raw_command)delayrr!cCsZ|dkr|j}||d}d|}|r.|d7}|d7}||gd|}|rNdS|dd kS) ah The memcached "flush_all" command. Args: delay: optional int, the number of seconds to wait before flushing, or zero to flush immediately (the default). noreply: optional bool, True to not wait for the reply (defaults to self.default_noreply). Returns: True. Nrs flush_all rrs flush_allTrOK)rfrr)rXrrZ delay_bytesrrr%r%r& flush_alls  zClient.flush_allcCs d}||gdd|dS)z The memcached "quit" command. This will close the connection with memcached. Calling any other method on this object will re-open the connection, so this object can be re-used after quit. squit squitTN)rr|)rXrr%r%r&quitsz Client.quitgracefulr!cCsFd}|r|d7}|d7}z||gddWntk r@YnXdS)a The memcached "shutdown" command. This will request shutdown and eventual termination of the server, optionally preceded by a graceful stop of memcached's internal state machine. Note that the server needs to have been started with the shutdown protocol command enabled with the --enable-shutdown flag. Args: graceful: optional bool, True to request a graceful shutdown with SIGUSR1 (defaults to False, i.e. SIGINT shutdown). sshutdowns gracefulrFN)rr)rXrrr%r%r&shutdowns zClient.shutdown)linenamer!cCsf|drt||dr:||ddd}t||drb||ddd}t|dS)NsERRORs CLIENT_ERRORrr:s SERVER_ERROR)rMrfindrr)rXrrrr%r%r& _raise_errorss   zClient._raise_errors)r rr!cCs,t|tst|d|t||jS)zACheck that a value is an integer and encode it as a binary stringz! must be integer, got bad value: )r<r#rr=r>rg)rXr rr%r%r&rs   zClient._check_integer)rr!cCstt|ttfrFzt||j}Wq\tk rBtd|Yq\Xnt|ts\td||sptd||S)zCheck that a value is a valid input for 'cas' -- either an int or a string containing only 0-9 The value will be (re)encoded so that we can accept strings or bytes. znon-ASCII cas value: %rz8cas must be integer, string, or bytes, got bad value: %rz6cas must only contain values in 0-9, got bad value: %r) r<r#r=r>rgr?rrtisdigit)rXrr%r%r&rs zClient._check_cas) expect_casrbuf remapped_keys prefixed_keysr!c Cs|r|\}}}} } nLz|\}}}} Wn6tk rb} ztd|d| W5d} ~ XYnXd} z(|jdk sxtt|j|t| \}} Wntk r|YnX||} |j | | t|} |r| | | f|fS| | |fSdS)z This function is abstracted from _fetch_cmd to support different ways of value extraction. In order to use this feature, _extract_value needs to be overridden in the subclass. zUnable to parse line z: N) rArrLrsr _readvaluer#rr|rkZ deserialize)rXrrrrrrr3rsizerrr Z original_keyr%r%r&_extract_value5s$ &zClient._extract_value)rrrr5r!csfdd|D}tt||}|}|r<|dd|7}|d7}zNjdkrhjdk shtj|d}d} i} ztj|\}} Wntk r YnX | || dks| dkr| WS| dr || |||\} } }| | | <q|d krF| d rF| } t| d kr8| d nd| | d <q|d kr| d r| } d| d d| | d <qt| ddqWn0tk r jriYSYnXdS)Ncsg|]}j|dqS)r)ryrrr5rXr%r&rbsz%Client._fetch_cmd..rrr2sENDrsVALUErsSTATr:sITEM )dictziprqrsrrsendall _readlinerr|rrMrrArBrrrc)rXrrrr5rrrrrrr3r key_valuer%rr&r[sV      $zClient._fetch_cmd)rrrrrrr!c Cs"g}g}d} |dk r | d|7} |r,| d7} ||d} |D]\} } || || |j} |j| | \} } |dk r~|} t| tszt |  |j } Wn.t k r}zt d|W5d}~XYnX||d| dt |  |j d| dt t|  |j | d| dq@|jdkrH||jdk sHtz|jd||rrdd|DWSi}d}d}|D]t} zt|j|\}}Wn tk r|YnX||||t|krt||| <nt|dd q|WStk r|YnXdS) Nr2rrrz#Data values must be binary-safe: %srcSsi|] }|dqS)Tr%rr%r%r& sz%Client._store_cmd..r)rrrryr5rk serializer<rtr=r>rgr?rrBrsrrrrqrrr|rVALID_STORE_RESULTSSTORE_RESULTS_VALUErr)rXrrrrrrrrextrarr3dataZ data_flagsrrrrr%r%r&rs           zClient._store_cmd)rcmd_namerr!c Cs|rtt|d}nt}|jdkr6||jdk s6tz|jd||rTgWSg}d}d}|D]N} z||j|\}}Wntk r| YnX| ||| |qd|WSt k r| YnXdS)N)rr2) r _readsegmentrrsrrrrqrr|rrr) rXrr rr_readerrrrrr%r%r&rs2    zClient._misc_cmdr3cCs|j||dddSNTrrrXr3r r%r%r& __setitem__szClient.__setitem__cCs||}|dkrt|SNrKeyErrorrr%r%r& __getitem__s zClient.__getitem__cCs|j|dddSrrrXr3r%r%r& __delitem__ szClient.__delitem__)rNN)rNN)rNN)rNN)rNN)rNN)rFN)N)NN)N)N)F)F)rN)r)rN)F)r2)NN)N)?rZr[r\r]r} ServerSpecr r+boolrrTrtr=rrYKeyryrr|disconnect_allrr#rrr r set_multirr,rrrrrr get_multir rrrr delete_multirrrrrrr rrrrrrrrrrrrrrr%r%r%r&r_snb a7  #   ( ( % # ! $          + ?  [ -r_c@seZdZdZeZdddddddedddddddddfeedd d Z e e d d d Z edddZ ddddZeZdPeeeeedddZdQeeeeedddZeZdReeeeedddZdSeeeeedddZdTeeeeedddZdUeeeddd ZdVe eed!d"d#Zee ee efd$d%d&ZeZe eeefd d'd(Z ee ee eeeffd$d)d*Z!dWe eeed+d,d-Z"dXee eeed.d/d0Z#e#Z$dYe eeeeed1d2d3Z%dZe d4d5d6Z&d[e d4d7d8Z'd\e ed9d:d;Z(dd?Z*d]edd@dAZ+dddBdCZ,d^eddDdEdFZ-d_dHdIZ.e d4dJdKZ/dLdMZ0dNdOZ1dS)` PooledClientaA thread-safe pool of clients (with the same client api). Args: max_pool_size: maximum pool size to use (going above this amount triggers a runtime error), by default this is 2147483648L when not provided (or none). pool_idle_timeout: pooled connections are discarded if they have been unused for this many seconds. A value of 0 indicates that pooled connections are never discarded. lock_generator: a callback/type that takes no arguments that will be called to create a lock or semaphore that can protect the pool from concurrent access (for example a eventlet lock or semaphore could be used instead) Further arguments are interpreted as for :py:class:`.Client` constructor. Note: if `serde` is given, the same object will be used for *all* clients in the pool. Your serde object must therefore be thread-safe. NFr2rTr8)rErfcCst||_|pt|||_||_||_||_||_| |_| |_ ||_ ||_ t | t r^| d} t | tsptd| |_tj|jdd| | |d|_||_||_dS)Nr8rjcSs|Sr)r|)clientr%r%r&br2z'PooledClient.__init__..)Z after_removemax_sizeZ idle_timeoutlock_generator)rSrErrkr`rarbrcrdrerfr4r<r=r>rtrur5r Z ObjectPool_create_client client_poolrgrh)rXrErkrvrwr`rarbrcrdrer5Z max_pool_sizeZpool_idle_timeoutr%rfr4rgrhr%r%r&rY<s0    zPooledClient.__init__)r3r!cCst||j|jdSrx)rDr4r5rr%r%r&ryjs zPooledClient.check_keyrzcCs8|j|j|j|j|j|jd|j|j|j|j |j |j d S)NF) rkr`rarbrcrdrer5rfr4rh) client_classrErkr`rarbrdrer5rfr4rhrr%r%r&r&pszPooledClient._create_clientcCs|jdSr)r'clearrr%r%r&r|szPooledClient.closerc Cs:|jjdd"}|j|||||dW5QRSQRXdSNTZdestroy_on_failr)r'get_and_releaserrXr3r rrrr"r%r%r&rszPooledClient.setc Cs8|jjdd }|j||||dW5QRSQRXdSr*)r'r,r)rXrrrrr"r%r%r&rszPooledClient.set_manyc Cs:|jjdd"}|j|||||dW5QRSQRXdSr*)r'r,r,r-r%r%r&r,szPooledClient.replacec Cs:|jjdd"}|j|||||dW5QRSQRXdSr*)r'r,rr-r%r%r&rszPooledClient.appendc Cs:|jjdd"}|j|||||dW5QRSQRXdSr*)r'r,rr-r%r%r&rszPooledClient.prepend)rrc Cs<|jjdd$}|j||||||dW5QRSQRXdSr*)r'r,r)rXr3r rrrrr"r%r%r&rs zPooledClient.casrc Csj|jjddR}z|||WW5QRStk rZ|jrT|YW5QRSYnXW5QRXdSNTr+)r'r,rrrc)rXr3rr"r%r%r&rszPooledClient.getrc Csh|jjddP}z||WW5QRStk rX|jrRiYW5QRSYnXW5QRXdSr.)r'r,rrrcrXrr"r%r%r&rszPooledClient.get_manyc Csd|jjddL}z||WW5QRStk rT|jrNYW5QRdSYnXW5QRXdS)NTr+)NN)r'r,rrrc)rXr3r"r%r%r&rszPooledClient.getsc Csh|jjddP}z||WW5QRStk rX|jrRiYW5QRSYnXW5QRXdSr.)r'r,rrrcr/r%r%r&rszPooledClient.gets_manyrc Cs4|jjdd}|j||dW5QRSQRXdSNTr+r)r'r,r)rXr3rr"r%r%r&rszPooledClient.deleterc Cs4|jjdd}|j||dW5QRSQRXdSr0)r'r,r)rXrrr"r%r%r&rszPooledClient.delete_many)r3rrrc Cs:|jjdd"}|j|||||dW5QRSQRXdSr*)r'r,rr-r%r%r&rszPooledClient.addr c Cs6|jjdd}|j|||dW5QRSQRXdSr0)r'r,rrXr3r rr"r%r%r&rszPooledClient.incrc Cs6|jjdd}|j|||dW5QRSQRXdSr0)r'r,rr1r%r%r&rszPooledClient.decr)r3rc Cs6|jjdd}|j|||dW5QRSQRXdS)NTr+)rr)r'r,r)rXr3rrr"r%r%r&rszPooledClient.touchc Gsh|jjddP}z|j|WW5QRStk rX|jrRiYW5QRSYnXW5QRXdSr.)r'r,rrrc)rXrr"r%r%r&rszPooledClient.statsc Cs.|jjdd}|W5QRSQRXdSr.)r'r,rrXr"r%r%r&r(szPooledClient.versionc Cs4|jjdd}|j||dW5QRSQRXdS)NTr+)rr)r'r,r)rXrrr"r%r%r&r,szPooledClient.flush_allc Cs:|jjdd"}z |W5|j|XW5QRXdSr.)r'r,destroyrr2r%r%r&r0s zPooledClient.quitrc Cs(|jjdd}||W5QRXdSr.)r'r,r)rXrr"r%r%r&r7szPooledClient.shutdownrc Cs2|jjdd}|||W5QRSQRXdSr.)r'r,r)rXrrr"r%r%r&r;szPooledClient.raw_commandcCs|j||dddSrrrr%r%r&r?szPooledClient.__setitem__cCs||}|dkrt|Srrrr%r%r&rBs zPooledClient.__getitem__cCs|j|dddSrrrr%r%r&rHszPooledClient.__delitem__)rNN)rNN)rNN)rNN)rNN)rFN)N)N)N)rNN)F)F)rN)rN)F)r)2rZr[r\r]r_r(r}rrrYrrtryr&r|rr#r rrrr,rrrrrrrrrr rrrrr rrrrrrrrrrrrrr%r%r%r&r!$s .         $    r!)rsrr!cCsg}d}|dkrJ|dddkrJ|ddd|d<|ddd|fS|d}|dkr|d|||d d}}|||d|fS|r|||dd}t|t}|stqdS) aRead line of text from the socket. Read a line of text (delimited by " ") from the socket, and return that line along with any trailing characters read from the socket. Args: sock: Socket object, should be connected. buf: Bytes, zero or more characters, returned from an earlier call to _readline or _readvalue (pass an empty byte string on the first call). Returns: A tuple of (buf, line) where line is the full line read from the socket (minus the " " characters) and buf is any trailing characters read after the " " was found (which may be an empty byte string). r2 rr: Nrr)rqrr_recv RECV_SIZEr)rsrchunks last_charZ token_posrrr%r%r&rLs       r)rsrrcCsg}|d}|t|dkrL|r6|t|8}||t|t}|s tq |dkrj|ddd|d<n||d|d||dd|fS)aRead specified amount of bytes from the socket. Read size bytes, followed by the " " characters, from the socket, and return those bytes and any trailing bytes read after the " ". Args: sock: Socket object, should be connected. buf: String, zero or more characters, returned from an earlier call to _readline or _readvalue (pass an empty string on the first call). size: Integer, number of bytes to read from the socket. Returns: A tuple of (buf, value) where value is the bytes read from the socket (there will be exactly size bytes) and buf is trailing characters read after the " " following the bytes (but not including the ). rrr:r6Nr2)rBrr7r8rrq)rsrrr9Zrlenr%r%r&rs   r)rsrrr!cCsdt}||}|dkrJ|d|||t|d}}||7}||fSt|t}|stqdS)aRead a segment from the socket. Read a segment from the socket, up to the first end_token sub-string/bytes, and return that segment. Args: sock: Socket object, should be connected. buf: bytes, zero or more bytes, returned from an earlier call to _readline, _readsegment or _readvalue (pass an empty byte-string on the first call). end_tokens: bytes, indicates the end of the segment, generally this is b"\r\n" for memcached. Returns: A tuple of (buf, line) where line is the full line read from the socket (minus the end_tokens bytes) and buf is any trailing characters read after the end_tokens was found (which may be an empty bytes object). r6N)rtrrBr7r8r)rsrrrZ tokens_posrrr%r%r&r s " r )rsrr!c CsDz ||WStk r<}z|jtjkr,W5d}~XYqXqdS)zsock.recv() with retry on EINTRN)recvOSErrorerrnoZEINTR)rsrrr%r%r&r7s   r7)r2)7r=rlr} functoolsrsslrtypesrtypingrrrrr r r r Z pymemcacher Zpymemcache.exceptionsrrrrrrZpymemcache.serderr8rrnrr=r#rrtrrr'r(r+r-r/r1__annotations__rDrSrTr_r!rrr r7r%r%r%r&s   (        z*3. &