Class: Memcache::Server

Inherits:
Object show all
Defined in:
lib/memcache/server.rb

Direct Known Subclasses

SegmentedServer

Defined Under Namespace

Classes: ClientError, ConnectionError, Error, ServerError

Constant Summary collapse

CONNECT_TIMEOUT = 
1.0
READ_RETRY_DELAY = 
5.0
DEFAULT_PORT = 
11211

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(opts) ⇒ Server

Returns a new instance of Server.



13
14
15
16
17
18
19
 
# File 'lib/memcache/server.rb', line 13

def initialize(opts)
  @host         = opts[:host]
  @port         = opts[:port] || DEFAULT_PORT
  @readonly     = opts[:readonly]
  @strict_reads = opts[:strict_reads]
  @status       = 'NOT CONNECTED'
end

Instance Attribute Details

#host ⇒ Object (readonly)

Returns the value of attribute host.



11
12
13
 
# File 'lib/memcache/server.rb', line 11

def host
  @host
end

#port ⇒ Object (readonly)

Returns the value of attribute port.



11
12
13
 
# File 'lib/memcache/server.rb', line 11

def port
  @port
end

#retry_at ⇒ Object (readonly)

Returns the value of attribute retry_at.



11
12
13
 
# File 'lib/memcache/server.rb', line 11

def retry_at
  @retry_at
end

#status ⇒ Object (readonly)

Returns the value of attribute status.



11
12
13
 
# File 'lib/memcache/server.rb', line 11

def status
  @status
end

Instance Method Details

#add(key, value, expiry = 0, flags = 0) ⇒ Object 



146
147
148
149
150
 
# File 'lib/memcache/server.rb', line 146

def add(key, value, expiry = 0, flags = 0)
  check_writable!
  response = write_command("add #{key} #{flags.to_i} #{expiry.to_i} #{value.to_s.size}", value)
  response == "STORED\r\n" ? value : nil
end

#alive? ⇒ Boolean

Returns:

  • (Boolean) 


33
34
35
 
# File 'lib/memcache/server.rb', line 33

def alive?
  @retry_at.nil? or @retry_at < Time.now
end

#append(key, value) ⇒ Object 



158
159
160
161
162
 
# File 'lib/memcache/server.rb', line 158

def append(key, value)
  check_writable!
  response = write_command("append #{key} 0 0 #{value.to_s.size}", value)
  response == "STORED\r\n"
end

#cas(key, value, cas, expiry = 0, flags = 0) ⇒ Object 



140
141
142
143
144
 
# File 'lib/memcache/server.rb', line 140

def cas(key, value, cas, expiry = 0, flags = 0)
  check_writable!
  response = write_command("cas #{key} #{flags.to_i} #{expiry.to_i} #{value.to_s.size} #{cas.to_i}", value)
  response == "STORED\r\n" ? value : nil
end

#clone ⇒ Object 



21
22
23
 
# File 'lib/memcache/server.rb', line 21

def clone
  self.class.new(:host => host, :port => port, :readonly => readonly?, :strict_reads => strict_reads?)
end

#close(error = nil) ⇒ Object 



45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/memcache/server.rb', line 45

def close(error = nil)
  # Close the socket. If there is an error, mark the server dead.
  @socket.close if @socket and not @socket.closed?
  @socket = nil
  
  if error
    @retry_at = Time.now + READ_RETRY_DELAY
    @status   = "DEAD: %s: %s, will retry at %s" % [error.class, error.message, @retry_at]
  else
    @retry_at = nil
    @status   = "NOT CONNECTED"
  end
end

#count ⇒ Object 



75
76
77
 
# File 'lib/memcache/server.rb', line 75

def count
  stats['curr_items']
end

#decr(key, amount = 1) ⇒ Object

Raises:



121
122
123
124
125
126
 
# File 'lib/memcache/server.rb', line 121

def decr(key, amount = 1)
  check_writable!
  raise Error, "decr requires unsigned value" if amount < 0
  response = write_command("decr #{key} #{amount}")
  response == "NOT_FOUND\r\n" ? nil : response.to_i
end

#delete(key) ⇒ Object 



128
129
130
131
 
# File 'lib/memcache/server.rb', line 128

def delete(key)
  check_writable!
  write_command("delete #{key}") == "DELETED\r\n" ? true : nil
end

#flush_all(delay = nil) ⇒ Object Also known as: clear 



79
80
81
82
 
# File 'lib/memcache/server.rb', line 79

def flush_all(delay = nil)
  check_writable!
  write_command("flush_all #{delay}")
end

#get(keys, cas = false) ⇒ Object 



90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/memcache/server.rb', line 90

def get(keys, cas = false)
  return get([keys], cas)[keys.to_s] unless keys.kind_of?(Array)
  return {} if keys.empty?

  method = cas ? 'gets' : 'get'

  results = {}
  read_command("#{method} #{keys.join(' ')}") do |response|
    if cas
      key, flags, length, cas = match_response!(response, /^VALUE ([^\s]+) ([^\s]+) ([^\s]+) ([^\s]+)/)
    else
      key, flags, length = match_response!(response, /^VALUE ([^\s]+) ([^\s]+) ([^\s]+)/)
    end
      
    value = socket.read(length.to_i)
    match_response!(socket.read(2), "\r\n")

    value.memcache_flags = flags.to_i
    value.memcache_cas   = cas
    results[key] = value
  end
  results
end

#gets(keys) ⇒ Object 



86
87
88
 
# File 'lib/memcache/server.rb', line 86

def gets(keys)
  get(keys, true)
end

#incr(key, amount = 1) ⇒ Object

Raises:



114
115
116
117
118
119
 
# File 'lib/memcache/server.rb', line 114

def incr(key, amount = 1)
  check_writable!
  raise Error, "incr requires unsigned value" if amount < 0
  response = write_command("incr #{key} #{amount}")
  response == "NOT_FOUND\r\n" ? nil : response.to_i
end

#inspect ⇒ Object 



25
26
27
 
# File 'lib/memcache/server.rb', line 25

def inspect
  "<Memcache::Server: %s:%d (%s)>" % [@host, @port, @status]
end

#name ⇒ Object 



29
30
31
 
# File 'lib/memcache/server.rb', line 29

def name
  "#{host}:#{port}"
end

#prepend(key, value) ⇒ Object 



164
165
166
167
168
 
# File 'lib/memcache/server.rb', line 164

def prepend(key, value)
  check_writable!
  response = write_command("prepend #{key} 0 0 #{value.to_s.size}", value)
  response == "STORED\r\n"
end

#readonly? ⇒ Boolean

Returns:

  • (Boolean) 


37
38
39
 
# File 'lib/memcache/server.rb', line 37

def readonly?
  @readonly
end

#replace(key, value, expiry = 0, flags = 0) ⇒ Object 



152
153
154
155
156
 
# File 'lib/memcache/server.rb', line 152

def replace(key, value, expiry = 0, flags = 0)
  check_writable!
  response = write_command("replace #{key} #{flags.to_i} #{expiry.to_i} #{value.to_s.size}", value)
  response == "STORED\r\n" ? value : nil
end

#set(key, value, expiry = 0, flags = 0) ⇒ Object 



133
134
135
136
137
138
 
# File 'lib/memcache/server.rb', line 133

def set(key, value, expiry = 0, flags = 0)
  return delete(key) if value.nil?
  check_writable!
  write_command("set #{key} #{flags.to_i} #{expiry.to_i} #{value.to_s.size}", value)
  value
end

#stats ⇒ Object 



59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
# File 'lib/memcache/server.rb', line 59

def stats
  stats = {}
  read_command('stats') do |response|
    key, value = match_response!(response, /^STAT ([\w]+) (-?[\w\.\:]+)/)

    if ['rusage_user', 'rusage_system'].include?(key)
      seconds, microseconds = value.split(/:/, 2)
      microseconds ||= 0
      stats[key] = Float(seconds) + (Float(microseconds) / 1_000_000)
    else
      stats[key] = (value =~ /^-?\d+$/ ? value.to_i : value)
    end
  end
  stats
end

#strict_reads? ⇒ Boolean

Returns:

  • (Boolean) 


41
42
43
 
# File 'lib/memcache/server.rb', line 41

def strict_reads?
  @strict_reads
end