Class: ActiveSupport::Cache::MemCacheStore

Inherits:
Store show all
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

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, #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 'activesupport/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 'activesupport/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.



139
140
141
# File 'activesupport/lib/active_support/cache/mem_cache_store.rb', line 139

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.



128
129
130
131
132
133
134
135
# File 'activesupport/lib/active_support/cache/mem_cache_store.rb', line 128

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.



115
116
117
118
119
120
121
122
# File 'activesupport/lib/active_support/cache/mem_cache_store.rb', line 115

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
108
109
# File 'activesupport/lib/active_support/cache/mem_cache_store.rb', line 95

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

  instrument_multi(:read, names, options) do
    keys_to_names = Hash[names.map{|name| [normalize_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
end

#statsObject

Get the statistics from the memcached servers.



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

def stats
  @data.stats
end