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

DEFAULT_CODER =

Dalli automatically Marshal values

NullCoder
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, #delete_matched, #middleware, #with_local_cache

Methods inherited from Store

#cleanup, #delete, #delete_matched, #delete_multi, #exist?, #fetch, #fetch_multi, #mute, #read, #read_multi, #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 provided, but ENV is defined, it will be used instead. Otherwise, MemCacheStore will connect to localhost:11211 (the default memcached port).



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/active_support/cache/mem_cache_store.rb', line 86

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. If no addresses are provided, we give nil to Dalli::Client, so it uses its fallbacks:

  • ENV (if defined)

  • “127.0.0.1:11211” (otherwise)

    ActiveSupport::Cache::MemCacheStore.build_mem_cache

    # => #<Dalli::Client:0x007f98a47d2028 @servers=["127.0.0.1:11211"], @options={}, @ring=nil>

    ActiveSupport::Cache::MemCacheStore.build_mem_cache(‘localhost:10290’)

    # => #<Dalli::Client:0x007f98a47b3a60 @servers=["localhost:10290"], @options={}, @ring=nil>



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

def self.build_mem_cache(*addresses) # :nodoc:
  addresses = addresses.flatten
  options = addresses.extract_options!
  addresses = nil if addresses.compact.empty?
  pool_options = retrieve_pool_options(options)

  if pool_options.empty?
    Dalli::Client.new(addresses, options)
  else
    ensure_connection_pool_added!
    ConnectionPool.new(pool_options) { Dalli::Client.new(addresses, options.merge(threadsafe: false)) }
  end
end

.supports_cache_versioning? ⇒ Boolean

Advertise cache versioning support.

Returns:

  • (Boolean) 


46
47
48
 
# File 'lib/active_support/cache/mem_cache_store.rb', line 46

def self.supports_cache_versioning?
  true
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.



131
132
133
 
# File 'lib/active_support/cache/mem_cache_store.rb', line 131

def clear(options = nil)
  rescue_error_with(nil) { @data.with { |c| c.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.



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

def decrement(name, amount = 1, options = nil)
  options = merged_options(options)
  instrument(:decrement, name, amount: amount) do
    rescue_error_with nil do
      @data.with { |c| c.decr(normalize_key(name, options), amount, options[:expires_in]) }
    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.



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

def increment(name, amount = 1, options = nil)
  options = merged_options(options)
  instrument(:increment, name, amount: amount) do
    rescue_error_with nil do
      @data.with { |c| c.incr(normalize_key(name, options), amount, options[:expires_in]) }
    end
  end
end

#stats ⇒ Object

Get the statistics from the memcached servers.



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

def stats
  @data.with { |c| c.stats }
end