| Current File : //kunden/usr/share/gems/doc/memcache-client-1.8.5/rdoc/MemCache.html |
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>class MemCache - memcache-client-1.8.5 Documentation</title>
<script type="text/javascript">
var rdoc_rel_prefix = "./";
var index_rel_prefix = "./";
</script>
<script src="./js/navigation.js" defer></script>
<script src="./js/search.js" defer></script>
<script src="./js/search_index.js" defer></script>
<script src="./js/searcher.js" defer></script>
<script src="./js/darkfish.js" defer></script>
<link href="./css/fonts.css" rel="stylesheet">
<link href="./css/rdoc.css" rel="stylesheet">
<body id="top" role="document" class="class">
<nav role="navigation">
<div id="project-navigation">
<div id="home-section" role="region" title="Quick navigation" class="nav-section">
<h2>
<a href="./index.html" rel="home">Home</a>
</h2>
<div id="table-of-contents-navigation">
<a href="./table_of_contents.html#pages">Pages</a>
<a href="./table_of_contents.html#classes">Classes</a>
<a href="./table_of_contents.html#methods">Methods</a>
</div>
</div>
<div id="search-section" role="search" class="project-section initially-hidden">
<form action="#" method="get" accept-charset="utf-8">
<div id="search-field-wrapper">
<input id="search-field" role="combobox" aria-label="Search"
aria-autocomplete="list" aria-controls="search-results"
type="text" name="search" placeholder="Search" spellcheck="false"
title="Type to search, Up and Down to navigate, Enter to load">
</div>
<ul id="search-results" aria-label="Search Results"
aria-busy="false" aria-expanded="false"
aria-atomic="false" class="initially-hidden"></ul>
</form>
</div>
</div>
<div id="class-metadata">
<div id="parent-class-section" class="nav-section">
<h3>Parent</h3>
<p class="link"><a href="Object.html">Object</a>
</div>
<!-- Method Quickref -->
<div id="method-list-section" class="nav-section">
<h3>Methods</h3>
<ul class="link-list" role="directory">
<li ><a href="#method-c-new">::new</a>
<li ><a href="#method-i-5B-5D">#[]</a>
<li ><a href="#method-i-5B-5D-3D">#[]=</a>
<li ><a href="#method-i-active-3F">#active?</a>
<li ><a href="#method-i-add">#add</a>
<li ><a href="#method-i-append">#append</a>
<li ><a href="#method-i-cache_decr">#cache_decr</a>
<li ><a href="#method-i-cache_get">#cache_get</a>
<li ><a href="#method-i-cache_get_multi">#cache_get_multi</a>
<li ><a href="#method-i-cache_incr">#cache_incr</a>
<li ><a href="#method-i-cas">#cas</a>
<li ><a href="#method-i-check_multithread_status-21">#check_multithread_status!</a>
<li ><a href="#method-i-create_continuum_for">#create_continuum_for</a>
<li ><a href="#method-i-decr">#decr</a>
<li ><a href="#method-i-delete">#delete</a>
<li ><a href="#method-i-entry_count_for">#entry_count_for</a>
<li ><a href="#method-i-fetch">#fetch</a>
<li ><a href="#method-i-flush_all">#flush_all</a>
<li ><a href="#method-i-get">#get</a>
<li ><a href="#method-i-get_multi">#get_multi</a>
<li ><a href="#method-i-get_server_for_key">#get_server_for_key</a>
<li ><a href="#method-i-gets">#gets</a>
<li ><a href="#method-i-handle_error">#handle_error</a>
<li ><a href="#method-i-hash_for">#hash_for</a>
<li ><a href="#method-i-incr">#incr</a>
<li ><a href="#method-i-inspect">#inspect</a>
<li ><a href="#method-i-key_length">#key_length</a>
<li ><a href="#method-i-make_cache_key">#make_cache_key</a>
<li ><a href="#method-i-noreply">#noreply</a>
<li ><a href="#method-i-prepend">#prepend</a>
<li ><a href="#method-i-raise_on_error_response-21">#raise_on_error_response!</a>
<li ><a href="#method-i-readonly-3F">#readonly?</a>
<li ><a href="#method-i-replace">#replace</a>
<li ><a href="#method-i-request_setup">#request_setup</a>
<li ><a href="#method-i-reset">#reset</a>
<li ><a href="#method-i-servers-3D">#servers=</a>
<li ><a href="#method-i-set">#set</a>
<li ><a href="#method-i-stats">#stats</a>
<li ><a href="#method-i-with_server">#with_server</a>
<li ><a href="#method-i-with_socket_management">#with_socket_management</a>
</ul>
</div>
</div>
</nav>
<main role="main" aria-labelledby="class-MemCache">
<h1 id="class-MemCache" class="class">
class MemCache
</h1>
<section class="description">
<p>A Ruby client library for memcached.</p>
</section>
<section id="5Buntitled-5D" class="documentation-section">
<section class="constants-list">
<header>
<h3>Constants</h3>
</header>
<dl>
<dt id="DEFAULT_OPTIONS">DEFAULT_OPTIONS
<dd><p>Default options for the cache object.</p>
<dt id="DEFAULT_PORT">DEFAULT_PORT
<dd><p>Default memcached port.</p>
<dt id="DEFAULT_WEIGHT">DEFAULT_WEIGHT
<dd><p>Default memcached server weight.</p>
<dt id="ONE_MB">ONE_MB
<dd><p>Add <code>key</code> to the cache with value <code>value</code> that expires in <code>expiry</code> seconds. If <code>raw</code> is true, <code>value</code> will not be Marshalled.</p>
<p>Warning: Readers should not call this method in the event of a cache miss; see <a href="MemCache.html#method-i-add"><code>MemCache#add</code></a>.</p>
<dt id="VERSION">VERSION
<dd><p>The version of <a href="MemCache.html"><code>MemCache</code></a> you are using.</p>
</dl>
</section>
<section class="attribute-method-details" class="method-section">
<header>
<h3>Attributes</h3>
</header>
<div id="attribute-i-autofix_keys" class="method-detail">
<div class="method-heading attribute-method-heading">
<span class="method-name">autofix_keys</span><span
class="attribute-access-type">[R]</span>
</div>
<div class="method-description">
<p>Whether to try to fix keys that are too long and will be truncated by using their SHA1 hash instead. The hash is only used on keys longer than 250 characters, or containing spaces, to avoid impacting performance unnecesarily.</p>
<p>In theory, your code should generate correct keys when calling memcache, so it's your responsibility and you should try to fix this problem at its source.</p>
<p>But if that's not possible, enable this option and memcache-client will give you a hand.</p>
</div>
</div>
<div id="attribute-i-failover" class="method-detail">
<div class="method-heading attribute-method-heading">
<span class="method-name">failover</span><span
class="attribute-access-type">[R]</span>
</div>
<div class="method-description">
<p>Should the client try to failover to another server if the first server is down? Defaults to true.</p>
</div>
</div>
<div id="attribute-i-logger" class="method-detail">
<div class="method-heading attribute-method-heading">
<span class="method-name">logger</span><span
class="attribute-access-type">[R]</span>
</div>
<div class="method-description">
<p>Log debug/info/warn/error to the given Logger, defaults to nil.</p>
</div>
</div>
<div id="attribute-i-multithread" class="method-detail">
<div class="method-heading attribute-method-heading">
<span class="method-name">multithread</span><span
class="attribute-access-type">[R]</span>
</div>
<div class="method-description">
<p>The multithread setting for this instance</p>
</div>
</div>
<div id="attribute-i-namespace" class="method-detail">
<div class="method-heading attribute-method-heading">
<span class="method-name">namespace</span><span
class="attribute-access-type">[R]</span>
</div>
<div class="method-description">
<p>The namespace for this instance</p>
</div>
</div>
<div id="attribute-i-no_reply" class="method-detail">
<div class="method-heading attribute-method-heading">
<span class="method-name">no_reply</span><span
class="attribute-access-type">[R]</span>
</div>
<div class="method-description">
<p>Don't send or look for a reply from the memcached server for write operations. Please note this feature only works in memcached 1.2.5 and later. Earlier versions will reply with “ERROR”.</p>
</div>
</div>
<div id="attribute-i-servers" class="method-detail">
<div class="method-heading attribute-method-heading">
<span class="method-name">servers</span><span
class="attribute-access-type">[R]</span>
</div>
<div class="method-description">
<p>The servers this client talks to. Play at your own peril.</p>
</div>
</div>
<div id="attribute-i-timeout" class="method-detail">
<div class="method-heading attribute-method-heading">
<span class="method-name">timeout</span><span
class="attribute-access-type">[R]</span>
</div>
<div class="method-description">
<p>Socket timeout limit with this client, defaults to 0.5 sec. Set to nil to disable timeouts.</p>
</div>
</div>
</section>
<section id="public-class-5Buntitled-5D-method-details" class="method-section">
<header>
<h3>Public Class Methods</h3>
</header>
<div id="method-c-new" class="method-detail ">
<div class="method-heading">
<span class="method-name">new</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Accepts a list of <code>servers</code> and a list of <code>opts</code>. <code>servers</code> may be omitted. See <code>servers=</code> for acceptable server list arguments.</p>
<p>Valid options for <code>opts</code> are:</p>
<pre>[:namespace] Prepends this value to all keys added or retrieved.
[:readonly] Raises an exception on cache writes when true.
[:multithread] Wraps cache access in a Mutex for thread safety. Defaults to true.
[:failover] Should the client try to failover to another server if the
first server is down? Defaults to true.
[:timeout] Time to use as the socket read timeout. Defaults to 0.5 sec,
set to nil to disable timeouts.
[:logger] Logger to use for info/debug output, defaults to nil
[:no_reply] Don't bother looking for a reply for write operations (i.e. they
become 'fire and forget'), memcached 1.2.5 and later only, speeds up
set/add/delete/incr/decr significantly.
[:check_size] Raises a MemCacheError if the value to be set is greater than 1 MB, which
is the maximum key size for the standard memcached server. Defaults to true.
[:autofix_keys] If a key is longer than 250 characters or contains spaces,
use an SHA1 hash instead, to prevent collisions on truncated keys.</pre>
<p>Other options are ignored.</p>
<div class="method-source-code" id="new-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 136</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">initialize</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-identifier">servers</span> = []
<span class="ruby-identifier">opts</span> = {}
<span class="ruby-keyword">case</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">length</span>
<span class="ruby-keyword">when</span> <span class="ruby-value">0</span> <span class="ruby-keyword">then</span> <span class="ruby-comment"># NOP</span>
<span class="ruby-keyword">when</span> <span class="ruby-value">1</span> <span class="ruby-keyword">then</span>
<span class="ruby-identifier">arg</span> = <span class="ruby-identifier">args</span>.<span class="ruby-identifier">shift</span>
<span class="ruby-keyword">case</span> <span class="ruby-identifier">arg</span>
<span class="ruby-keyword">when</span> <span class="ruby-constant">Hash</span> <span class="ruby-keyword">then</span> <span class="ruby-identifier">opts</span> = <span class="ruby-identifier">arg</span>
<span class="ruby-keyword">when</span> <span class="ruby-constant">Array</span> <span class="ruby-keyword">then</span> <span class="ruby-identifier">servers</span> = <span class="ruby-identifier">arg</span>
<span class="ruby-keyword">when</span> <span class="ruby-constant">String</span> <span class="ruby-keyword">then</span> <span class="ruby-identifier">servers</span> = [<span class="ruby-identifier">arg</span>]
<span class="ruby-keyword">else</span> <span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>, <span class="ruby-string">'first argument must be Array, Hash or String'</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">when</span> <span class="ruby-value">2</span> <span class="ruby-keyword">then</span>
<span class="ruby-identifier">servers</span>, <span class="ruby-identifier">opts</span> = <span class="ruby-identifier">args</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>, <span class="ruby-node">"wrong number of arguments (#{args.length} for 2)"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-ivar">@evented</span> = <span class="ruby-keyword">defined?</span>(<span class="ruby-constant">EM</span>) <span class="ruby-operator">&&</span> <span class="ruby-constant">EM</span>.<span class="ruby-identifier">reactor_running?</span>
<span class="ruby-identifier">opts</span> = <span class="ruby-constant">DEFAULT_OPTIONS</span>.<span class="ruby-identifier">merge</span> <span class="ruby-identifier">opts</span>
<span class="ruby-ivar">@namespace</span> = <span class="ruby-identifier">opts</span>[<span class="ruby-value">:namespace</span>]
<span class="ruby-ivar">@readonly</span> = <span class="ruby-identifier">opts</span>[<span class="ruby-value">:readonly</span>]
<span class="ruby-ivar">@multithread</span> = <span class="ruby-identifier">opts</span>[<span class="ruby-value">:multithread</span>] <span class="ruby-operator">&&</span> <span class="ruby-operator">!</span><span class="ruby-ivar">@evented</span>
<span class="ruby-ivar">@autofix_keys</span> = <span class="ruby-identifier">opts</span>[<span class="ruby-value">:autofix_keys</span>]
<span class="ruby-ivar">@timeout</span> = <span class="ruby-identifier">opts</span>[<span class="ruby-value">:timeout</span>]
<span class="ruby-ivar">@failover</span> = <span class="ruby-identifier">opts</span>[<span class="ruby-value">:failover</span>]
<span class="ruby-ivar">@logger</span> = <span class="ruby-identifier">opts</span>[<span class="ruby-value">:logger</span>]
<span class="ruby-ivar">@no_reply</span> = <span class="ruby-identifier">opts</span>[<span class="ruby-value">:no_reply</span>]
<span class="ruby-ivar">@check_size</span> = <span class="ruby-identifier">opts</span>[<span class="ruby-value">:check_size</span>]
<span class="ruby-ivar">@namespace_separator</span> = <span class="ruby-identifier">opts</span>[<span class="ruby-value">:namespace_separator</span>]
<span class="ruby-ivar">@mutex</span> = <span class="ruby-constant">Mutex</span>.<span class="ruby-identifier">new</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@multithread</span>
<span class="ruby-identifier">logger</span>.<span class="ruby-identifier">info</span> { <span class="ruby-node">"memcache-client #{VERSION} #{Array(servers).inspect}"</span> } <span class="ruby-keyword">if</span> <span class="ruby-identifier">logger</span>
<span class="ruby-constant">Thread</span>.<span class="ruby-identifier">current</span>[<span class="ruby-value">:memcache_client</span>] = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">object_id</span> <span class="ruby-keyword">if</span> <span class="ruby-operator">!</span><span class="ruby-ivar">@multithread</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">servers</span> = <span class="ruby-identifier">servers</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
</section>
<section id="public-instance-5Buntitled-5D-method-details" class="method-section">
<header>
<h3>Public Instance Methods</h3>
</header>
<div id="method-i-5B-5D" class="method-detail method-alias">
<div class="method-heading">
<span class="method-name">[]</span><span
class="method-args">(key, raw = false)</span>
</div>
<div class="method-description">
<p>Shortcut to get a value from the cache.</p>
</div>
<div class="aliases">
Alias for: <a href="MemCache.html#method-i-get">get</a>
</div>
</div>
<div id="method-i-5B-5D-3D" class="method-detail ">
<div class="method-heading">
<span class="method-name">[]=</span><span
class="method-args">(key, value)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Shortcut to save a value in the cache. This method does not set an expiration on the entry. Use set to specify an explicit expiry.</p>
<div class="method-source-code" id="5B-5D-3D-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 659</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">[]=</span>(<span class="ruby-identifier">key</span>, <span class="ruby-identifier">value</span>)
<span class="ruby-identifier">set</span> <span class="ruby-identifier">key</span>, <span class="ruby-identifier">value</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-active-3F" class="method-detail ">
<div class="method-heading">
<span class="method-name">active?</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns whether there is at least one active server for the object.</p>
<div class="method-source-code" id="active-3F-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 189</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">active?</span>
<span class="ruby-keyword">not</span> <span class="ruby-ivar">@servers</span>.<span class="ruby-identifier">empty?</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-add" class="method-detail ">
<div class="method-heading">
<span class="method-name">add</span><span
class="method-args">(key, value, expiry = 0, raw = false)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Add <code>key</code> to the cache with value <code>value</code> that expires in <code>expiry</code> seconds, but only if <code>key</code> does not already exist in the cache. If <code>raw</code> is true, <code>value</code> will not be Marshalled.</p>
<p>Readers should call this method in the event of a cache miss, not <a href="MemCache.html#method-i-set"><code>MemCache#set</code></a>.</p>
<div class="method-source-code" id="add-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 438</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">add</span>(<span class="ruby-identifier">key</span>, <span class="ruby-identifier">value</span>, <span class="ruby-identifier">expiry</span> = <span class="ruby-value">0</span>, <span class="ruby-identifier">raw</span> = <span class="ruby-keyword">false</span>)
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-string">"Update of readonly cache"</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@readonly</span>
<span class="ruby-identifier">value</span> = <span class="ruby-constant">Marshal</span>.<span class="ruby-identifier">dump</span> <span class="ruby-identifier">value</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">raw</span>
<span class="ruby-identifier">with_server</span>(<span class="ruby-identifier">key</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">logger</span>.<span class="ruby-identifier">debug</span> { <span class="ruby-node">"add #{key} to #{server}: #{value ? value.to_s.size : 'nil'}"</span> } <span class="ruby-keyword">if</span> <span class="ruby-identifier">logger</span>
<span class="ruby-identifier">command</span> = <span class="ruby-node">"add #{cache_key} 0 #{expiry} #{value.to_s.size}#{noreply}\r\n#{value}\r\n"</span>
<span class="ruby-identifier">with_socket_management</span>(<span class="ruby-identifier">server</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">socket</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">socket</span>.<span class="ruby-identifier">write</span> <span class="ruby-identifier">command</span>
<span class="ruby-keyword">break</span> <span class="ruby-keyword">nil</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@no_reply</span>
<span class="ruby-identifier">result</span> = <span class="ruby-identifier">socket</span>.<span class="ruby-identifier">gets</span>
<span class="ruby-identifier">raise_on_error_response!</span> <span class="ruby-identifier">result</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-append" class="method-detail ">
<div class="method-heading">
<span class="method-name">append</span><span
class="method-args">(key, value)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Append - 'add this data to an existing key after existing data' Please note the value is always passed to memcached as raw since it doesn't make a lot of sense to concatenate marshalled data together.</p>
<div class="method-source-code" id="append-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 480</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">append</span>(<span class="ruby-identifier">key</span>, <span class="ruby-identifier">value</span>)
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-string">"Update of readonly cache"</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@readonly</span>
<span class="ruby-identifier">with_server</span>(<span class="ruby-identifier">key</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">logger</span>.<span class="ruby-identifier">debug</span> { <span class="ruby-node">"append #{key} to #{server}: #{value ? value.to_s.size : 'nil'}"</span> } <span class="ruby-keyword">if</span> <span class="ruby-identifier">logger</span>
<span class="ruby-identifier">command</span> = <span class="ruby-node">"append #{cache_key} 0 0 #{value.to_s.size}#{noreply}\r\n#{value}\r\n"</span>
<span class="ruby-identifier">with_socket_management</span>(<span class="ruby-identifier">server</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">socket</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">socket</span>.<span class="ruby-identifier">write</span> <span class="ruby-identifier">command</span>
<span class="ruby-keyword">break</span> <span class="ruby-keyword">nil</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@no_reply</span>
<span class="ruby-identifier">result</span> = <span class="ruby-identifier">socket</span>.<span class="ruby-identifier">gets</span>
<span class="ruby-identifier">raise_on_error_response!</span> <span class="ruby-identifier">result</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-cas" class="method-detail ">
<div class="method-heading">
<span class="method-name">cas</span><span
class="method-args">(key, expiry=0, raw=false) { |value| ... }</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>“cas” is a check and set operation which means “store this data but only if no one else has updated since I last fetched it.” This can be used as a form of optimistic locking.</p>
<p>Works in block form like so:</p>
<pre class="ruby"><span class="ruby-identifier">cache</span>.<span class="ruby-identifier">cas</span>(<span class="ruby-string">'some-key'</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">value</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">value</span> <span class="ruby-operator">+</span> <span class="ruby-value">1</span>
<span class="ruby-keyword">end</span>
</pre>
<p>Returns: <code>nil</code> if the value was not found on the memcached server. <code>STORED</code> if the value was updated successfully <code>EXISTS</code> if the value was updated by someone else since last fetch</p>
<div class="method-source-code" id="cas-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 401</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">cas</span>(<span class="ruby-identifier">key</span>, <span class="ruby-identifier">expiry</span>=<span class="ruby-value">0</span>, <span class="ruby-identifier">raw</span>=<span class="ruby-keyword">false</span>)
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-string">"Update of readonly cache"</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@readonly</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-string">"A block is required"</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">block_given?</span>
(<span class="ruby-identifier">value</span>, <span class="ruby-identifier">token</span>) = <span class="ruby-identifier">gets</span>(<span class="ruby-identifier">key</span>, <span class="ruby-identifier">raw</span>)
<span class="ruby-keyword">return</span> <span class="ruby-keyword">nil</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">value</span>
<span class="ruby-identifier">updated</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">value</span>
<span class="ruby-identifier">value</span> = <span class="ruby-identifier">raw</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">updated</span> <span class="ruby-operator">:</span> <span class="ruby-constant">Marshal</span>.<span class="ruby-identifier">dump</span>(<span class="ruby-identifier">updated</span>)
<span class="ruby-identifier">with_server</span>(<span class="ruby-identifier">key</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">logger</span>.<span class="ruby-identifier">debug</span> { <span class="ruby-node">"cas #{key} to #{server.inspect}: #{value.to_s.size}"</span> } <span class="ruby-keyword">if</span> <span class="ruby-identifier">logger</span>
<span class="ruby-identifier">command</span> = <span class="ruby-node">"cas #{cache_key} 0 #{expiry} #{value.to_s.size} #{token}#{noreply}\r\n#{value}\r\n"</span>
<span class="ruby-identifier">with_socket_management</span>(<span class="ruby-identifier">server</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">socket</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">socket</span>.<span class="ruby-identifier">write</span> <span class="ruby-identifier">command</span>
<span class="ruby-keyword">break</span> <span class="ruby-keyword">nil</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@no_reply</span>
<span class="ruby-identifier">result</span> = <span class="ruby-identifier">socket</span>.<span class="ruby-identifier">gets</span>
<span class="ruby-identifier">raise_on_error_response!</span> <span class="ruby-identifier">result</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">result</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-identifier">server</span>.<span class="ruby-identifier">close</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-node">"lost connection to #{server.host}:#{server.port}"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-decr" class="method-detail ">
<div class="method-heading">
<span class="method-name">decr</span><span
class="method-args">(key, amount = 1)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Decrements the value for <code>key</code> by <code>amount</code> and returns the new value. <code>key</code> must already exist. If <code>key</code> is not an integer, it is assumed to be</p>
<ol><li>
<p><code>key</code> can not be decremented below 0.</p>
</li></ol>
<div class="method-source-code" id="decr-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 232</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">decr</span>(<span class="ruby-identifier">key</span>, <span class="ruby-identifier">amount</span> = <span class="ruby-value">1</span>)
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-string">"Update of readonly cache"</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@readonly</span>
<span class="ruby-identifier">with_server</span>(<span class="ruby-identifier">key</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">cache_decr</span> <span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span>, <span class="ruby-identifier">amount</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">rescue</span> <span class="ruby-constant">TypeError</span> <span class="ruby-operator">=></span> <span class="ruby-identifier">err</span>
<span class="ruby-identifier">handle_error</span> <span class="ruby-keyword">nil</span>, <span class="ruby-identifier">err</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-delete" class="method-detail ">
<div class="method-heading">
<span class="method-name">delete</span><span
class="method-args">(key, expiry = 0)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Removes <code>key</code> from the cache. <code>expiry</code> is ignored as it has been removed from the latest memcached version.</p>
<div class="method-source-code" id="delete-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 520</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">delete</span>(<span class="ruby-identifier">key</span>, <span class="ruby-identifier">expiry</span> = <span class="ruby-value">0</span>)
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-string">"Update of readonly cache"</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@readonly</span>
<span class="ruby-identifier">with_server</span>(<span class="ruby-identifier">key</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">with_socket_management</span>(<span class="ruby-identifier">server</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">socket</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">logger</span>.<span class="ruby-identifier">debug</span> { <span class="ruby-node">"delete #{cache_key} on #{server}"</span> } <span class="ruby-keyword">if</span> <span class="ruby-identifier">logger</span>
<span class="ruby-identifier">socket</span>.<span class="ruby-identifier">write</span> <span class="ruby-node">"delete #{cache_key}#{noreply}\r\n"</span>
<span class="ruby-keyword">break</span> <span class="ruby-keyword">nil</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@no_reply</span>
<span class="ruby-identifier">result</span> = <span class="ruby-identifier">socket</span>.<span class="ruby-identifier">gets</span>
<span class="ruby-identifier">raise_on_error_response!</span> <span class="ruby-identifier">result</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-fetch" class="method-detail ">
<div class="method-heading">
<span class="method-name">fetch</span><span
class="method-args">(key, expiry = 0, raw = false) { || ... }</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Performs a <code>get</code> with the given <code>key</code>. If the value does not exist and a block was given, the block will be called and the result saved via <code>add</code>.</p>
<p>If you do not provide a block, using this method is the same as using <code>get</code>.</p>
<div class="method-source-code" id="fetch-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 265</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">fetch</span>(<span class="ruby-identifier">key</span>, <span class="ruby-identifier">expiry</span> = <span class="ruby-value">0</span>, <span class="ruby-identifier">raw</span> = <span class="ruby-keyword">false</span>)
<span class="ruby-identifier">value</span> = <span class="ruby-identifier">get</span>(<span class="ruby-identifier">key</span>, <span class="ruby-identifier">raw</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">value</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-operator">&&</span> <span class="ruby-identifier">block_given?</span>
<span class="ruby-identifier">value</span> = <span class="ruby-keyword">yield</span>
<span class="ruby-identifier">add</span>(<span class="ruby-identifier">key</span>, <span class="ruby-identifier">value</span>, <span class="ruby-identifier">expiry</span>, <span class="ruby-identifier">raw</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">value</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-flush_all" class="method-detail ">
<div class="method-heading">
<span class="method-name">flush_all</span><span
class="method-args">(delay=0)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Flush the cache from all memcache servers. A non-zero value for <code>delay</code> will ensure that the flush is propogated slowly through your memcached server farm. The Nth server will be flushed N*delay seconds from now, asynchronously so this method returns quickly. This prevents a huge database spike due to a total flush all at once.</p>
<div class="method-source-code" id="flush_all-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 543</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">flush_all</span>(<span class="ruby-identifier">delay</span>=<span class="ruby-value">0</span>)
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-string">'No active servers'</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">active?</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-string">"Update of readonly cache"</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@readonly</span>
<span class="ruby-keyword">begin</span>
<span class="ruby-identifier">delay_time</span> = <span class="ruby-value">0</span>
<span class="ruby-ivar">@servers</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">server</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">with_socket_management</span>(<span class="ruby-identifier">server</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">socket</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">logger</span>.<span class="ruby-identifier">debug</span> { <span class="ruby-node">"flush_all #{delay_time} on #{server}"</span> } <span class="ruby-keyword">if</span> <span class="ruby-identifier">logger</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">delay</span> <span class="ruby-operator">==</span> <span class="ruby-value">0</span> <span class="ruby-comment"># older versions of memcached will fail silently otherwise</span>
<span class="ruby-identifier">socket</span>.<span class="ruby-identifier">write</span> <span class="ruby-node">"flush_all#{noreply}\r\n"</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">socket</span>.<span class="ruby-identifier">write</span> <span class="ruby-node">"flush_all #{delay_time}#{noreply}\r\n"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">break</span> <span class="ruby-keyword">nil</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@no_reply</span>
<span class="ruby-identifier">result</span> = <span class="ruby-identifier">socket</span>.<span class="ruby-identifier">gets</span>
<span class="ruby-identifier">raise_on_error_response!</span> <span class="ruby-identifier">result</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">delay_time</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">delay</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">rescue</span> <span class="ruby-constant">IndexError</span> <span class="ruby-operator">=></span> <span class="ruby-identifier">err</span>
<span class="ruby-identifier">handle_error</span> <span class="ruby-keyword">nil</span>, <span class="ruby-identifier">err</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-get" class="method-detail ">
<div class="method-heading">
<span class="method-name">get</span><span
class="method-args">(key, raw = false)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Retrieves <code>key</code> from memcache. If <code>raw</code> is false, the value will be unmarshalled.</p>
<div class="method-source-code" id="get-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 245</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">get</span>(<span class="ruby-identifier">key</span>, <span class="ruby-identifier">raw</span> = <span class="ruby-keyword">false</span>)
<span class="ruby-identifier">with_server</span>(<span class="ruby-identifier">key</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">logger</span>.<span class="ruby-identifier">debug</span> { <span class="ruby-node">"get #{key} from #{server.inspect}"</span> } <span class="ruby-keyword">if</span> <span class="ruby-identifier">logger</span>
<span class="ruby-identifier">value</span> = <span class="ruby-identifier">cache_get</span> <span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span>
<span class="ruby-keyword">return</span> <span class="ruby-keyword">nil</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">value</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-identifier">value</span> = <span class="ruby-constant">Marshal</span>.<span class="ruby-identifier">load</span> <span class="ruby-identifier">value</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">raw</span>
<span class="ruby-keyword">return</span> <span class="ruby-identifier">value</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">rescue</span> <span class="ruby-constant">TypeError</span> <span class="ruby-operator">=></span> <span class="ruby-identifier">err</span>
<span class="ruby-identifier">handle_error</span> <span class="ruby-keyword">nil</span>, <span class="ruby-identifier">err</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
<div class="aliases">
Also aliased as: <a href="MemCache.html#method-i-5B-5D">[]</a>
</div>
</div>
<div id="method-i-get_multi" class="method-detail ">
<div class="method-heading">
<span class="method-name">get_multi</span><span
class="method-args">(*keys)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Retrieves multiple values from memcached in parallel, if possible.</p>
<p>The memcached protocol supports the ability to retrieve multiple keys in a single request. Pass in an array of keys to this method and it will:</p>
<ol><li>
<p>map the key to the appropriate memcached server</p>
</li><li>
<p>send a single request to each server that has one or more key values</p>
</li></ol>
<p>Returns a hash of values.</p>
<pre class="ruby"><span class="ruby-identifier">cache</span>[<span class="ruby-string">"a"</span>] = <span class="ruby-value">1</span>
<span class="ruby-identifier">cache</span>[<span class="ruby-string">"b"</span>] = <span class="ruby-value">2</span>
<span class="ruby-identifier">cache</span>.<span class="ruby-identifier">get_multi</span> <span class="ruby-string">"a"</span>, <span class="ruby-string">"b"</span> <span class="ruby-comment"># => { "a" => 1, "b" => 2 }</span>
</pre>
<p>Note that <a href="MemCache.html#method-i-get_multi"><code>get_multi</code></a> assumes the values are marshalled. You can pass in :raw => true to bypass value marshalling.</p>
<pre>cache.get_multi('a', 'b', ..., :raw => true)</pre>
<div class="method-source-code" id="get_multi-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 297</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">get_multi</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">keys</span>)
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-string">'No active servers'</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">active?</span>
<span class="ruby-identifier">opts</span> = <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Hash</span>) <span class="ruby-operator">?</span> <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">pop</span> <span class="ruby-operator">:</span> {}
<span class="ruby-identifier">keys</span>.<span class="ruby-identifier">flatten!</span>
<span class="ruby-identifier">key_count</span> = <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">length</span>
<span class="ruby-identifier">cache_keys</span> = {}
<span class="ruby-identifier">server_keys</span> = <span class="ruby-constant">Hash</span>.<span class="ruby-identifier">new</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">h</span>,<span class="ruby-identifier">k</span><span class="ruby-operator">|</span> <span class="ruby-identifier">h</span>[<span class="ruby-identifier">k</span>] = [] }
<span class="ruby-comment"># map keys to servers</span>
<span class="ruby-identifier">keys</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">key</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span> = <span class="ruby-identifier">request_setup</span> <span class="ruby-identifier">key</span>
<span class="ruby-identifier">cache_keys</span>[<span class="ruby-identifier">cache_key</span>] = <span class="ruby-identifier">key</span>
<span class="ruby-identifier">server_keys</span>[<span class="ruby-identifier">server</span>] <span class="ruby-operator"><<</span> <span class="ruby-identifier">cache_key</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">results</span> = {}
<span class="ruby-identifier">raw</span> = <span class="ruby-identifier">opts</span>[<span class="ruby-value">:raw</span>] <span class="ruby-operator">||</span> <span class="ruby-keyword">false</span>
<span class="ruby-identifier">server_keys</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">server</span>, <span class="ruby-identifier">keys_for_server</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">keys_for_server_str</span> = <span class="ruby-identifier">keys_for_server</span>.<span class="ruby-identifier">join</span> <span class="ruby-string">' '</span>
<span class="ruby-keyword">begin</span>
<span class="ruby-identifier">values</span> = <span class="ruby-identifier">cache_get_multi</span> <span class="ruby-identifier">server</span>, <span class="ruby-identifier">keys_for_server_str</span>
<span class="ruby-identifier">values</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">key</span>, <span class="ruby-identifier">value</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">results</span>[<span class="ruby-identifier">cache_keys</span>[<span class="ruby-identifier">key</span>]] = <span class="ruby-identifier">raw</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">value</span> <span class="ruby-operator">:</span> <span class="ruby-constant">Marshal</span>.<span class="ruby-identifier">load</span>(<span class="ruby-identifier">value</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">rescue</span> <span class="ruby-constant">IndexError</span> <span class="ruby-operator">=></span> <span class="ruby-identifier">e</span>
<span class="ruby-comment"># Ignore this server and try the others</span>
<span class="ruby-identifier">logger</span>.<span class="ruby-identifier">warn</span> { <span class="ruby-node">"Unable to retrieve #{keys_for_server.size} elements from #{server.inspect}: #{e.message}"</span>} <span class="ruby-keyword">if</span> <span class="ruby-identifier">logger</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">return</span> <span class="ruby-identifier">results</span>
<span class="ruby-keyword">rescue</span> <span class="ruby-constant">TypeError</span> <span class="ruby-operator">=></span> <span class="ruby-identifier">err</span>
<span class="ruby-identifier">handle_error</span> <span class="ruby-keyword">nil</span>, <span class="ruby-identifier">err</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-incr" class="method-detail ">
<div class="method-heading">
<span class="method-name">incr</span><span
class="method-args">(key, amount = 1)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Increments the value for <code>key</code> by <code>amount</code> and returns the new value. <code>key</code> must already exist. If <code>key</code> is not an integer, it is assumed to be 0.</p>
<div class="method-source-code" id="incr-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 339</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">incr</span>(<span class="ruby-identifier">key</span>, <span class="ruby-identifier">amount</span> = <span class="ruby-value">1</span>)
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-string">"Update of readonly cache"</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@readonly</span>
<span class="ruby-identifier">with_server</span>(<span class="ruby-identifier">key</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">cache_incr</span> <span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span>, <span class="ruby-identifier">amount</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">rescue</span> <span class="ruby-constant">TypeError</span> <span class="ruby-operator">=></span> <span class="ruby-identifier">err</span>
<span class="ruby-identifier">handle_error</span> <span class="ruby-keyword">nil</span>, <span class="ruby-identifier">err</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-inspect" class="method-detail ">
<div class="method-heading">
<span class="method-name">inspect</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns a string representation of the cache object.</p>
<div class="method-source-code" id="inspect-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 181</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">inspect</span>
<span class="ruby-string">"<MemCache: %d servers, ns: %p, ro: %p>"</span> <span class="ruby-operator">%</span>
[<span class="ruby-ivar">@servers</span>.<span class="ruby-identifier">length</span>, <span class="ruby-ivar">@namespace</span>, <span class="ruby-ivar">@readonly</span>]
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-prepend" class="method-detail ">
<div class="method-heading">
<span class="method-name">prepend</span><span
class="method-args">(key, value)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Prepend - 'add this data to an existing key before existing data' Please note the value is always passed to memcached as raw since it doesn't make a lot of sense to concatenate marshalled data together.</p>
<div class="method-source-code" id="prepend-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 500</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">prepend</span>(<span class="ruby-identifier">key</span>, <span class="ruby-identifier">value</span>)
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-string">"Update of readonly cache"</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@readonly</span>
<span class="ruby-identifier">with_server</span>(<span class="ruby-identifier">key</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">logger</span>.<span class="ruby-identifier">debug</span> { <span class="ruby-node">"prepend #{key} to #{server}: #{value ? value.to_s.size : 'nil'}"</span> } <span class="ruby-keyword">if</span> <span class="ruby-identifier">logger</span>
<span class="ruby-identifier">command</span> = <span class="ruby-node">"prepend #{cache_key} 0 0 #{value.to_s.size}#{noreply}\r\n#{value}\r\n"</span>
<span class="ruby-identifier">with_socket_management</span>(<span class="ruby-identifier">server</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">socket</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">socket</span>.<span class="ruby-identifier">write</span> <span class="ruby-identifier">command</span>
<span class="ruby-keyword">break</span> <span class="ruby-keyword">nil</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@no_reply</span>
<span class="ruby-identifier">result</span> = <span class="ruby-identifier">socket</span>.<span class="ruby-identifier">gets</span>
<span class="ruby-identifier">raise_on_error_response!</span> <span class="ruby-identifier">result</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-readonly-3F" class="method-detail ">
<div class="method-heading">
<span class="method-name">readonly?</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns whether or not the cache object was created read only.</p>
<div class="method-source-code" id="readonly-3F-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 196</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">readonly?</span>
<span class="ruby-ivar">@readonly</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-replace" class="method-detail ">
<div class="method-heading">
<span class="method-name">replace</span><span
class="method-args">(key, value, expiry = 0, raw = false)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Add <code>key</code> to the cache with value <code>value</code> that expires in <code>expiry</code> seconds, but only if <code>key</code> already exists in the cache. If <code>raw</code> is true, <code>value</code> will not be Marshalled.</p>
<div class="method-source-code" id="replace-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 459</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">replace</span>(<span class="ruby-identifier">key</span>, <span class="ruby-identifier">value</span>, <span class="ruby-identifier">expiry</span> = <span class="ruby-value">0</span>, <span class="ruby-identifier">raw</span> = <span class="ruby-keyword">false</span>)
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-string">"Update of readonly cache"</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@readonly</span>
<span class="ruby-identifier">value</span> = <span class="ruby-constant">Marshal</span>.<span class="ruby-identifier">dump</span> <span class="ruby-identifier">value</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">raw</span>
<span class="ruby-identifier">with_server</span>(<span class="ruby-identifier">key</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">logger</span>.<span class="ruby-identifier">debug</span> { <span class="ruby-node">"replace #{key} to #{server}: #{value ? value.to_s.size : 'nil'}"</span> } <span class="ruby-keyword">if</span> <span class="ruby-identifier">logger</span>
<span class="ruby-identifier">command</span> = <span class="ruby-node">"replace #{cache_key} 0 #{expiry} #{value.to_s.size}#{noreply}\r\n#{value}\r\n"</span>
<span class="ruby-identifier">with_socket_management</span>(<span class="ruby-identifier">server</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">socket</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">socket</span>.<span class="ruby-identifier">write</span> <span class="ruby-identifier">command</span>
<span class="ruby-keyword">break</span> <span class="ruby-keyword">nil</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@no_reply</span>
<span class="ruby-identifier">result</span> = <span class="ruby-identifier">socket</span>.<span class="ruby-identifier">gets</span>
<span class="ruby-identifier">raise_on_error_response!</span> <span class="ruby-identifier">result</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-reset" class="method-detail ">
<div class="method-heading">
<span class="method-name">reset</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Reset the connection to all memcache servers. This should be called if there is a problem with a cache lookup that might have left the connection in a corrupted state.</p>
<div class="method-source-code" id="reset-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 574</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">reset</span>
<span class="ruby-ivar">@servers</span>.<span class="ruby-identifier">each</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">server</span><span class="ruby-operator">|</span> <span class="ruby-identifier">server</span>.<span class="ruby-identifier">close</span> }
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-servers-3D" class="method-detail ">
<div class="method-heading">
<span class="method-name">servers=</span><span
class="method-args">(servers)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Set the servers that the requests will be distributed between. Entries can be either strings of the form “hostname:port” or “hostname:port:weight” or <a href="MemCache/Server.html"><code>MemCache::Server</code></a> objects.</p>
<div class="method-source-code" id="servers-3D-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 205</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">servers=</span>(<span class="ruby-identifier">servers</span>)
<span class="ruby-comment"># Create the server objects.</span>
<span class="ruby-ivar">@servers</span> = <span class="ruby-constant">Array</span>(<span class="ruby-identifier">servers</span>).<span class="ruby-identifier">collect</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">server</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">case</span> <span class="ruby-identifier">server</span>
<span class="ruby-keyword">when</span> <span class="ruby-constant">String</span>
<span class="ruby-identifier">host</span>, <span class="ruby-identifier">port</span>, <span class="ruby-identifier">weight</span> = <span class="ruby-identifier">server</span>.<span class="ruby-identifier">split</span> <span class="ruby-string">':'</span>, <span class="ruby-value">3</span>
<span class="ruby-identifier">port</span> <span class="ruby-operator">||=</span> <span class="ruby-constant">DEFAULT_PORT</span>
<span class="ruby-identifier">weight</span> <span class="ruby-operator">||=</span> <span class="ruby-constant">DEFAULT_WEIGHT</span>
<span class="ruby-constant">Server</span>.<span class="ruby-identifier">new</span> <span class="ruby-keyword">self</span>, <span class="ruby-identifier">host</span>, <span class="ruby-identifier">port</span>, <span class="ruby-identifier">weight</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">server</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">logger</span>.<span class="ruby-identifier">debug</span> { <span class="ruby-node">"Servers now: #{@servers.inspect}"</span> } <span class="ruby-keyword">if</span> <span class="ruby-identifier">logger</span>
<span class="ruby-comment"># There's no point in doing this if there's only one server</span>
<span class="ruby-ivar">@continuum</span> = <span class="ruby-identifier">create_continuum_for</span>(<span class="ruby-ivar">@servers</span>) <span class="ruby-keyword">if</span> <span class="ruby-ivar">@servers</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">></span> <span class="ruby-value">1</span>
<span class="ruby-ivar">@servers</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-set" class="method-detail ">
<div class="method-heading">
<span class="method-name">set</span><span
class="method-args">(key, value, expiry = 0, raw = false)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="set-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 357</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">set</span>(<span class="ruby-identifier">key</span>, <span class="ruby-identifier">value</span>, <span class="ruby-identifier">expiry</span> = <span class="ruby-value">0</span>, <span class="ruby-identifier">raw</span> = <span class="ruby-keyword">false</span>)
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-string">"Update of readonly cache"</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@readonly</span>
<span class="ruby-identifier">value</span> = <span class="ruby-constant">Marshal</span>.<span class="ruby-identifier">dump</span> <span class="ruby-identifier">value</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">raw</span>
<span class="ruby-identifier">with_server</span>(<span class="ruby-identifier">key</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">logger</span>.<span class="ruby-identifier">debug</span> { <span class="ruby-node">"set #{key} to #{server.inspect}: #{value.to_s.size}"</span> } <span class="ruby-keyword">if</span> <span class="ruby-identifier">logger</span>
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@check_size</span> <span class="ruby-operator">&&</span> <span class="ruby-identifier">value</span>.<span class="ruby-identifier">to_s</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">></span> <span class="ruby-constant">ONE_MB</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-string">"Value too large, memcached can only store 1MB of data per key"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">command</span> = <span class="ruby-node">"set #{cache_key} 0 #{expiry} #{value.to_s.size}#{noreply}\r\n#{value}\r\n"</span>
<span class="ruby-identifier">with_socket_management</span>(<span class="ruby-identifier">server</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">socket</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">socket</span>.<span class="ruby-identifier">write</span> <span class="ruby-identifier">command</span>
<span class="ruby-keyword">break</span> <span class="ruby-keyword">nil</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@no_reply</span>
<span class="ruby-identifier">result</span> = <span class="ruby-identifier">socket</span>.<span class="ruby-identifier">gets</span>
<span class="ruby-identifier">raise_on_error_response!</span> <span class="ruby-identifier">result</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">result</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-identifier">server</span>.<span class="ruby-identifier">close</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-node">"lost connection to #{server.host}:#{server.port}"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-stats" class="method-detail ">
<div class="method-heading">
<span class="method-name">stats</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns statistics for each memcached server. An explanation of the statistics can be found in the memcached docs:</p>
<p><a href="http://code.sixapart.com/svn/memcached/trunk/server/doc/protocol.txt">code.sixapart.com/svn/memcached/trunk/server/doc/protocol.txt</a></p>
<p>Example:</p>
<pre>>> pp CACHE.stats
{"localhost:11211"=>
{"bytes"=>4718,
"pid"=>20188,
"connection_structures"=>4,
"time"=>1162278121,
"pointer_size"=>32,
"limit_maxbytes"=>67108864,
"cmd_get"=>14532,
"version"=>"1.2.0",
"bytes_written"=>432583,
"cmd_set"=>32,
"get_misses"=>0,
"total_connections"=>19,
"curr_connections"=>3,
"curr_items"=>4,
"uptime"=>1557,
"get_hits"=>14532,
"total_items"=>32,
"rusage_system"=>0.313952,
"rusage_user"=>0.119981,
"bytes_read"=>190619}}
=> nil</pre>
<div class="method-source-code" id="stats-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 610</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">stats</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-string">"No active servers"</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">active?</span>
<span class="ruby-identifier">server_stats</span> = {}
<span class="ruby-ivar">@servers</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">server</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">next</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">server</span>.<span class="ruby-identifier">alive?</span>
<span class="ruby-identifier">with_socket_management</span>(<span class="ruby-identifier">server</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">socket</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">value</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-identifier">socket</span>.<span class="ruby-identifier">write</span> <span class="ruby-string">"stats\r\n"</span>
<span class="ruby-identifier">stats</span> = {}
<span class="ruby-keyword">while</span> <span class="ruby-identifier">line</span> = <span class="ruby-identifier">socket</span>.<span class="ruby-identifier">gets</span> <span class="ruby-keyword">do</span>
<span class="ruby-identifier">raise_on_error_response!</span> <span class="ruby-identifier">line</span>
<span class="ruby-keyword">break</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">line</span> <span class="ruby-operator">==</span> <span class="ruby-string">"END\r\n"</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">line</span> <span class="ruby-operator">=~</span> <span class="ruby-regexp">/\ASTAT ([\S]+) ([\w\.\:]+)/</span> <span class="ruby-keyword">then</span>
<span class="ruby-identifier">name</span>, <span class="ruby-identifier">value</span> = <span class="ruby-node">$1</span>, <span class="ruby-node">$2</span>
<span class="ruby-identifier">stats</span>[<span class="ruby-identifier">name</span>] = <span class="ruby-keyword">case</span> <span class="ruby-identifier">name</span>
<span class="ruby-keyword">when</span> <span class="ruby-string">'version'</span>
<span class="ruby-identifier">value</span>
<span class="ruby-keyword">when</span> <span class="ruby-string">'rusage_user'</span>, <span class="ruby-string">'rusage_system'</span> <span class="ruby-keyword">then</span>
<span class="ruby-identifier">seconds</span>, <span class="ruby-identifier">microseconds</span> = <span class="ruby-identifier">value</span>.<span class="ruby-identifier">split</span>(<span class="ruby-regexp">/:/</span>, <span class="ruby-value">2</span>)
<span class="ruby-identifier">microseconds</span> <span class="ruby-operator">||=</span> <span class="ruby-value">0</span>
<span class="ruby-constant">Float</span>(<span class="ruby-identifier">seconds</span>) <span class="ruby-operator">+</span> (<span class="ruby-constant">Float</span>(<span class="ruby-identifier">microseconds</span>) <span class="ruby-operator">/</span> <span class="ruby-value">1_000_000</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">value</span> <span class="ruby-operator">=~</span> <span class="ruby-regexp">/\A\d+\Z/</span> <span class="ruby-keyword">then</span>
<span class="ruby-identifier">value</span>.<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">value</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">server_stats</span>[<span class="ruby-node">"#{server.host}:#{server.port}"</span>] = <span class="ruby-identifier">stats</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-string">"No active servers"</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">server_stats</span>.<span class="ruby-identifier">empty?</span>
<span class="ruby-identifier">server_stats</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
</section>
<section id="protected-instance-5Buntitled-5D-method-details" class="method-section">
<header>
<h3>Protected Instance Methods</h3>
</header>
<div id="method-i-cache_decr" class="method-detail ">
<div class="method-heading">
<span class="method-name">cache_decr</span><span
class="method-args">(server, cache_key, amount)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Performs a raw decr for <code>cache_key</code> from <code>server</code>. Returns nil if not found.</p>
<div class="method-source-code" id="cache_decr-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 724</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">cache_decr</span>(<span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span>, <span class="ruby-identifier">amount</span>)
<span class="ruby-identifier">with_socket_management</span>(<span class="ruby-identifier">server</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">socket</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">socket</span>.<span class="ruby-identifier">write</span> <span class="ruby-node">"decr #{cache_key} #{amount}#{noreply}\r\n"</span>
<span class="ruby-keyword">break</span> <span class="ruby-keyword">nil</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@no_reply</span>
<span class="ruby-identifier">text</span> = <span class="ruby-identifier">socket</span>.<span class="ruby-identifier">gets</span>
<span class="ruby-identifier">raise_on_error_response!</span> <span class="ruby-identifier">text</span>
<span class="ruby-keyword">return</span> <span class="ruby-keyword">nil</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">text</span> <span class="ruby-operator">==</span> <span class="ruby-string">"NOT_FOUND\r\n"</span>
<span class="ruby-keyword">return</span> <span class="ruby-identifier">text</span>.<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-cache_get" class="method-detail ">
<div class="method-heading">
<span class="method-name">cache_get</span><span
class="method-args">(server, cache_key)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Fetches the raw data for <code>cache_key</code> from <code>server</code>. Returns nil on cache miss.</p>
<div class="method-source-code" id="cache_get-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 739</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">cache_get</span>(<span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span>)
<span class="ruby-identifier">with_socket_management</span>(<span class="ruby-identifier">server</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">socket</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">socket</span>.<span class="ruby-identifier">write</span> <span class="ruby-node">"get #{cache_key}\r\n"</span>
<span class="ruby-identifier">keyline</span> = <span class="ruby-identifier">socket</span>.<span class="ruby-identifier">gets</span> <span class="ruby-comment"># "VALUE <key> <flags> <bytes>\r\n"</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">keyline</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-keyword">then</span>
<span class="ruby-identifier">server</span>.<span class="ruby-identifier">close</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-node">"lost connection to #{server.host}:#{server.port}"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">raise_on_error_response!</span> <span class="ruby-identifier">keyline</span>
<span class="ruby-keyword">return</span> <span class="ruby-keyword">nil</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">keyline</span> <span class="ruby-operator">==</span> <span class="ruby-string">"END\r\n"</span>
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">keyline</span> <span class="ruby-operator">=~</span> <span class="ruby-regexp">/(\d+)\r/</span> <span class="ruby-keyword">then</span>
<span class="ruby-identifier">server</span>.<span class="ruby-identifier">close</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-node">"unexpected response #{keyline.inspect}"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">value</span> = <span class="ruby-identifier">socket</span>.<span class="ruby-identifier">read</span> <span class="ruby-node">$1</span>.<span class="ruby-identifier">to_i</span>
<span class="ruby-identifier">socket</span>.<span class="ruby-identifier">read</span> <span class="ruby-value">2</span> <span class="ruby-comment"># "\r\n"</span>
<span class="ruby-identifier">socket</span>.<span class="ruby-identifier">gets</span> <span class="ruby-comment"># "END\r\n"</span>
<span class="ruby-keyword">return</span> <span class="ruby-identifier">value</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-cache_get_multi" class="method-detail ">
<div class="method-heading">
<span class="method-name">cache_get_multi</span><span
class="method-args">(server, cache_keys)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Fetches <code>cache_keys</code> from <code>server</code> using a multi-get.</p>
<div class="method-source-code" id="cache_get_multi-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 798</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">cache_get_multi</span>(<span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_keys</span>)
<span class="ruby-identifier">with_socket_management</span>(<span class="ruby-identifier">server</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">socket</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">values</span> = {}
<span class="ruby-identifier">socket</span>.<span class="ruby-identifier">write</span> <span class="ruby-node">"get #{cache_keys}\r\n"</span>
<span class="ruby-keyword">while</span> <span class="ruby-identifier">keyline</span> = <span class="ruby-identifier">socket</span>.<span class="ruby-identifier">gets</span> <span class="ruby-keyword">do</span>
<span class="ruby-keyword">return</span> <span class="ruby-identifier">values</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">keyline</span> <span class="ruby-operator">==</span> <span class="ruby-string">"END\r\n"</span>
<span class="ruby-identifier">raise_on_error_response!</span> <span class="ruby-identifier">keyline</span>
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">keyline</span> <span class="ruby-operator">=~</span> <span class="ruby-regexp">/\AVALUE (.+) (.+) (.+)/</span> <span class="ruby-keyword">then</span>
<span class="ruby-identifier">server</span>.<span class="ruby-identifier">close</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-node">"unexpected response #{keyline.inspect}"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">key</span>, <span class="ruby-identifier">data_length</span> = <span class="ruby-node">$1</span>, <span class="ruby-node">$3</span>
<span class="ruby-identifier">values</span>[<span class="ruby-node">$1</span>] = <span class="ruby-identifier">socket</span>.<span class="ruby-identifier">read</span> <span class="ruby-identifier">data_length</span>.<span class="ruby-identifier">to_i</span>
<span class="ruby-identifier">socket</span>.<span class="ruby-identifier">read</span>(<span class="ruby-value">2</span>) <span class="ruby-comment"># "\r\n"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">server</span>.<span class="ruby-identifier">close</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-node">"lost connection to #{server.host}:#{server.port}"</span> <span class="ruby-comment"># TODO: retry here too</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-cache_incr" class="method-detail ">
<div class="method-heading">
<span class="method-name">cache_incr</span><span
class="method-args">(server, cache_key, amount)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Performs a raw incr for <code>cache_key</code> from <code>server</code>. Returns nil if not found.</p>
<div class="method-source-code" id="cache_incr-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 826</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">cache_incr</span>(<span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span>, <span class="ruby-identifier">amount</span>)
<span class="ruby-identifier">with_socket_management</span>(<span class="ruby-identifier">server</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">socket</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">socket</span>.<span class="ruby-identifier">write</span> <span class="ruby-node">"incr #{cache_key} #{amount}#{noreply}\r\n"</span>
<span class="ruby-keyword">break</span> <span class="ruby-keyword">nil</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@no_reply</span>
<span class="ruby-identifier">text</span> = <span class="ruby-identifier">socket</span>.<span class="ruby-identifier">gets</span>
<span class="ruby-identifier">raise_on_error_response!</span> <span class="ruby-identifier">text</span>
<span class="ruby-keyword">return</span> <span class="ruby-keyword">nil</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">text</span> <span class="ruby-operator">==</span> <span class="ruby-string">"NOT_FOUND\r\n"</span>
<span class="ruby-keyword">return</span> <span class="ruby-identifier">text</span>.<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-check_multithread_status-21" class="method-detail ">
<div class="method-heading">
<span class="method-name">check_multithread_status!</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="check_multithread_status-21-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 949</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">check_multithread_status!</span>
<span class="ruby-keyword">return</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@multithread</span>
<span class="ruby-keyword">return</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@evented</span>
<span class="ruby-keyword">if</span> <span class="ruby-constant">Thread</span>.<span class="ruby-identifier">current</span>[<span class="ruby-value">:memcache_client</span>] <span class="ruby-operator">!=</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">object_id</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-identifier"><<-EOM</span>
<span class="ruby-value"> You are accessing this memcache-client instance from multiple threads but have not enabled multithread support.
Normally: MemCache.new(['localhost:11211'], :multithread => true)
In Rails: config.cache_store = [:mem_cache_store, 'localhost:11211', { :multithread => true }]
</span><span class="ruby-identifier"> EOM</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-create_continuum_for" class="method-detail ">
<div class="method-heading">
<span class="method-name">create_continuum_for</span><span
class="method-args">(servers)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="create_continuum_for-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 930</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">create_continuum_for</span>(<span class="ruby-identifier">servers</span>)
<span class="ruby-identifier">total_weight</span> = <span class="ruby-identifier">servers</span>.<span class="ruby-identifier">inject</span>(<span class="ruby-value">0</span>) { <span class="ruby-operator">|</span><span class="ruby-identifier">memo</span>, <span class="ruby-identifier">srv</span><span class="ruby-operator">|</span> <span class="ruby-identifier">memo</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">srv</span>.<span class="ruby-identifier">weight</span> }
<span class="ruby-identifier">continuum</span> = []
<span class="ruby-identifier">servers</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">server</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">entry_count_for</span>(<span class="ruby-identifier">server</span>, <span class="ruby-identifier">servers</span>.<span class="ruby-identifier">size</span>, <span class="ruby-identifier">total_weight</span>).<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">idx</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">hash</span> = <span class="ruby-constant">Digest</span><span class="ruby-operator">::</span><span class="ruby-constant">SHA1</span>.<span class="ruby-identifier">hexdigest</span>(<span class="ruby-node">"#{server.host}:#{server.port}:#{idx}"</span>)
<span class="ruby-identifier">value</span> = <span class="ruby-constant">Integer</span>(<span class="ruby-node">"0x#{hash[0..7]}"</span>)
<span class="ruby-identifier">continuum</span> <span class="ruby-operator"><<</span> <span class="ruby-constant">Continuum</span><span class="ruby-operator">::</span><span class="ruby-constant">Entry</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">value</span>, <span class="ruby-identifier">server</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">continuum</span>.<span class="ruby-identifier">sort</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">a</span>, <span class="ruby-identifier">b</span><span class="ruby-operator">|</span> <span class="ruby-identifier">a</span>.<span class="ruby-identifier">value</span> <span class="ruby-operator"><=></span> <span class="ruby-identifier">b</span>.<span class="ruby-identifier">value</span> }
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-entry_count_for" class="method-detail ">
<div class="method-heading">
<span class="method-name">entry_count_for</span><span
class="method-args">(server, total_servers, total_weight)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="entry_count_for-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 945</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">entry_count_for</span>(<span class="ruby-identifier">server</span>, <span class="ruby-identifier">total_servers</span>, <span class="ruby-identifier">total_weight</span>)
((<span class="ruby-identifier">total_servers</span> <span class="ruby-operator">*</span> <span class="ruby-constant">Continuum</span><span class="ruby-operator">::</span><span class="ruby-constant">POINTS_PER_SERVER</span> <span class="ruby-operator">*</span> <span class="ruby-identifier">server</span>.<span class="ruby-identifier">weight</span>) <span class="ruby-operator">/</span> <span class="ruby-constant">Float</span>(<span class="ruby-identifier">total_weight</span>)).<span class="ruby-identifier">floor</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-get_server_for_key" class="method-detail ">
<div class="method-heading">
<span class="method-name">get_server_for_key</span><span
class="method-args">(key, options = {})</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Pick a server to handle the request based on a hash of the key.</p>
<div class="method-source-code" id="get_server_for_key-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 699</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">get_server_for_key</span>(<span class="ruby-identifier">key</span>, <span class="ruby-identifier">options</span> = {})
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>, <span class="ruby-node">"illegal character in key #{key.inspect}"</span> <span class="ruby-keyword">if</span>
<span class="ruby-identifier">key</span> <span class="ruby-operator">=~</span> <span class="ruby-regexp">/\s/</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>, <span class="ruby-string">"key cannot be blank"</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">key</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">key</span>.<span class="ruby-identifier">strip</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">==</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>, <span class="ruby-node">"key too long #{key.inspect}"</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">key</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">></span> <span class="ruby-value">250</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-string">"No servers available"</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@servers</span>.<span class="ruby-identifier">empty?</span>
<span class="ruby-keyword">return</span> <span class="ruby-ivar">@servers</span>.<span class="ruby-identifier">first</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@servers</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">==</span> <span class="ruby-value">1</span>
<span class="ruby-identifier">hkey</span> = <span class="ruby-identifier">hash_for</span>(<span class="ruby-identifier">key</span>)
<span class="ruby-value">20</span>.<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">try</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">entryidx</span> = <span class="ruby-constant">Continuum</span>.<span class="ruby-identifier">binary_search</span>(<span class="ruby-ivar">@continuum</span>, <span class="ruby-identifier">hkey</span>)
<span class="ruby-identifier">server</span> = <span class="ruby-ivar">@continuum</span>[<span class="ruby-identifier">entryidx</span>].<span class="ruby-identifier">server</span>
<span class="ruby-keyword">return</span> <span class="ruby-identifier">server</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">server</span>.<span class="ruby-identifier">alive?</span>
<span class="ruby-keyword">break</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">failover</span>
<span class="ruby-identifier">hkey</span> = <span class="ruby-identifier">hash_for</span> <span class="ruby-node">"#{try}#{key}"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-string">"No servers available"</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-gets" class="method-detail ">
<div class="method-heading">
<span class="method-name">gets</span><span
class="method-args">(key, raw = false)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="gets-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 763</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">gets</span>(<span class="ruby-identifier">key</span>, <span class="ruby-identifier">raw</span> = <span class="ruby-keyword">false</span>)
<span class="ruby-identifier">with_server</span>(<span class="ruby-identifier">key</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">logger</span>.<span class="ruby-identifier">debug</span> { <span class="ruby-node">"gets #{key} from #{server.inspect}"</span> } <span class="ruby-keyword">if</span> <span class="ruby-identifier">logger</span>
<span class="ruby-identifier">result</span> = <span class="ruby-identifier">with_socket_management</span>(<span class="ruby-identifier">server</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">socket</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">socket</span>.<span class="ruby-identifier">write</span> <span class="ruby-node">"gets #{cache_key}\r\n"</span>
<span class="ruby-identifier">keyline</span> = <span class="ruby-identifier">socket</span>.<span class="ruby-identifier">gets</span> <span class="ruby-comment"># "VALUE <key> <flags> <bytes> <cas token>\r\n"</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">keyline</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-keyword">then</span>
<span class="ruby-identifier">server</span>.<span class="ruby-identifier">close</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-node">"lost connection to #{server.host}:#{server.port}"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">raise_on_error_response!</span> <span class="ruby-identifier">keyline</span>
<span class="ruby-keyword">return</span> <span class="ruby-keyword">nil</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">keyline</span> <span class="ruby-operator">==</span> <span class="ruby-string">"END\r\n"</span>
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">keyline</span> <span class="ruby-operator">=~</span> <span class="ruby-regexp">/(\d+) (\w+)\r/</span> <span class="ruby-keyword">then</span>
<span class="ruby-identifier">server</span>.<span class="ruby-identifier">close</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-node">"unexpected response #{keyline.inspect}"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">value</span> = <span class="ruby-identifier">socket</span>.<span class="ruby-identifier">read</span> <span class="ruby-node">$1</span>.<span class="ruby-identifier">to_i</span>
<span class="ruby-identifier">socket</span>.<span class="ruby-identifier">read</span> <span class="ruby-value">2</span> <span class="ruby-comment"># "\r\n"</span>
<span class="ruby-identifier">socket</span>.<span class="ruby-identifier">gets</span> <span class="ruby-comment"># "END\r\n"</span>
[<span class="ruby-identifier">value</span>, <span class="ruby-node">$2</span>]
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>[<span class="ruby-value">0</span>] = <span class="ruby-constant">Marshal</span>.<span class="ruby-identifier">load</span> <span class="ruby-identifier">result</span>[<span class="ruby-value">0</span>] <span class="ruby-keyword">unless</span> <span class="ruby-identifier">raw</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">rescue</span> <span class="ruby-constant">TypeError</span> <span class="ruby-operator">=></span> <span class="ruby-identifier">err</span>
<span class="ruby-identifier">handle_error</span> <span class="ruby-keyword">nil</span>, <span class="ruby-identifier">err</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-handle_error" class="method-detail ">
<div class="method-heading">
<span class="method-name">handle_error</span><span
class="method-args">(server, error)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Handles <code>error</code> from <code>server</code>.</p>
<div class="method-source-code" id="handle_error-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 901</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">handle_error</span>(<span class="ruby-identifier">server</span>, <span class="ruby-identifier">error</span>)
<span class="ruby-identifier">raise</span> <span class="ruby-identifier">error</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">error</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">MemCacheError</span>)
<span class="ruby-identifier">server</span>.<span class="ruby-identifier">close</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">server</span> <span class="ruby-operator">&&</span> <span class="ruby-identifier">server</span>.<span class="ruby-identifier">status</span> <span class="ruby-operator">==</span> <span class="ruby-string">"CONNECTED"</span>
<span class="ruby-identifier">new_error</span> = <span class="ruby-constant">MemCacheError</span>.<span class="ruby-identifier">new</span> <span class="ruby-identifier">error</span>.<span class="ruby-identifier">message</span>
<span class="ruby-identifier">new_error</span>.<span class="ruby-identifier">set_backtrace</span> <span class="ruby-identifier">error</span>.<span class="ruby-identifier">backtrace</span>
<span class="ruby-identifier">raise</span> <span class="ruby-identifier">new_error</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-hash_for" class="method-detail ">
<div class="method-heading">
<span class="method-name">hash_for</span><span
class="method-args">(key)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns an interoperable hash value for <code>key</code>. (I think, docs are sketchy for down servers).</p>
<div class="method-source-code" id="hash_for-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 692</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">hash_for</span>(<span class="ruby-identifier">key</span>)
<span class="ruby-constant">Zlib</span>.<span class="ruby-identifier">crc32</span>(<span class="ruby-identifier">key</span>)
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-key_length" class="method-detail ">
<div class="method-heading">
<span class="method-name">key_length</span><span
class="method-args">(key)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Calculate length of the key, including the namespace and namespace-separator.</p>
<div class="method-source-code" id="key_length-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 684</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">key_length</span>(<span class="ruby-identifier">key</span>)
<span class="ruby-identifier">key</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">+</span> (<span class="ruby-identifier">namespace</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-operator">?</span> <span class="ruby-value">0</span> <span class="ruby-operator">:</span> ( <span class="ruby-identifier">namespace</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">+</span> (<span class="ruby-ivar">@namespace_separator</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-operator">?</span> <span class="ruby-value">0</span> <span class="ruby-operator">:</span> <span class="ruby-ivar">@namespace_separator</span>.<span class="ruby-identifier">length</span>) ) )
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-make_cache_key" class="method-detail ">
<div class="method-heading">
<span class="method-name">make_cache_key</span><span
class="method-args">(key)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Create a key for the cache, incorporating the namespace qualifier if requested.</p>
<div class="method-source-code" id="make_cache_key-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 669</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">make_cache_key</span>(<span class="ruby-identifier">key</span>)
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@autofix_keys</span> <span class="ruby-operator">&&</span> (<span class="ruby-identifier">key</span> <span class="ruby-operator">=~</span> <span class="ruby-regexp">/\s/</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">key_length</span>(<span class="ruby-identifier">key</span>) <span class="ruby-operator">></span> <span class="ruby-value">250</span>)
<span class="ruby-identifier">key</span> = <span class="ruby-node">"#{Digest::SHA1.hexdigest(key)}-autofixed"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">namespace</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-identifier">key</span>
<span class="ruby-keyword">else</span>
<span class="ruby-node">"#{@namespace}#{@namespace_separator}#{key}"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-noreply" class="method-detail ">
<div class="method-heading">
<span class="method-name">noreply</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="noreply-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 909</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">noreply</span>
<span class="ruby-ivar">@no_reply</span> <span class="ruby-operator">?</span> <span class="ruby-string">' noreply'</span> <span class="ruby-operator">:</span> <span class="ruby-string">''</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-raise_on_error_response-21" class="method-detail ">
<div class="method-heading">
<span class="method-name">raise_on_error_response!</span><span
class="method-args">(response)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="raise_on_error_response-21-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 924</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">raise_on_error_response!</span>(<span class="ruby-identifier">response</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">response</span> <span class="ruby-operator">=~</span> <span class="ruby-regexp">/\A(?:CLIENT_|SERVER_)?ERROR(.*)/</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-node">$1</span>.<span class="ruby-identifier">strip</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-request_setup" class="method-detail ">
<div class="method-heading">
<span class="method-name">request_setup</span><span
class="method-args">(key)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Performs setup for making a request with <code>key</code> from memcached. Returns the server to fetch the key from and the complete key to use.</p>
<div class="method-source-code" id="request_setup-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 917</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">request_setup</span>(<span class="ruby-identifier">key</span>)
<span class="ruby-identifier">raise</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-string">'No active servers'</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">active?</span>
<span class="ruby-identifier">cache_key</span> = <span class="ruby-identifier">make_cache_key</span> <span class="ruby-identifier">key</span>
<span class="ruby-identifier">server</span> = <span class="ruby-identifier">get_server_for_key</span> <span class="ruby-identifier">cache_key</span>
<span class="ruby-keyword">return</span> <span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-with_server" class="method-detail ">
<div class="method-heading">
<span class="method-name">with_server</span><span
class="method-args">(key) { |server, cache_key| ... }</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="with_server-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 882</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">with_server</span>(<span class="ruby-identifier">key</span>)
<span class="ruby-identifier">retried</span> = <span class="ruby-keyword">false</span>
<span class="ruby-keyword">begin</span>
<span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span> = <span class="ruby-identifier">request_setup</span>(<span class="ruby-identifier">key</span>)
<span class="ruby-keyword">yield</span> <span class="ruby-identifier">server</span>, <span class="ruby-identifier">cache_key</span>
<span class="ruby-keyword">rescue</span> <span class="ruby-constant">IndexError</span> <span class="ruby-operator">=></span> <span class="ruby-identifier">e</span>
<span class="ruby-identifier">logger</span>.<span class="ruby-identifier">warn</span> { <span class="ruby-node">"Server failed: #{e.class.name}: #{e.message}"</span> } <span class="ruby-keyword">if</span> <span class="ruby-identifier">logger</span>
<span class="ruby-keyword">if</span> <span class="ruby-operator">!</span><span class="ruby-identifier">retried</span> <span class="ruby-operator">&&</span> <span class="ruby-ivar">@servers</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">></span> <span class="ruby-value">1</span>
<span class="ruby-identifier">logger</span>.<span class="ruby-identifier">info</span> { <span class="ruby-node">"Connection to server #{server.inspect} DIED! Retrying operation..."</span> } <span class="ruby-keyword">if</span> <span class="ruby-identifier">logger</span>
<span class="ruby-identifier">retried</span> = <span class="ruby-keyword">true</span>
<span class="ruby-keyword">retry</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">handle_error</span>(<span class="ruby-keyword">nil</span>, <span class="ruby-identifier">e</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-with_socket_management" class="method-detail ">
<div class="method-heading">
<span class="method-name">with_socket_management</span><span
class="method-args">(server, &block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Gets or creates a socket connected to the given server, and yields it to the block, wrapped in a mutex synchronization if @multithread is true.</p>
<p>If a socket error (SocketError, SystemCallError, IOError) or protocol error (<a href="MemCache/MemCacheError.html"><code>MemCacheError</code></a>) is raised by the block, closes the socket, attempts to connect again, and retries the block (once). If an error is again raised, reraises it as <a href="MemCache/MemCacheError.html"><code>MemCacheError</code></a>.</p>
<p>If unable to connect to the server (or if in the reconnect wait period), raises <a href="MemCache/MemCacheError.html"><code>MemCacheError</code></a>. Note that the socket connect code marks a server dead for a timeout period, so retrying does not apply to connection attempt failures (but does still apply to unexpectedly lost connections etc.).</p>
<div class="method-source-code" id="with_socket_management-source">
<pre><span class="ruby-comment"># File lib/memcache.rb, line 851</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">with_socket_management</span>(<span class="ruby-identifier">server</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>)
<span class="ruby-identifier">check_multithread_status!</span>
<span class="ruby-ivar">@mutex</span>.<span class="ruby-identifier">lock</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@multithread</span>
<span class="ruby-identifier">retried</span> = <span class="ruby-keyword">false</span>
<span class="ruby-keyword">begin</span>
<span class="ruby-identifier">socket</span> = <span class="ruby-identifier">server</span>.<span class="ruby-identifier">socket</span>
<span class="ruby-comment"># Raise an IndexError to show this server is out of whack. If were inside</span>
<span class="ruby-comment"># a with_server block, we'll catch it and attempt to restart the operation.</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">IndexError</span>, <span class="ruby-node">"No connection to server (#{server.status})"</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">socket</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">socket</span>)
<span class="ruby-keyword">rescue</span> <span class="ruby-constant">SocketError</span>, <span class="ruby-constant">Errno</span><span class="ruby-operator">::</span><span class="ruby-constant">EAGAIN</span>, <span class="ruby-constant">Timeout</span><span class="ruby-operator">::</span><span class="ruby-constant">Error</span> <span class="ruby-operator">=></span> <span class="ruby-identifier">err</span>
<span class="ruby-identifier">logger</span>.<span class="ruby-identifier">warn</span> { <span class="ruby-node">"Socket failure: #{err.message}"</span> } <span class="ruby-keyword">if</span> <span class="ruby-identifier">logger</span>
<span class="ruby-identifier">server</span>.<span class="ruby-identifier">mark_dead</span>(<span class="ruby-identifier">err</span>)
<span class="ruby-identifier">handle_error</span>(<span class="ruby-identifier">server</span>, <span class="ruby-identifier">err</span>)
<span class="ruby-keyword">rescue</span> <span class="ruby-constant">MemCacheError</span>, <span class="ruby-constant">SystemCallError</span>, <span class="ruby-constant">IOError</span> <span class="ruby-operator">=></span> <span class="ruby-identifier">err</span>
<span class="ruby-identifier">logger</span>.<span class="ruby-identifier">warn</span> { <span class="ruby-node">"Generic failure: #{err.class.name}: #{err.message}"</span> } <span class="ruby-keyword">if</span> <span class="ruby-identifier">logger</span>
<span class="ruby-identifier">handle_error</span>(<span class="ruby-identifier">server</span>, <span class="ruby-identifier">err</span>) <span class="ruby-keyword">if</span> <span class="ruby-identifier">retried</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">socket</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-identifier">retried</span> = <span class="ruby-keyword">true</span>
<span class="ruby-keyword">retry</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">ensure</span>
<span class="ruby-ivar">@mutex</span>.<span class="ruby-identifier">unlock</span> <span class="ruby-keyword">if</span> <span class="ruby-ivar">@multithread</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
</section>
</section>
</main>
<footer id="validator-badges" role="contentinfo">
<p><a href="https://validator.w3.org/check/referer">Validate</a>
<p>Generated by <a href="https://ruby.github.io/rdoc/">RDoc</a> 6.3.3.
<p>Based on <a href="http://deveiate.org/projects/Darkfish-RDoc/">Darkfish</a> by <a href="http://deveiate.org">Michael Granger</a>.
</footer>