class Dalli::Protocol::Meta

Access point for a single Memcached server, accessed via Memcached's meta protocol. Contains logic for managing connection state to the server (retries, etc), formatting requests to the server, and unpacking responses.

Constants

TERMINATOR

Public Instance Methods

response_processor() click to toggle source
# File lib/dalli/protocol/meta.rb, line 16
def response_processor
  @response_processor ||= ResponseProcessor.new(@connection_manager, @value_marshaller)
end

Private Instance Methods

add(key, value, ttl, options) click to toggle source
# File lib/dalli/protocol/meta.rb, line 67
def add(key, value, ttl, options)
  write_storage_req(:add, key, value, ttl, nil, options)
  response_processor.meta_set_with_cas unless quiet?
end
append(key, value) click to toggle source

rubocop:enable Metrics/ParameterLists

# File lib/dalli/protocol/meta.rb, line 89
def append(key, value)
  write_append_prepend_req(:append, key, value)
  response_processor.meta_set_append_prepend unless quiet?
end
authenticate_connection() click to toggle source
# File lib/dalli/protocol/meta.rb, line 167
def authenticate_connection
  raise Dalli::DalliError, 'Authentication not supported for the meta protocol.'
end
cas(key) click to toggle source

TODO: This is confusing, as there's a cas command in memcached and this isn't it. Maybe rename? Maybe eliminate?

# File lib/dalli/protocol/meta.rb, line 54
def cas(key)
  encoded_key, base64 = KeyRegularizer.encode(key)
  req = RequestFormatter.meta_get(key: encoded_key, value: true, return_cas: true, base64: base64)
  write(req)
  response_processor.meta_get_with_value_and_cas
end
decr(key, count, ttl, initial) click to toggle source

Arithmetic Commands

# File lib/dalli/protocol/meta.rb, line 119
def decr(key, count, ttl, initial)
  decr_incr false, key, count, ttl, initial
end
decr_incr(incr, key, delta, ttl, initial) click to toggle source
# File lib/dalli/protocol/meta.rb, line 127
def decr_incr(incr, key, delta, ttl, initial)
  ttl = initial ? TtlSanitizer.sanitize(ttl) : nil # Only set a TTL if we want to set a value on miss
  encoded_key, base64 = KeyRegularizer.encode(key)
  write(RequestFormatter.meta_arithmetic(key: encoded_key, delta: delta, initial: initial, incr: incr, ttl: ttl,
                                         quiet: quiet?, base64: base64))
  response_processor.decr_incr unless quiet?
end
delete(key, cas) click to toggle source

Delete Commands

# File lib/dalli/protocol/meta.rb, line 110
def delete(key, cas)
  encoded_key, base64 = KeyRegularizer.encode(key)
  req = RequestFormatter.meta_delete(key: encoded_key, cas: cas,
                                     base64: base64, quiet: quiet?)
  write(req)
  response_processor.meta_delete unless quiet?
end
flush(delay = 0) click to toggle source

Other Commands

# File lib/dalli/protocol/meta.rb, line 136
def flush(delay = 0)
  write(RequestFormatter.flush(delay: delay))
  response_processor.flush unless quiet?
end
gat(key, ttl, options = nil) click to toggle source
# File lib/dalli/protocol/meta.rb, line 37
def gat(key, ttl, options = nil)
  ttl = TtlSanitizer.sanitize(ttl)
  encoded_key, base64 = KeyRegularizer.encode(key)
  req = RequestFormatter.meta_get(key: encoded_key, ttl: ttl, base64: base64)
  write(req)
  response_processor.meta_get_with_value(cache_nils: cache_nils?(options))
end
get(key, options = nil) click to toggle source

Retrieval Commands

# File lib/dalli/protocol/meta.rb, line 25
def get(key, options = nil)
  encoded_key, base64 = KeyRegularizer.encode(key)
  req = RequestFormatter.meta_get(key: encoded_key, base64: base64)
  write(req)
  response_processor.meta_get_with_value(cache_nils: cache_nils?(options))
end
incr(key, count, ttl, initial) click to toggle source
# File lib/dalli/protocol/meta.rb, line 123
def incr(key, count, ttl, initial)
  decr_incr true, key, count, ttl, initial
end
noop() click to toggle source

Noop is a keepalive operation but also used to demarcate the end of a set of pipelined commands. We need to read all the responses at once.

# File lib/dalli/protocol/meta.rb, line 143
def noop
  write_noop
  response_processor.consume_all_responses_until_mn
end
prepend(key, value) click to toggle source
# File lib/dalli/protocol/meta.rb, line 94
def prepend(key, value)
  write_append_prepend_req(:prepend, key, value)
  response_processor.meta_set_append_prepend unless quiet?
end
quiet_get_request(key) click to toggle source
# File lib/dalli/protocol/meta.rb, line 32
def quiet_get_request(key)
  encoded_key, base64 = KeyRegularizer.encode(key)
  RequestFormatter.meta_get(key: encoded_key, return_cas: true, base64: base64, quiet: true)
end
replace(key, value, ttl, cas, options) click to toggle source
# File lib/dalli/protocol/meta.rb, line 72
def replace(key, value, ttl, cas, options)
  write_storage_req(:replace, key, value, ttl, cas, options)
  response_processor.meta_set_with_cas unless quiet?
end
reset_stats() click to toggle source
# File lib/dalli/protocol/meta.rb, line 153
def reset_stats
  write(RequestFormatter.stats('reset'))
  response_processor.reset
end
set(key, value, ttl, cas, options) click to toggle source

Storage Commands

# File lib/dalli/protocol/meta.rb, line 62
def set(key, value, ttl, cas, options)
  write_storage_req(:set, key, value, ttl, cas, options)
  response_processor.meta_set_with_cas unless quiet?
end
stats(info = nil) click to toggle source
# File lib/dalli/protocol/meta.rb, line 148
def stats(info = nil)
  write(RequestFormatter.stats(info))
  response_processor.stats
end
touch(key, ttl) click to toggle source
# File lib/dalli/protocol/meta.rb, line 45
def touch(key, ttl)
  encoded_key, base64 = KeyRegularizer.encode(key)
  req = RequestFormatter.meta_get(key: encoded_key, ttl: ttl, value: false, base64: base64)
  write(req)
  response_processor.meta_get_without_value
end
version() click to toggle source
# File lib/dalli/protocol/meta.rb, line 158
def version
  write(RequestFormatter.version)
  response_processor.version
end
write_append_prepend_req(mode, key, value, ttl = nil, cas = nil, _options = {}) click to toggle source

rubocop:disable Metrics/ParameterLists

# File lib/dalli/protocol/meta.rb, line 100
def write_append_prepend_req(mode, key, value, ttl = nil, cas = nil, _options = {})
  ttl = TtlSanitizer.sanitize(ttl) if ttl
  encoded_key, base64 = KeyRegularizer.encode(key)
  req = RequestFormatter.meta_set(key: encoded_key, value: value, base64: base64,
                                  cas: cas, ttl: ttl, mode: mode, quiet: quiet?)
  write(req)
end
write_noop() click to toggle source
# File lib/dalli/protocol/meta.rb, line 163
def write_noop
  write(RequestFormatter.meta_noop)
end
write_storage_req(mode, key, raw_value, ttl = nil, cas = nil, options = {}) click to toggle source

rubocop:disable Metrics/ParameterLists

# File lib/dalli/protocol/meta.rb, line 78
def write_storage_req(mode, key, raw_value, ttl = nil, cas = nil, options = {})
  (value, bitflags) = @value_marshaller.store(key, raw_value, options)
  ttl = TtlSanitizer.sanitize(ttl) if ttl
  encoded_key, base64 = KeyRegularizer.encode(key)
  req = RequestFormatter.meta_set(key: encoded_key, value: value,
                                  bitflags: bitflags, cas: cas,
                                  ttl: ttl, mode: mode, quiet: quiet?, base64: base64)
  write(req)
end