Class: ActiveSupport::Cache::MemCacheStore

Inherits:
Store show all
Defined in:
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 inherited from Store

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

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).



44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/active_support/cache/mem_cache_store.rb', line 44

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

  extend Strategy::LocalCache
  extend LocalCacheWithRaw
end

Class Method Details

.build_mem_cache(*addresses) ⇒ Object 



29
30
31
32
33
34
 
# File 'lib/active_support/cache/mem_cache_store.rb', line 29

def self.build_mem_cache(*addresses)
  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.



109
110
111
112
113
114
 
# File 'lib/active_support/cache/mem_cache_store.rb', line 109

def clear(options = nil)
  @data.flush_all
rescue Dalli::DalliError => e
  logger.error("DalliError (#{e}): #{e.message}") if logger
  nil
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.



97
98
99
100
101
102
103
104
105
 
# File 'lib/active_support/cache/mem_cache_store.rb', line 97

def decrement(name, amount = 1, options = nil) # :nodoc:
  options = merged_options(options)
  instrument(:decrement, name, :amount => amount) do
    @data.decr(escape_key(namespaced_key(name, options)), amount)
  end
rescue Dalli::DalliError => e
  logger.error("DalliError (#{e}): #{e.message}") if logger
  nil
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.



83
84
85
86
87
88
89
90
91
 
# File 'lib/active_support/cache/mem_cache_store.rb', line 83

def increment(name, amount = 1, options = nil) # :nodoc:
  options = merged_options(options)
  instrument(:increment, name, :amount => amount) do
    @data.incr(escape_key(namespaced_key(name, options)), amount)
  end
rescue Dalli::DalliError => e
  logger.error("DalliError (#{e}): #{e.message}") if logger
  nil
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.



66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/active_support/cache/mem_cache_store.rb', line 66

def read_multi(*names)
  options = names.extract_options!
  options = merged_options(options)
  keys_to_names = Hash[names.map{|name| [escape_key(namespaced_key(name, options)), name]}]
  raw_values = @data.get_multi(keys_to_names.keys, :raw => true)
  values = {}
  raw_values.each do |key, value|
    entry = deserialize_entry(value)
    values[keys_to_names[key]] = entry.value unless entry.expired?
  end
  values
end

#stats ⇒ Object

Get the statistics from the memcached servers.



117
118
119
 
# File 'lib/active_support/cache/mem_cache_store.rb', line 117

def stats
  @data.stats
end