Class: ActiveSupport::Cache::MemCacheStore

Inherits:
Store show all
Includes:
LocalCacheWithRaw, Strategy::LocalCache
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 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

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



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

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>



61
62
63
64
65
66
 
# File 'lib/active_support/cache/mem_cache_store.rb', line 61

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.



137
138
139
 
# File 'lib/active_support/cache/mem_cache_store.rb', line 137

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.



126
127
128
129
130
131
132
133
 
# File 'lib/active_support/cache/mem_cache_store.rb', line 126

def decrement(name, amount = 1, options = nil) # :nodoc:
  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.



113
114
115
116
117
118
119
120
 
# File 'lib/active_support/cache/mem_cache_store.rb', line 113

def increment(name, amount = 1, options = nil) # :nodoc:
  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.



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

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)
    values[keys_to_names[key]] = entry.value unless entry.expired?
  end
  values
end

#stats ⇒ Object

Get the statistics from the memcached servers.



142
143
144
 
# File 'lib/active_support/cache/mem_cache_store.rb', line 142

def stats
  @data.stats
end