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, #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 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>



54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/active_support/cache/mem_cache_store.rb', line 54

def self.build_mem_cache(*addresses) # :nodoc:
  addresses = addresses.flatten
  options = addresses.extract_options!
  addresses = ["localhost:11211"] if addresses.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

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.



121
122
123
 
# File 'lib/active_support/cache/mem_cache_store.rb', line 121

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.



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

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.



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

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.



126
127
128
 
# File 'lib/active_support/cache/mem_cache_store.rb', line 126

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