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

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

Multi operations



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 = {}

  # Assemble client connections per keys
  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

  # send requests and wait for responses per client
  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 # last request for this client
        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

Memcached operations



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
        # This is allowed to fail silently
      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

Returns:

  • (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