Class: ActiveSupport::Cache::MemCacheStore

Inherits:
Store show all
Includes:
LocalCacheWithRaw, Strategy::LocalCache
Defined in:
activesupport/lib/active_support/cache/mem_cache_store.rb

Overview

A cache store implementation which stores data in Memcached: memcached.org

This is currently the most popular cache store for production websites.

Special features:

  • Clustering and load balancing. One can specify multiple memcached servers, and MemCacheStore will load balance between all available servers. If a server goes down, then MemCacheStore will ignore it until it comes back up.

MemCacheStore implements the Strategy::LocalCache strategy which implements an in-memory cache inside of a block.

Defined Under Namespace

Modules: LocalCacheWithRaw

Constant Summary collapse

ESCAPE_KEY_CHARS = 
/[\x00-\x20%\x7F-\xFF]/n

Instance Attribute Summary

Attributes inherited from Store

#options, #silence

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Strategy::LocalCache

#cleanup, #middleware, #with_local_cache

Methods inherited from Store

#cleanup, #delete, #delete_matched, #exist?, #fetch, #fetch_multi, #mute, #read, #silence!, #write, #write_multi

Constructor Details

#initialize(*addresses) ⇒ MemCacheStore

Creates a new MemCacheStore object, with the given memcached server addresses. Each address is either a host name, or a host-with-port string in the form of “host_name:port”. For example:

ActiveSupport::Cache::MemCacheStore.new("localhost", "server-downstairs.localnetwork:8229")

If no addresses are specified, then MemCacheStore will connect to localhost port 11211 (the default memcached port).



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'activesupport/lib/active_support/cache/mem_cache_store.rb', line 78

def initialize(*addresses)
  addresses = addresses.flatten
  options = addresses.extract_options!
  super(options)

  unless [String, Dalli::Client, NilClass].include?(addresses.first.class)
    raise ArgumentError, "First argument must be an empty array, an array of hosts or a Dalli::Client instance."
  end
  if addresses.first.is_a?(Dalli::Client)
    @data = addresses.first
  else
    mem_cache_options = options.dup
    UNIVERSAL_OPTIONS.each { |name| mem_cache_options.delete(name) }
    @data = self.class.build_mem_cache(*(addresses + [mem_cache_options]))
  end
end

Class Method Details

.build_mem_cache(*addresses) ⇒ Object

Creates a new Dalli::Client instance with specified addresses and options. By default address is equal localhost:11211.

ActiveSupport::Cache::MemCacheStore.build_mem_cache
  # => #<Dalli::Client:0x007f98a47d2028 @servers=["localhost:11211"], @options={}, @ring=nil>
ActiveSupport::Cache::MemCacheStore.build_mem_cache('localhost:10290')
  # => #<Dalli::Client:0x007f98a47b3a60 @servers=["localhost:10290"], @options={}, @ring=nil>



63
64
65
66
67
68
 
# File 'activesupport/lib/active_support/cache/mem_cache_store.rb', line 63

def self.build_mem_cache(*addresses) # :nodoc:
  addresses = addresses.flatten
  options = addresses.extract_options!
  addresses = ["localhost:11211"] if addresses.empty?
  Dalli::Client.new(addresses, options)
end

Instance Method Details

#clear(options = nil) ⇒ Object

Clear the entire cache on all memcached servers. This method should be used with care when shared cache is being used.



145
146
147
 
# File 'activesupport/lib/active_support/cache/mem_cache_store.rb', line 145

def clear(options = nil)
  rescue_error_with(nil) { @data.flush_all }
end

#decrement(name, amount = 1, options = nil) ⇒ Object

Decrement a cached value. This method uses the memcached decr atomic operator and can only be used on values written with the :raw option. Calling it on a value not stored with :raw will initialize that value to zero.



134
135
136
137
138
139
140
141
 
# File 'activesupport/lib/active_support/cache/mem_cache_store.rb', line 134

def decrement(name, amount = 1, options = nil)
  options = merged_options(options)
  instrument(:decrement, name, amount: amount) do
    rescue_error_with nil do
      @data.decr(normalize_key(name, options), amount)
    end
  end
end

#increment(name, amount = 1, options = nil) ⇒ Object

Increment a cached value. This method uses the memcached incr atomic operator and can only be used on values written with the :raw option. Calling it on a value not stored with :raw will initialize that value to zero.



121
122
123
124
125
126
127
128
 
# File 'activesupport/lib/active_support/cache/mem_cache_store.rb', line 121

def increment(name, amount = 1, options = nil)
  options = merged_options(options)
  instrument(:increment, name, amount: amount) do
    rescue_error_with nil do
      @data.incr(normalize_key(name, options), amount)
    end
  end
end

#read_multi(*names) ⇒ Object

Reads multiple values from the cache using a single call to the servers for all keys. Options can be passed in the last argument.



97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'activesupport/lib/active_support/cache/mem_cache_store.rb', line 97

def read_multi(*names)
  options = names.extract_options!
  options = merged_options(options)

  keys_to_names = Hash[names.map { |name| [normalize_key(name, options), name] }]

  raw_values = @data.get_multi(keys_to_names.keys)
  values = {}

  raw_values.each do |key, value|
    entry = deserialize_entry(value)

    unless entry.expired? || entry.mismatched?(normalize_version(keys_to_names[key], options))
      values[keys_to_names[key]] = entry.value
    end
  end

  values
end

#stats ⇒ Object

Get the statistics from the memcached servers.



150
151
152
 
# File 'activesupport/lib/active_support/cache/mem_cache_store.rb', line 150

def stats
  @data.stats
end