Class: Dalli::Protocol::Meta::RequestFormatter

Inherits:
Object
  • Object
show all
Defined in:
lib/dalli/protocol/meta/request_formatter.rb

Overview

Class that encapsulates logic for formatting meta protocol requests to memcached.

Class Method Summary collapse

Class Method Details

.cas_string(cas) ⇒ Object

rubocop:enable Metrics/MethodLength



107
108
109
110
 
# File 'lib/dalli/protocol/meta/request_formatter.rb', line 107

def self.cas_string(cas)
  cas = parse_to_64_bit_int(cas, nil)
  cas.nil? || cas.zero? ? '' : " C#{cas}"
end

.flush(delay: nil, quiet: false) ⇒ Object 



77
78
79
80
81
82
 
# File 'lib/dalli/protocol/meta/request_formatter.rb', line 77

def self.flush(delay: nil, quiet: false)
  cmd = +'flush_all'
  cmd << " #{parse_to_64_bit_int(delay, 0)}" if delay
  cmd << ' noreply' if quiet
  cmd + TERMINATOR
end

.meta_arithmetic(key:, delta:, initial:, incr: true, cas: nil, ttl: nil, base64: false, quiet: false) ⇒ Object 



52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/dalli/protocol/meta/request_formatter.rb', line 52

def self.meta_arithmetic(key:, delta:, initial:, incr: true, cas: nil, ttl: nil, base64: false, quiet: false)
  cmd = "ma #{key} v"
  cmd << ' b' if base64
  cmd << " D#{delta}" if delta
  cmd << " J#{initial}" if initial
  # Always set a TTL if an initial value is specified
  cmd << " N#{ttl || 0}" if ttl || initial
  cmd << cas_string(cas)
  cmd << ' q' if quiet
  cmd << " M#{incr ? 'I' : 'D'}"
  cmd + TERMINATOR
end

.meta_delete(key:, cas: nil, ttl: nil, base64: false, quiet: false) ⇒ Object 



43
44
45
46
47
48
49
50
 
# File 'lib/dalli/protocol/meta/request_formatter.rb', line 43

def self.meta_delete(key:, cas: nil, ttl: nil, base64: false, quiet: false)
  cmd = "md #{key}"
  cmd << ' b' if base64
  cmd << cas_string(cas)
  cmd << " T#{ttl}" if ttl
  cmd << ' q' if quiet
  cmd + TERMINATOR
end

.meta_get(key:, value: true, return_cas: false, ttl: nil, base64: false, quiet: false) ⇒ Object

Since these are string construction methods, we’re going to disable these Rubocop directives. We really can’t make this construction much simpler, and introducing an intermediate object seems like overkill.

rubocop:disable Metrics/CyclomaticComplexity rubocop:disable Metrics/MethodLength rubocop:disable Metrics/ParameterLists rubocop:disable Metrics/PerceivedComplexity



19
20
21
22
23
24
25
26
27
 
# File 'lib/dalli/protocol/meta/request_formatter.rb', line 19

def self.meta_get(key:, value: true, return_cas: false, ttl: nil, base64: false, quiet: false)
  cmd = "mg #{key}"
  cmd << ' v f' if value
  cmd << ' c' if return_cas
  cmd << ' b' if base64
  cmd << " T#{ttl}" if ttl
  cmd << ' k q s' if quiet # Return the key in the response if quiet
  cmd + TERMINATOR
end

.meta_noop ⇒ Object

rubocop:enable Metrics/CyclomaticComplexity rubocop:enable Metrics/MethodLength rubocop:enable Metrics/ParameterLists rubocop:enable Metrics/PerceivedComplexity



69
70
71
 
# File 'lib/dalli/protocol/meta/request_formatter.rb', line 69

def self.meta_noop
  "mn#{TERMINATOR}"
end

.meta_set(key:, value:, bitflags: nil, cas: nil, ttl: nil, mode: :set, base64: false, quiet: false) ⇒ Object 



29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/dalli/protocol/meta/request_formatter.rb', line 29

def self.meta_set(key:, value:, bitflags: nil, cas: nil, ttl: nil, mode: :set, base64: false, quiet: false)
  cmd = "ms #{key} #{value.bytesize}"
  cmd << ' c' unless %i[append prepend].include?(mode)
  cmd << ' b' if base64
  cmd << " F#{bitflags}" if bitflags
  cmd << cas_string(cas)
  cmd << " T#{ttl}" if ttl
  cmd << " M#{mode_to_token(mode)}"
  cmd << ' q' if quiet
  cmd << TERMINATOR
  cmd << value
  cmd + TERMINATOR
end

.mode_to_token(mode) ⇒ Object

rubocop:disable Metrics/MethodLength



91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/dalli/protocol/meta/request_formatter.rb', line 91

def self.mode_to_token(mode)
  case mode
  when :add
    'E'
  when :replace
    'R'
  when :append
    'A'
  when :prepend
    'P'
  else
    'S'
  end
end

.parse_to_64_bit_int(val, default) ⇒ Object 



112
113
114
115
116
117
 
# File 'lib/dalli/protocol/meta/request_formatter.rb', line 112

def self.parse_to_64_bit_int(val, default)
  val.nil? ? nil : Integer(val)
rescue ArgumentError
  # Sanitize to default if it isn't parsable as an integer
  default
end

.stats(arg = nil) ⇒ Object 



84
85
86
87
88
 
# File 'lib/dalli/protocol/meta/request_formatter.rb', line 84

def self.stats(arg = nil)
  cmd = +'stats'
  cmd << " #{arg}" if arg
  cmd + TERMINATOR
end

.version ⇒ Object 



73
74
75
 
# File 'lib/dalli/protocol/meta/request_formatter.rb', line 73

def self.version
  "version#{TERMINATOR}"
end