class Moneta::Adapters::Redis

Redis backend @api public

Public Instance Methods

clear(options = {}) click to toggle source

(see Proxy#clear)

# File lib/moneta/adapters/redis.rb, line 77
def clear(options = {})
  @backend.flushdb
  self
end
close() click to toggle source

(see Proxy#close)

# File lib/moneta/adapters/redis.rb, line 95
def close
  @backend.quit
  nil
end
create(key, value, options = {}) click to toggle source

(see Defaults#create)

# File lib/moneta/adapters/redis.rb, line 83
def create(key, value, options = {})
  expires = expires_value(options, config.expires)

  if @backend.setnx(key, value)
    update_expires(@backend, key, expires)
    true
  else
    false
  end
end
delete(key, options = {}) click to toggle source

(see Proxy#delete)

# File lib/moneta/adapters/redis.rb, line 60
def delete(key, options = {})
  future = nil
  @backend.pipelined do |pipeline|
    future = pipeline.get(key)
    pipeline.del(key)
  end
  future.value
end
each_key() { |k| ... } click to toggle source

(see Proxy#each_key)

# File lib/moneta/adapters/redis.rb, line 34
def each_key(&block)
  return enum_for(:each_key) unless block_given?

  @backend.scan_each { |k| yield(k) }
  self
end
increment(key, amount = 1, options = {}) click to toggle source

(see Proxy#increment)

# File lib/moneta/adapters/redis.rb, line 70
def increment(key, amount = 1, options = {})
  with_expiry_update(key, **options) do |pipeline_handle|
    pipeline_handle.incrby(key, amount)
  end
end
key?(key, options = {}) click to toggle source

(see Proxy#key?)

This method considers false and 0 as “no-expire” and every positive number as a time to live in seconds.

# File lib/moneta/adapters/redis.rb, line 23
def key?(key, options = {})
  with_expiry_update(key, default: nil, **options) do |pipeline_handle|
    if pipeline_handle.respond_to?(:exists?)
      pipeline_handle.exists?(key)
    else
      pipeline_handle.exists(key)
    end
  end
end
load(key, options = {}) click to toggle source

(see Proxy#load)

# File lib/moneta/adapters/redis.rb, line 42
def load(key, options = {})
  with_expiry_update(key, default: nil, **options) do |pipeline_handle|
    pipeline_handle.get(key)
  end
end
merge!(pairs, options = {}) { |key, old_value, new_value| ... } click to toggle source

(see Defaults#merge!)

# File lib/moneta/adapters/redis.rb, line 108
def merge!(pairs, options = {})
  keys = pairs.map { |key, _| key }.to_a
  return self if keys.empty?

  if block_given?
    old_values = @backend.mget(*keys)
    updates = pairs.each_with_index.with_object({}) do |(pair, i), updates|
      old_value = old_values[i]
      if old_value != nil
        key, new_value = pair
        updates[key] = yield(key, old_value, new_value)
      end
    end
    unless updates.empty?
      pairs = if pairs.respond_to?(:merge)
                pairs.merge(updates)
              else
                Hash[pairs.to_a].merge!(updates)
              end
    end
  end

  with_expiry_update(*keys, **options) do |pipeline_handle|
    pipeline_handle.mset(*pairs.to_a.flatten(1))
  end

  self
end
store(key, value, options = {}) click to toggle source

(see Proxy#store)

# File lib/moneta/adapters/redis.rb, line 49
def store(key, value, options = {})
  if expires = expires_value(options)
    Numeric === expires and expires = (expires * 1000).to_i
    @backend.psetex(key, expires, value)
  else
    @backend.set(key, value)
  end
  value
end
values_at(*keys, **options) click to toggle source

(see Defaults#values_at)

# File lib/moneta/adapters/redis.rb, line 101
def values_at(*keys, **options)
  with_expiry_update(*keys, default: nil, **options) do |pipeline_handle|
    pipeline_handle.mget(*keys)
  end
end

Protected Instance Methods

update_expires(pipeline_handle, key, expires) click to toggle source
# File lib/moneta/adapters/redis.rb, line 139
def update_expires(pipeline_handle, key, expires)
  case expires
  when false
    pipeline_handle.persist(key)
  when Numeric
    pipeline_handle.pexpire(key, (expires * 1000).to_i)
  end
end
with_expiry_update(*keys, default: config.expires, **options) { |backend| ... } click to toggle source
# File lib/moneta/adapters/redis.rb, line 148
def with_expiry_update(*keys, default: config.expires, **options)
  expires = expires_value(options, default)
  if expires == nil
    yield(@backend)
  else
    future = nil
    @backend.multi do |pipeline|
      # as of redis 4.6 calling redis methods on the redis client itself
      # is deprecated in favor of a pipeline handle provided by the
      # +multi+ call. This will cause in error in redis >= 5.0.
      #
      # In order to continue supporting redis versions < 4.6, the following
      # fallback has been introduced and can be removed once moneta
      # no longer supports redis < 4.6.

      pipeline_handle = pipeline || @backend
      future = yield(pipeline_handle)
      keys.each { |key| update_expires(pipeline_handle, key, expires) }
    end
    future.value
  end
end