Class: ActiveSupport::Cache::RedisCacheStore

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 131

def initialize(error_handler: DEFAULT_ERROR_HANDLER, **redis_options)
  universal_options = redis_options.extract!(*UNIVERSAL_OPTIONS)
  pool_options = self.class.send(:retrieve_pool_options, redis_options)

  if redis_options.key?(:client)
    client = redis_options.delete(:client)
    clients = Array.wrap(client.respond_to?(:call) ? client.call : client)
  else
    urls = Array.wrap(redis_options.delete(:url))
    urls << nil if urls.empty?
    clients = urls.map do |url|
      RedisClient.config(url: url, protocol: 2, **redis_options)
    end
  end

  clients.map! do |c|
    if c.respond_to?(:new_pool)
      c.new_pool(**(pool_options || {}))
    else
      c
    end
  end

  @redis = if clients.size > 1
    RedisClient.ring(clients)
  else
    clients.first
  end

  @error_handler = error_handler

  super(universal_options)
end

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 473

def supports_expire_nx?
  return @supports_expire_nx if defined?(@supports_expire_nx)

  redis_versions = redis.nodes.map { |n| n.call("info", "server").scan(/edis_version:([\d.]+)/)[0][0] || "0" }
  @supports_expire_nx = redis_versions.all? { |v| Gem::Version.new(v) >= Gem::Version.new("7.0.0") }
end

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 290

def cleanup(options = nil)
  super
end

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 298

def clear(options = nil)
  failsafe :clear do
    if namespace = merged_options(options)[:namespace]
      delete_matched "*", namespace: namespace
    else
      redis.then { |c| c.flushdb }
    end
  end
end

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 275

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

  instrument :decrement, key, amount: amount do
    failsafe :decrement do
      change_counter(key, -amount, options)
    end
  end
end

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 391

def delete_entry(key, **options)
  failsafe :delete_entry, returning: false do
    redis.node_for(key).call("unlink", key) == 1
  end
end

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 204

def delete_matched(matcher, options = nil)
  unless String === matcher
    raise ArgumentError, "Only Redis glob strings are supported: #{matcher.inspect}"
  end
  pattern = namespace_key(matcher, options)

  instrument :delete_matched, pattern do
    redis.nodes.each do |node|
      node.with do |conn|
        conn.scan(match: pattern, count: SCAN_BATCH_SIZE).each_slice(SCAN_BATCH_SIZE).each do |keys|
          conn.call("unlink", *keys)
        end
      end
    end
  end
end

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 398

def delete_multi_entries(entries, **_options)
  return 0 if entries.empty?

  count = 0
  redis.nodes_for(*entries).each do |node, keys|
    failsafe :delete_multi_entries do
      count += node.call("unlink", *keys)
    end
  end

  count
end

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 426

def deserialize_entry(payload, raw: false, **)
  if raw && !payload.nil?
    Entry.new(payload)
  else
    super(payload)
  end
end

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 480

def failsafe(method, returning: nil)
  yield
rescue ::RedisClient::ConnectionError => error
  @error_handler&.call(method: method, exception: error, returning: returning)
  returning
end

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 243

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

  instrument :increment, key, amount: amount do
    failsafe :increment do
      change_counter(key, amount, options)
    end
  end
end

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 314

def instance_variables_to_inspect
  [:@options, :@redis].freeze
end

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 320

def read_entry(key, **options)
  deserialize_entry(read_serialized_entry(key, **options), **options)
end

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

def read_multi(*names)
  return {} if names.empty?

  options = names.extract_options!
  options = merged_options(options)
  keys    = names.map { |name| normalize_key(name, options) }

  instrument_multi(:read_multi, keys, options) do |payload|
    read_multi_entries(names, **options).tap do |results|
      payload[:hits] = results.keys.map { |name| normalize_key(name, options) }
    end
  end
end

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 331

def read_multi_entries(names, **options)
  options = merged_options(options)
  return {} if names == []
  raw = options&.fetch(:raw, false)

  keys = names.map { |name| normalize_key(name, options) }
  keys_index = keys.each_with_index.to_h

  results = {}

  redis.nodes_for(keys).each do |node, key_subset|
    failsafe(:read_multi_entries) do
      node.call("mget", *key_subset).each_with_index do |value, index|
        if value
          results[names[keys_index[key_subset[index]]]] = value
        end
      end
    end
  end

  results.transform_values! { |value| deserialize_entry(value, raw: raw) }
  results.reject! do |name, entry|
    entry.nil? || entry.expired? || entry.mismatched?(normalize_version(name, options))
  end
  results.compact!
  results.transform_values! { |entry| entry&.value }
  results
end

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 324

def read_serialized_entry(key, raw: false, **options)
  failsafe :read_entry do
    command = options[:delete] ? "getdel" : "get"
    redis.node_for(key).call(command, key)
  end
end

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 442

def serialize_entries(entries, **options)
  entries.transform_values do |entry|
    serialize_entry(entry, **options)
  end
end

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 434

def serialize_entry(entry, raw: false, **options)
  if raw
    entry.value.to_s
  else
    super(entry, raw: raw, **options)
  end
end

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 309

def stats
  redis.then { |c| c.info }
end

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 363

def write_entry(key, entry, raw: false, **options)
  write_serialized_entry(key, serialize_entry(entry, raw: raw, **options), raw: raw, **options)
end

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 412

def write_multi_entries(entries, **options)
  return if entries.empty?

  redis.nodes_for(entries.keys).each do |node, keys|
    failsafe :write_multi_entries do
      node.pipelined do |pipeline|
        entries.slice(*keys).each do |key, entry|
          write_entry key, entry, **options, pipeline: pipeline
        end
      end
    end
  end
end

# File 'activesupport/lib/active_support/cache/redis_cache_store.rb', line 367

def write_serialized_entry(key, payload, raw: false, unless_exist: false, expires_in: nil, race_condition_ttl: nil, pipeline: nil, **options)
  # If race condition TTL is in use, ensure that cache entries
  # stick around a bit longer after they would have expired
  # so we can purposefully serve stale entries.
  if race_condition_ttl && expires_in && expires_in > 0 && !raw
    expires_in += 5.minutes
  end

  modifiers = []
  if unless_exist || expires_in
    modifiers << :nx if unless_exist
    modifiers << :px << (1000 * expires_in.to_f).ceil if expires_in
  end

  if pipeline
    pipeline.call("set", key, payload, *modifiers)
  else
    failsafe :write_entry, returning: nil do
      redis.node_for(key).call("set", key, payload, *modifiers) == "OK"
    end
  end
end