Module: Memcached
- Defined in:
- lib/remcached.rb,
lib/remcached/const.rb,
lib/remcached/client.rb,
lib/remcached/packet.rb
Defined Under Namespace
Modules: Commands, Datatypes, Errors, PackArray
Classes: Client, Connection, Packet, Request, Response
Class Method Summary
collapse
-
.add(contents, &callback) ⇒ Object
-
.client_for_key(key) ⇒ Object
-
.delete(contents, &callback) ⇒ Object
-
.get(contents, &callback) ⇒ Object
-
.hash_key(key) ⇒ Object
-
.multi_add(contents_list, &callback) ⇒ Object
-
.multi_delete(contents_list, &callback) ⇒ Object
-
.multi_get(contents_list, &callback) ⇒ Object
-
.multi_operation(request_klass, contents_list, &callback) ⇒ Object
-
.multi_set(contents_list, &callback) ⇒ Object
-
.operation(request_klass, contents, &callback) ⇒ Object
-
.servers=(servers) ⇒ Object
servers
: Array of host:port strings.
-
.set(contents, &callback) ⇒ Object
-
.usable? ⇒ Boolean
-
.usable_clients ⇒ Object
Class Method Details
.add(contents, &callback) ⇒ Object
73
74
75
|
# File 'lib/remcached.rb', line 73
def add(contents, &callback)
operation Request::Add, contents, &callback
end
|
.client_for_key(key) ⇒ Object
38
39
40
41
42
43
44
45
46
|
# File 'lib/remcached.rb', line 38
def client_for_key(key)
usable_clients_ = usable_clients
if usable_clients_.empty?
nil
else
h = hash_key(key) % usable_clients_.length
usable_clients_[h]
end
end
|
.delete(contents, &callback) ⇒ Object
82
83
84
|
# File 'lib/remcached.rb', line 82
def delete(contents, &callback)
operation Request::Delete, contents, &callback
end
|
.get(contents, &callback) ⇒ Object
76
77
78
|
# File 'lib/remcached.rb', line 76
def get(contents, &callback)
operation Request::Get, contents, &callback
end
|
.hash_key(key) ⇒ Object
48
49
50
51
52
53
54
55
56
57
|
# File 'lib/remcached.rb', line 48
def hash_key(key)
hashed = 0
i = 0
key.each_byte do |b|
j = key.length - i - 1 % 4
hashed ^= b << (j * 8)
i += 1
end
hashed
end
|
.multi_add(contents_list, &callback) ⇒ Object
141
142
143
|
# File 'lib/remcached.rb', line 141
def multi_add(contents_list, &callback)
multi_operation Request::Add, contents_list, &callback
end
|
.multi_delete(contents_list, &callback) ⇒ Object
153
154
155
|
# File 'lib/remcached.rb', line 153
def multi_delete(contents_list, &callback)
multi_operation Request::Delete, contents_list, &callback
end
|
.multi_get(contents_list, &callback) ⇒ Object
145
146
147
|
# File 'lib/remcached.rb', line 145
def multi_get(contents_list, &callback)
multi_operation Request::Get, contents_list, &callback
end
|
.multi_operation(request_klass, contents_list, &callback) ⇒ Object
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
# File 'lib/remcached.rb', line 92
def multi_operation(request_klass, contents_list, &callback)
if contents_list.empty?
callback.call []
return self
end
results = {}
client_contents = {}
contents_list.each do |contents|
client = client_for_key(contents[:key])
if client
client_contents[client] ||= []
client_contents[client] << contents
else
puts "no client for #{contents[:key].inspect}"
results[contents[:key]] = {:status => Memcached::Errors::DISCONNECTED}
end
end
clients_pending = client_contents.length
client_contents.each do |client,contents_list|
last_i = contents_list.length - 1
client_results = {}
contents_list.each_with_index do |contents,i|
if i < last_i
request = request_klass::Quiet.new(contents)
client.send_request(request) { |response|
results[contents[:key]] = response
}
else request = request_klass.new(contents)
client.send_request(request) { |response|
results[contents[:key]] = response
clients_pending -= 1
if clients_pending < 1
callback.call results
end
}
end
end
end
self
end
|
.multi_set(contents_list, &callback) ⇒ Object
149
150
151
|
# File 'lib/remcached.rb', line 149
def multi_set(contents_list, &callback)
multi_operation Request::Set, contents_list, &callback
end
|
.operation(request_klass, contents, &callback) ⇒ Object
64
65
66
67
68
69
70
71
|
# File 'lib/remcached.rb', line 64
def operation(request_klass, contents, &callback)
client = client_for_key(contents[:key])
if client
client.send_request request_klass.new(contents), &callback
elsif callback
callback.call :status => Errors::DISCONNECTED
end
end
|
.servers=(servers) ⇒ Object
servers
: Array of host:port strings
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
# File 'lib/remcached.rb', line 9
def servers=(servers)
if defined?(@clients) && @clients
while client = @clients.shift
begin
client.close
rescue Exception
end
end
end
@clients = servers.collect { |server|
host, port = server.split(':')
Client.connect host, (port ? port.to_i : 11211)
}
end
|
.set(contents, &callback) ⇒ Object
79
80
81
|
# File 'lib/remcached.rb', line 79
def set(contents, &callback)
operation Request::Set, contents, &callback
end
|
.usable? ⇒ Boolean
26
27
28
|
# File 'lib/remcached.rb', line 26
def usable?
usable_clients.length > 0
end
|
.usable_clients ⇒ Object
30
31
32
33
34
35
36
|
# File 'lib/remcached.rb', line 30
def usable_clients
unless defined?(@clients) && @clients
[]
else
@clients.select { |client| client.connected? }
end
end
|