123456789_123456789_123456789_123456789_123456789_

Class: ActiveSupport::Cache::MemCacheStore

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, Store
Instance Chain:
self, Strategy::LocalCache, Store
Inherits: ActiveSupport::Cache::Store
Defined in: activesupport/lib/active_support/cache/mem_cache_store.rb

Overview

Memcached Cache Store

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.

Constant Summary

Store - Inherited

DEFAULT_POOL_OPTIONS

Class Attribute Summary

Store - Inherited

.logger, .raise_on_invalid_cache_expiration_time

Class Method Summary

Store - Inherited

.new

Creates a new cache.

Instance Attribute Summary

Store - Inherited

#logger, #options, #raise_on_invalid_cache_expiration_time,
#silence?

Alias for Store#silence.

Instance Method Summary

Strategy::LocalCache - Included

#middleware

Middleware class can be inserted as a ::Rack handler to be local cache for the duration of request.
#with_local_cache

Use a local cache for the duration of block.

Store - Inherited

#cleanup

Cleans up the cache by removing expired entries.
#clear

Clears the entire cache.
#decrement

Decrements an integer value in the cache.
#delete

Deletes an entry in the cache.
#delete_matched

Deletes all entries with keys matching the pattern.
#delete_multi

Deletes multiple entries in the cache.
#exist?

Returns true if the cache contains an entry for the given key.
#fetch

Fetches data from the cache, using the given key.
#fetch_multi

Fetches data from the cache, using the given keys.
#increment

Increments an integer value in the cache.
#mute

Silences the logger within a block.
#read

Reads data from the cache, using the given key.
#read_multi

Reads multiple values at once from the cache.
#silence,
#silence!

Silences the logger.
#write

Writes the value to the cache with the key.
#write_multi

::ActiveSupport::Cache Storage API to write multiple values at once.
#key_matcher

Adds the namespace defined in the options to a pattern designed to match keys.

Constructor Details

.new(*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['MEMCACHE_SERVERS'] is defined, it will be used instead. Otherwise, MemCacheStore will connect to localhost:11211 (the default memcached port).

[ GitHub ] 

  


# File 'activesupport/lib/active_support/cache/mem_cache_store.rb', line 77



def initialize(*addresses)
  addresses = addresses.flatten
  options = addresses.extract_options!
  if options.key?(:cache_nils)
    options[:skip_nil] = !options.delete(:cache_nils)
  end
  super(options)

  unless [String, Dalli::Client, NilClass].include?(addresses.first.class)
    raise ArgumentError, "First argument must be an empty array, address, or array of addresses."
  end

  @mem_cache_options = options.dup
  # The value "compress: false" prevents duplicate compression within Dalli.
  @mem_cache_options[:compress] = false
  (OVERRIDDEN_OPTIONS - %i(compress)).each { |name| @mem_cache_options.delete(name) }
  @data = self.class.build_mem_cache(*(addresses + [@mem_cache_options]))
end


  







Class Attribute Details



  

    .supports_cache_versioning?  ⇒ Boolean  (readonly)
  



  

    

Advertise cache versioning support.


  





  


  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/cache/mem_cache_store.rb', line 38



def self.supports_cache_versioning?
  true
end


  







Instance Method Details



  

    #clear(options = nil)  
  



  

    

Clear the entire cache on all memcached servers. This method should be used with care when shared cache is being used.


  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/cache/mem_cache_store.rb', line 171



def clear(options = nil)
  rescue_error_with(nil) { @data.with { |c| c.flush_all } }
end


  








  

    #decrement(name, amount = 1, options = nil)  
  



  

    

Decrement a cached integer value using the memcached decr atomic operator. Returns the updated value.



If the key is unset or has expired, it will be set to 0. Memcached does not support negative counters.



cache.decrement("foo") # => 0



To set a specific value, call #write passing raw: true:



cache.write("baz", 5, raw: true)
cache.decrement("baz") # => 4



Decrementing a non-numeric value, or a value written without raw: true, will fail and return nil.


  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/cache/mem_cache_store.rb', line 158



def decrement(name, amount = 1, options = nil)
  options = merged_options(options)
  key = normalize_key(name, options)

  instrument(:decrement, key, amount: amount) do
    rescue_error_with nil do
      @data.with { |c| c.decr(key, amount, options[:expires_in], 0) }
    end
  end
end


  








  

    #increment(name, amount = 1, options = nil)  
  



  

    

Increment a cached integer value using the memcached incr atomic operator. Returns the updated value.



If the key is unset or has expired, it will be set to amount:



cache.increment("foo") # => 1
cache.increment("bar", 100) # => 100



To set a specific value, call #write passing raw: true:



cache.write("baz", 5, raw: true)
cache.increment("baz") # => 6



Incrementing a non-numeric value, or a value written without raw: true, will fail and return nil.


  



  [ GitHub ]


  

  


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



def increment(name, amount = 1, options = nil)
  options = merged_options(options)
  key = normalize_key(name, options)

  instrument(:increment, key, amount: amount) do
    rescue_error_with nil do
      @data.with { |c| c.incr(key, amount, options[:expires_in], amount) }
    end
  end
end


  








  

    #inspect  
  

  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/cache/mem_cache_store.rb', line 96



def inspect
  instance = @data || @mem_cache_options
  "#<#{self.class} options=#{options.inspect} mem_cache=#{instance.inspect}>"
end


  








  

    #stats  
  



  

    

Get the statistics from the memcached servers.


  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/cache/mem_cache_store.rb', line 176



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


  








  

    #write(name, value, options = nil)    



  

    

Behaves the same as Store#write, but supports additional options specific to memcached.



Additional Options


  • 

    raw: true - Sends the value directly to the server as raw bytes. The value must be a string or number. You can use memcached direct operations like #increment and #decrement only on raw values.
    

  • 

    unless_exist: true - Prevents overwriting an existing cache entry.
    



  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/cache/mem_cache_store.rb', line 102



rdoc_method :method: write