Module: ActiveSupport::Cache::Strategy::LocalCache

Included in:
MemCacheStore, NullStore, RedisCacheStore
Defined in:
lib/active_support/cache/strategy/local_cache.rb,
lib/active_support/cache/strategy/local_cache_middleware.rb

Overview

Local Cache Strategy

Caches that implement LocalCache will be backed by an in-memory cache for the duration of a block. Repeated calls to the cache for the same key will hit the in-memory cache for faster access.

Defined Under Namespace

Modules: LocalCacheRegistry Classes: LocalStore, Middleware

Instance Method Summary collapse

Instance Method Details

#cleanup(options = nil) ⇒ Object

:nodoc:



85
86
87
88
89
 
# File 'lib/active_support/cache/strategy/local_cache.rb', line 85

def cleanup(options = nil) # :nodoc:
  return super unless cache = local_cache
  cache.clear(options)
  super
end

#clear(options = nil) ⇒ Object

:nodoc:



79
80
81
82
83
 
# File 'lib/active_support/cache/strategy/local_cache.rb', line 79

def clear(options = nil) # :nodoc:
  return super unless cache = local_cache
  cache.clear(options)
  super
end

#decrement(name, amount = 1, **options) ⇒ Object

:nodoc:



104
105
106
107
108
109
 
# File 'lib/active_support/cache/strategy/local_cache.rb', line 104

def decrement(name, amount = 1, **options) # :nodoc:
  return super unless local_cache
  value = bypass_local_cache { super }
  write_cache_value(name, value, raw: true, **options)
  value
end

#delete_matched(matcher, options = nil) ⇒ Object

:nodoc:



91
92
93
94
95
 
# File 'lib/active_support/cache/strategy/local_cache.rb', line 91

def delete_matched(matcher, options = nil) # :nodoc:
  return super unless cache = local_cache
  cache.clear(options)
  super
end

#fetch_multi(*names, &block) ⇒ Object

:nodoc:



111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
 
# File 'lib/active_support/cache/strategy/local_cache.rb', line 111

def fetch_multi(*names, &block) # :nodoc:
  return super if local_cache.nil? || names.empty?

  options = names.extract_options!
  options = merged_options(options)

  keys_to_names = names.index_by { |name| normalize_key(name, options) }

  local_entries = local_cache.read_multi_entries(keys_to_names.keys)
  results = local_entries.each_with_object({}) do |(key, value), result|
    # If we recorded a miss in the local cache, `#fetch_multi` will forward
    # that key to the real store, and the entry will be replaced
    # local_cache.delete_entry(key)
    next if value.nil?

    entry = deserialize_entry(value, **options)

    normalized_key = keys_to_names[key]
    if entry.nil?
      result[normalized_key] = nil
    elsif entry.expired? || entry.mismatched?(normalize_version(normalized_key, options))
      local_cache.delete_entry(key)
    else
      result[normalized_key] = entry.value
    end
  end

  if results.size < names.size
    results.merge!(super(*(names - results.keys), options, &block))
  end

  results
end

#increment(name, amount = 1, **options) ⇒ Object

:nodoc:



97
98
99
100
101
102
 
# File 'lib/active_support/cache/strategy/local_cache.rb', line 97

def increment(name, amount = 1, **options) # :nodoc:
  return super unless local_cache
  value = bypass_local_cache { super }
  write_cache_value(name, value, raw: true, **options)
  value
end

#middleware ⇒ Object

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



73
74
75
76
77
 
# File 'lib/active_support/cache/strategy/local_cache.rb', line 73

def middleware
  @middleware ||= Middleware.new(
    "ActiveSupport::Cache::Strategy::LocalCache",
    local_cache_key)
end

#with_local_cache(&block) ⇒ Object

Use a local cache for the duration of block.



67
68
69
 
# File 'lib/active_support/cache/strategy/local_cache.rb', line 67

def with_local_cache(&block)
  use_temporary_local_cache(LocalStore.new, &block)
end