Class: Redis::Client

Inherits:
Object
  • Object
show all
Defined in:
lib/redis/client.rb

Constant Summary collapse

DEFAULTS = 
{
  :scheme => "redis",
  :host => "127.0.0.1",
  :port => 6379,
  :path => nil,
  :timeout => 5.0,
  :password => nil,
  :db => 0,
}

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ Client

Returns a new instance of Client.



52
53
54
55
56
57
58
 
# File 'lib/redis/client.rb', line 52

def initialize(options = {})
  @options = _parse_options(options)
  @reconnect = true
  @logger = @options[:logger]
  @connection = nil
  @command_map = {}
end

Instance Attribute Details

#command_map ⇒ Object (readonly)

Returns the value of attribute command_map.



50
51
52
 
# File 'lib/redis/client.rb', line 50

def command_map
  @command_map
end

#connection ⇒ Object (readonly)

Returns the value of attribute connection.



49
50
51
 
# File 'lib/redis/client.rb', line 49

def connection
  @connection
end

#logger ⇒ Object (readonly)

Returns the value of attribute logger.



48
49
50
 
# File 'lib/redis/client.rb', line 48

def logger
  @logger
end

Instance Method Details

#call(command, &block) ⇒ Object 



77
78
79
80
81
82
83
84
85
86
 
# File 'lib/redis/client.rb', line 77

def call(command, &block)
  reply = process([command]) { read }
  raise reply if reply.is_a?(CommandError)

  if block
    block.call(reply)
  else
    reply
  end
end

#call_loop(command) ⇒ Object 



88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/redis/client.rb', line 88

def call_loop(command)
  error = nil

  result = without_socket_timeout do
    process([command]) do
      loop do
        reply = read
        if reply.is_a?(CommandError)
          error = reply
          break
        else
          yield reply
        end
      end
    end
  end

  # Raise error when previous block broke out of the loop.
  raise error if error

  # Result is set to the value that the provided block used to break.
  result
end

#call_pipeline(pipeline) ⇒ Object 



112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/redis/client.rb', line 112

def call_pipeline(pipeline)
  with_reconnect pipeline.with_reconnect? do
    begin
      pipeline.finish(call_pipelined(pipeline.commands))
    rescue ConnectionError => e
      return nil if pipeline.shutdown?
      # Assume the pipeline was sent in one piece, but execution of
      # SHUTDOWN caused none of the replies for commands that were executed
      # prior to it from coming back around.
      raise e
    end
  end
end

#call_pipelined(commands) ⇒ Object 



126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
# File 'lib/redis/client.rb', line 126

def call_pipelined(commands)
  return [] if commands.empty?

  # The method #ensure_connected (called from #process) reconnects once on
  # I/O errors. To make an effort in making sure that commands are not
  # executed more than once, only allow reconnection before the first reply
  # has been read. When an error occurs after the first reply has been
  # read, retrying would re-execute the entire pipeline, thus re-issuing
  # already successfully executed commands. To circumvent this, don't retry
  # after the first reply has been read successfully.

  result = Array.new(commands.size)
  reconnect = @reconnect

  begin
    process(commands) do
      result[0] = read

      @reconnect = false

      (commands.size - 1).times do |i|
        result[i + 1] = read
      end
    end
  ensure
    @reconnect = reconnect
  end

  result
end

#call_without_timeout(command, &blk) ⇒ Object 



157
158
159
160
161
162
163
 
# File 'lib/redis/client.rb', line 157

def call_without_timeout(command, &blk)
  without_socket_timeout do
    call(command, &blk)
  end
rescue ConnectionError
  retry
end

#connect ⇒ Object 



60
61
62
63
64
65
66
67
 
# File 'lib/redis/client.rb', line 60

def connect
  @pid = Process.pid

  establish_connection
  call [:auth, password] if password
  call [:select, db] if db != 0
  self
end

#connected? ⇒ Boolean

Returns:

  • (Boolean) 


182
183
184
 
# File 'lib/redis/client.rb', line 182

def connected?
  connection && connection.connected?
end

#db ⇒ Object 



40
41
42
 
# File 'lib/redis/client.rb', line 40

def db
  @options[:db]
end

#db=(db) ⇒ Object 



44
45
46
 
# File 'lib/redis/client.rb', line 44

def db=(db)
  @options[:db] = db.to_i
end

#disconnect ⇒ Object 



186
187
188
 
# File 'lib/redis/client.rb', line 186

def disconnect
  connection.disconnect if connected?
end

#host ⇒ Object 



20
21
22
 
# File 'lib/redis/client.rb', line 20

def host
  @options[:host]
end

#id ⇒ Object 



69
70
71
 
# File 'lib/redis/client.rb', line 69

def id
  @options[:id] || "redis://#{location}/#{db}"
end

#io ⇒ Object 



195
196
197
198
199
200
201
 
# File 'lib/redis/client.rb', line 195

def io
  yield
rescue TimeoutError
  raise TimeoutError, "Connection timed out"
rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EBADF, Errno::EINVAL => e
  raise ConnectionError, "Connection lost (%s)" % [e.class.name.split("::").last]
end

#location ⇒ Object 



73
74
75
 
# File 'lib/redis/client.rb', line 73

def location
  path || "#{host}:#{port}"
end

#password ⇒ Object 



36
37
38
 
# File 'lib/redis/client.rb', line 36

def password
  @options[:password]
end

#path ⇒ Object 



28
29
30
 
# File 'lib/redis/client.rb', line 28

def path
  @options[:path]
end

#port ⇒ Object 



24
25
26
 
# File 'lib/redis/client.rb', line 24

def port
  @options[:port]
end

#process(commands) ⇒ Object 



165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
 
# File 'lib/redis/client.rb', line 165

def process(commands)
  logging(commands) do
    ensure_connected do
      commands.each do |command|
        if command_map[command.first]
          command = command.dup
          command[0] = command_map[command.first]
        end

        write(command)
      end

      yield if block_given?
    end
  end
end

#read ⇒ Object 



203
204
205
206
207
 
# File 'lib/redis/client.rb', line 203

def read
  io do
    connection.read
  end
end

#reconnect ⇒ Object 



190
191
192
193
 
# File 'lib/redis/client.rb', line 190

def reconnect
  disconnect
  connect
end

#scheme ⇒ Object 



16
17
18
 
# File 'lib/redis/client.rb', line 16

def scheme
  @options[:scheme]
end

#timeout ⇒ Object 



32
33
34
 
# File 'lib/redis/client.rb', line 32

def timeout
  @options[:timeout]
end

#with_reconnect(val = true) ⇒ Object 



226
227
228
229
230
231
232
233
 
# File 'lib/redis/client.rb', line 226

def with_reconnect(val=true)
  begin
    original, @reconnect = @reconnect, val
    yield
  ensure
    @reconnect = original
  end
end

#without_reconnect(&blk) ⇒ Object 



235
236
237
 
# File 'lib/redis/client.rb', line 235

def without_reconnect(&blk)
  with_reconnect(false, &blk)
end

#without_socket_timeout ⇒ Object 



215
216
217
218
219
220
221
222
223
224
 
# File 'lib/redis/client.rb', line 215

def without_socket_timeout
  connect unless connected?

  begin
    connection.timeout = 0
    yield
  ensure
    connection.timeout = timeout if connected?
  end
end

#write(command) ⇒ Object 



209
210
211
212
213
 
# File 'lib/redis/client.rb', line 209

def write(command)
  io do
    connection.write(command)
  end
end