mirror of
https://github.com/fluencelabs/redis
synced 2025-06-21 04:51:32 +00:00
client libraries synched in git
This commit is contained in:
antirez
@ -9,10 +9,7 @@ class Redis
|
||||
@commands = []
|
||||
end
|
||||
|
||||
def get_response
|
||||
end
|
||||
|
||||
def write(data)
|
||||
def execute_command(data)
|
||||
@commands << data
|
||||
write_and_read if @commands.size >= BUFFER_SIZE
|
||||
end
|
||||
@ -22,10 +19,10 @@ class Redis
|
||||
end
|
||||
|
||||
def write_and_read
|
||||
@redis.write @commands.join
|
||||
@redis.execute_command(@commands.join, true)
|
||||
@redis.read_socket
|
||||
@commands.clear
|
||||
end
|
||||
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
@ -3,14 +3,15 @@ require 'set'
|
||||
require File.join(File.dirname(__FILE__),'server')
|
||||
require File.join(File.dirname(__FILE__),'pipeline')
|
||||
|
||||
|
||||
class RedisError < StandardError
|
||||
end
|
||||
class RedisRenameError < StandardError
|
||||
end
|
||||
|
||||
class Redis
|
||||
ERR = "-".freeze
|
||||
OK = 'OK'.freeze
|
||||
PONG = 'PONG'.freeze
|
||||
SINGLE = '+'.freeze
|
||||
BULK = '$'.freeze
|
||||
MULTI = '*'.freeze
|
||||
@ -18,22 +19,21 @@ class Redis
|
||||
|
||||
attr_reader :server
|
||||
|
||||
|
||||
def initialize(opts={})
|
||||
@opts = {:host => 'localhost', :port => '6379', :db => 0}.merge(opts)
|
||||
$debug = @opts[:debug]
|
||||
@db = @opts[:db]
|
||||
@server = Server.new(@opts[:host], @opts[:port], (@opts[:timeout]||10))
|
||||
end
|
||||
|
||||
|
||||
def pipelined
|
||||
pipeline = Pipeline.new(self)
|
||||
yield pipeline
|
||||
pipeline.finish
|
||||
end
|
||||
|
||||
|
||||
def to_s
|
||||
"#{host}:#{port}"
|
||||
"#{host}:#{port} -> #{@db}"
|
||||
end
|
||||
|
||||
def port
|
||||
@ -44,76 +44,42 @@ class Redis
|
||||
@opts[:host]
|
||||
end
|
||||
|
||||
def with_socket_management(server, &block)
|
||||
begin
|
||||
socket = server.socket
|
||||
block.call(socket)
|
||||
#Timeout or server down
|
||||
rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNREFUSED, Timeout::Error => e
|
||||
server.close
|
||||
puts "Client (#{server.inspect}) disconnected from server: #{e.inspect}\n" if $debug
|
||||
retry
|
||||
#Server down
|
||||
rescue NoMethodError => e
|
||||
puts "Client (#{server.inspect}) tryin server that is down: #{e.inspect}\n Dying!" if $debug
|
||||
raise Errno::ECONNREFUSED
|
||||
#exit
|
||||
end
|
||||
end
|
||||
|
||||
def monitor
|
||||
with_socket_management(@server) do |socket|
|
||||
trap("INT") { puts "\nGot ^C! Dying!"; exit }
|
||||
write "MONITOR\r\n"
|
||||
puts "Now Monitoring..."
|
||||
socket.read(12)
|
||||
loop do
|
||||
x = socket.gets
|
||||
puts x unless x.nil?
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def quit
|
||||
write "QUIT\r\n"
|
||||
execute_command("QUIT\r\n", true)
|
||||
end
|
||||
|
||||
|
||||
def ping
|
||||
execute_command("PING\r\n") == PONG
|
||||
end
|
||||
|
||||
def select_db(index)
|
||||
@db = index
|
||||
write "SELECT #{index}\r\n"
|
||||
get_response
|
||||
execute_command("SELECT #{index}\r\n")
|
||||
end
|
||||
|
||||
def flush_db
|
||||
write "FLUSHDB\r\n"
|
||||
get_response == OK
|
||||
execute_command("FLUSHDB\r\n") == OK
|
||||
end
|
||||
|
||||
def flush_all
|
||||
ensure_retry do
|
||||
puts "Warning!\nFlushing *ALL* databases!\n5 Seconds to Hit ^C!"
|
||||
trap('INT') {quit; return false}
|
||||
sleep 5
|
||||
write "FLUSHALL\r\n"
|
||||
get_response == OK
|
||||
end
|
||||
puts "Warning!\nFlushing *ALL* databases!\n5 Seconds to Hit ^C!"
|
||||
trap('INT') {quit; return false}
|
||||
sleep 5
|
||||
execute_command("FLUSHALL\r\n") == OK
|
||||
end
|
||||
|
||||
def last_save
|
||||
write "LASTSAVE\r\n"
|
||||
get_response.to_i
|
||||
execute_command("LASTSAVE\r\n").to_i
|
||||
end
|
||||
|
||||
def bgsave
|
||||
write "BGSAVE\r\n"
|
||||
get_response == OK
|
||||
execute_command("BGSAVE\r\n") == OK
|
||||
end
|
||||
|
||||
def info
|
||||
info = {}
|
||||
write("INFO\r\n")
|
||||
x = get_response
|
||||
x.each do |kv|
|
||||
x = execute_command("INFO\r\n")
|
||||
x.each_line do |kv|
|
||||
k,v = kv.split(':', 2)
|
||||
k,v = k.chomp, v = v.chomp
|
||||
info[k.to_sym] = v
|
||||
@ -121,6 +87,231 @@ class Redis
|
||||
info
|
||||
end
|
||||
|
||||
def keys(glob)
|
||||
execute_command("KEYS #{glob}\r\n").split(' ')
|
||||
end
|
||||
|
||||
def rename!(oldkey, newkey)
|
||||
execute_command("RENAME #{oldkey} #{newkey}\r\n")
|
||||
end
|
||||
|
||||
def rename(oldkey, newkey)
|
||||
case execute_command("RENAMENX #{oldkey} #{newkey}\r\n")
|
||||
when -1
|
||||
raise RedisRenameError, "source key: #{oldkey} does not exist"
|
||||
when 0
|
||||
raise RedisRenameError, "target key: #{oldkey} already exists"
|
||||
when -3
|
||||
raise RedisRenameError, "source and destination keys are the same"
|
||||
when 1
|
||||
true
|
||||
end
|
||||
end
|
||||
|
||||
def key?(key)
|
||||
execute_command("EXISTS #{key}\r\n") == 1
|
||||
end
|
||||
|
||||
def delete(key)
|
||||
execute_command("DEL #{key}\r\n") == 1
|
||||
end
|
||||
|
||||
def [](key)
|
||||
get(key)
|
||||
end
|
||||
|
||||
def get(key)
|
||||
execute_command("GET #{key}\r\n")
|
||||
end
|
||||
|
||||
def mget(*keys)
|
||||
execute_command("MGET #{keys.join(' ')}\r\n")
|
||||
end
|
||||
|
||||
def incr(key, increment=nil)
|
||||
if increment
|
||||
execute_command("INCRBY #{key} #{increment}\r\n")
|
||||
else
|
||||
execute_command("INCR #{key}\r\n")
|
||||
end
|
||||
end
|
||||
|
||||
def decr(key, decrement=nil)
|
||||
if decrement
|
||||
execute_command("DECRBY #{key} #{decrement}\r\n")
|
||||
else
|
||||
execute_command("DECR #{key}\r\n")
|
||||
end
|
||||
end
|
||||
|
||||
def randkey
|
||||
execute_command("RANDOMKEY\r\n")
|
||||
end
|
||||
|
||||
def list_length(key)
|
||||
case i = execute_command("LLEN #{key}\r\n")
|
||||
when -2
|
||||
raise RedisError, "key: #{key} does not hold a list value"
|
||||
else
|
||||
i
|
||||
end
|
||||
end
|
||||
|
||||
def type?(key)
|
||||
execute_command("TYPE #{key}\r\n")
|
||||
end
|
||||
|
||||
def push_tail(key, val)
|
||||
execute_command("RPUSH #{key} #{value_to_wire(val)}\r\n")
|
||||
end
|
||||
|
||||
def push_head(key, val)
|
||||
execute_command("LPUSH #{key} #{value_to_wire(val)}\r\n")
|
||||
end
|
||||
|
||||
def pop_head(key)
|
||||
execute_command("LPOP #{key}\r\n")
|
||||
end
|
||||
|
||||
def pop_tail(key)
|
||||
execute_command("RPOP #{key}\r\n")
|
||||
end
|
||||
|
||||
def list_set(key, index, val)
|
||||
execute_command("LSET #{key} #{index} #{value_to_wire(val)}\r\n") == OK
|
||||
end
|
||||
|
||||
def list_range(key, start, ending)
|
||||
execute_command("LRANGE #{key} #{start} #{ending}\r\n")
|
||||
end
|
||||
|
||||
def list_trim(key, start, ending)
|
||||
execute_command("LTRIM #{key} #{start} #{ending}\r\n")
|
||||
end
|
||||
|
||||
def list_index(key, index)
|
||||
execute_command("LINDEX #{key} #{index}\r\n")
|
||||
end
|
||||
|
||||
def list_rm(key, count, val)
|
||||
case num = execute_command("LREM #{key} #{count} #{value_to_wire(val)}\r\n")
|
||||
when -1
|
||||
raise RedisError, "key: #{key} does not exist"
|
||||
when -2
|
||||
raise RedisError, "key: #{key} does not hold a list value"
|
||||
else
|
||||
num
|
||||
end
|
||||
end
|
||||
|
||||
def set_add(key, member)
|
||||
case execute_command("SADD #{key} #{value_to_wire(member)}\r\n")
|
||||
when 1
|
||||
true
|
||||
when 0
|
||||
false
|
||||
when -2
|
||||
raise RedisError, "key: #{key} contains a non set value"
|
||||
end
|
||||
end
|
||||
|
||||
def set_delete(key, member)
|
||||
case execute_command("SREM #{key} #{value_to_wire(member)}\r\n")
|
||||
when 1
|
||||
true
|
||||
when 0
|
||||
false
|
||||
when -2
|
||||
raise RedisError, "key: #{key} contains a non set value"
|
||||
end
|
||||
end
|
||||
|
||||
def set_count(key)
|
||||
case i = execute_command("SCARD #{key}\r\n")
|
||||
when -2
|
||||
raise RedisError, "key: #{key} contains a non set value"
|
||||
else
|
||||
i
|
||||
end
|
||||
end
|
||||
|
||||
def set_member?(key, member)
|
||||
case execute_command("SISMEMBER #{key} #{value_to_wire(member)}\r\n")
|
||||
when 1
|
||||
true
|
||||
when 0
|
||||
false
|
||||
when -2
|
||||
raise RedisError, "key: #{key} contains a non set value"
|
||||
end
|
||||
end
|
||||
|
||||
def set_members(key)
|
||||
Set.new(execute_command("SMEMBERS #{key}\r\n"))
|
||||
end
|
||||
|
||||
def set_intersect(*keys)
|
||||
Set.new(execute_command("SINTER #{keys.join(' ')}\r\n"))
|
||||
end
|
||||
|
||||
def set_inter_store(destkey, *keys)
|
||||
execute_command("SINTERSTORE #{destkey} #{keys.join(' ')}\r\n")
|
||||
end
|
||||
|
||||
def set_union(*keys)
|
||||
Set.new(execute_command("SUNION #{keys.join(' ')}\r\n"))
|
||||
end
|
||||
|
||||
def set_union_store(destkey, *keys)
|
||||
execute_command("SUNIONSTORE #{destkey} #{keys.join(' ')}\r\n")
|
||||
end
|
||||
|
||||
def set_diff(*keys)
|
||||
Set.new(execute_command("SDIFF #{keys.join(' ')}\r\n"))
|
||||
end
|
||||
|
||||
def set_diff_store(destkey, *keys)
|
||||
execute_command("SDIFFSTORE #{destkey} #{keys.join(' ')}\r\n")
|
||||
end
|
||||
|
||||
def set_move(srckey, destkey, member)
|
||||
execute_command("SMOVE #{srckey} #{destkey} #{value_to_wire(member)}\r\n") == 1
|
||||
end
|
||||
|
||||
def sort(key, opts={})
|
||||
cmd = "SORT #{key}"
|
||||
cmd << " BY #{opts[:by]}" if opts[:by]
|
||||
cmd << " GET #{[opts[:get]].flatten * ' GET '}" if opts[:get]
|
||||
cmd << " INCR #{opts[:incr]}" if opts[:incr]
|
||||
cmd << " DEL #{opts[:del]}" if opts[:del]
|
||||
cmd << " DECR #{opts[:decr]}" if opts[:decr]
|
||||
cmd << " #{opts[:order]}" if opts[:order]
|
||||
cmd << " LIMIT #{opts[:limit].join(' ')}" if opts[:limit]
|
||||
cmd << "\r\n"
|
||||
execute_command(cmd)
|
||||
end
|
||||
|
||||
def []=(key, val)
|
||||
set(key,val)
|
||||
end
|
||||
|
||||
def set(key, val, expiry=nil)
|
||||
s = execute_command("SET #{key} #{value_to_wire(val)}\r\n") == OK
|
||||
return expire(key, expiry) if s && expiry
|
||||
s
|
||||
end
|
||||
|
||||
def dbsize
|
||||
execute_command("DBSIZE\r\n")
|
||||
end
|
||||
|
||||
def expire(key, expiry=nil)
|
||||
execute_command("EXPIRE #{key} #{expiry}\r\n") == 1
|
||||
end
|
||||
|
||||
def set_unless_exists(key, val)
|
||||
execute_command("SETNX #{key} #{value_to_wire(val)}\r\n") == 1
|
||||
end
|
||||
|
||||
def bulk_reply
|
||||
begin
|
||||
@ -134,265 +325,15 @@ class Redis
|
||||
end
|
||||
|
||||
def write(data)
|
||||
with_socket_management(@server) do |socket|
|
||||
puts "writing: #{data}" if $debug
|
||||
socket.write(data)
|
||||
end
|
||||
puts "writing: #{data}" if $debug
|
||||
@socket.write(data)
|
||||
end
|
||||
|
||||
def fetch(len)
|
||||
with_socket_management(@server) do |socket|
|
||||
len = [0, len.to_i].max
|
||||
res = socket.read(len + 2)
|
||||
res = res.chomp if res
|
||||
res
|
||||
end
|
||||
end
|
||||
|
||||
def read(length = read_proto)
|
||||
with_socket_management(@server) do |socket|
|
||||
res = socket.read(length)
|
||||
puts "read is #{res.inspect}" if $debug
|
||||
res
|
||||
end
|
||||
end
|
||||
|
||||
def keys(glob)
|
||||
write "KEYS #{glob}\r\n"
|
||||
get_response.split(' ')
|
||||
end
|
||||
|
||||
def rename!(oldkey, newkey)
|
||||
write "RENAME #{oldkey} #{newkey}\r\n"
|
||||
get_response
|
||||
end
|
||||
|
||||
def rename(oldkey, newkey)
|
||||
write "RENAMENX #{oldkey} #{newkey}\r\n"
|
||||
case get_response
|
||||
when -1
|
||||
raise RedisRenameError, "source key: #{oldkey} does not exist"
|
||||
when 0
|
||||
raise RedisRenameError, "target key: #{oldkey} already exists"
|
||||
when -3
|
||||
raise RedisRenameError, "source and destination keys are the same"
|
||||
when 1
|
||||
true
|
||||
end
|
||||
end
|
||||
|
||||
def key?(key)
|
||||
write "EXISTS #{key}\r\n"
|
||||
get_response == 1
|
||||
end
|
||||
|
||||
def delete(key)
|
||||
write "DEL #{key}\r\n"
|
||||
get_response == 1
|
||||
end
|
||||
|
||||
def [](key)
|
||||
get(key)
|
||||
end
|
||||
|
||||
def get(key)
|
||||
write "GET #{key}\r\n"
|
||||
get_response
|
||||
end
|
||||
|
||||
def mget(*keys)
|
||||
write "MGET #{keys.join(' ')}\r\n"
|
||||
get_response
|
||||
end
|
||||
|
||||
def incr(key, increment=nil)
|
||||
if increment
|
||||
write "INCRBY #{key} #{increment}\r\n"
|
||||
else
|
||||
write "INCR #{key}\r\n"
|
||||
end
|
||||
get_response
|
||||
end
|
||||
|
||||
def decr(key, decrement=nil)
|
||||
if decrement
|
||||
write "DECRBY #{key} #{decrement}\r\n"
|
||||
else
|
||||
write "DECR #{key}\r\n"
|
||||
end
|
||||
get_response
|
||||
end
|
||||
|
||||
def randkey
|
||||
write "RANDOMKEY\r\n"
|
||||
get_response
|
||||
end
|
||||
|
||||
def list_length(key)
|
||||
write "LLEN #{key}\r\n"
|
||||
case i = get_response
|
||||
when -2
|
||||
raise RedisError, "key: #{key} does not hold a list value"
|
||||
else
|
||||
i
|
||||
end
|
||||
end
|
||||
|
||||
def type?(key)
|
||||
write "TYPE #{key}\r\n"
|
||||
get_response
|
||||
end
|
||||
|
||||
def push_tail(key, string)
|
||||
write "RPUSH #{key} #{string.to_s.size}\r\n#{string.to_s}\r\n"
|
||||
get_response
|
||||
end
|
||||
|
||||
def push_head(key, string)
|
||||
write "LPUSH #{key} #{string.to_s.size}\r\n#{string.to_s}\r\n"
|
||||
get_response
|
||||
end
|
||||
|
||||
def pop_head(key)
|
||||
write "LPOP #{key}\r\n"
|
||||
get_response
|
||||
end
|
||||
|
||||
def pop_tail(key)
|
||||
write "RPOP #{key}\r\n"
|
||||
get_response
|
||||
end
|
||||
|
||||
def list_set(key, index, val)
|
||||
write "LSET #{key} #{index} #{val.to_s.size}\r\n#{val}\r\n"
|
||||
get_response == OK
|
||||
end
|
||||
|
||||
def list_range(key, start, ending)
|
||||
write "LRANGE #{key} #{start} #{ending}\r\n"
|
||||
get_response
|
||||
end
|
||||
|
||||
def list_trim(key, start, ending)
|
||||
write "LTRIM #{key} #{start} #{ending}\r\n"
|
||||
get_response
|
||||
end
|
||||
|
||||
def list_index(key, index)
|
||||
write "LINDEX #{key} #{index}\r\n"
|
||||
get_response
|
||||
end
|
||||
|
||||
def list_rm(key, count, value)
|
||||
write "LREM #{key} #{count} #{value.to_s.size}\r\n#{value}\r\n"
|
||||
case num = get_response
|
||||
when -1
|
||||
raise RedisError, "key: #{key} does not exist"
|
||||
when -2
|
||||
raise RedisError, "key: #{key} does not hold a list value"
|
||||
else
|
||||
num
|
||||
end
|
||||
end
|
||||
|
||||
def set_add(key, member)
|
||||
write "SADD #{key} #{member.to_s.size}\r\n#{member}\r\n"
|
||||
case get_response
|
||||
when 1
|
||||
true
|
||||
when 0
|
||||
false
|
||||
when -2
|
||||
raise RedisError, "key: #{key} contains a non set value"
|
||||
end
|
||||
end
|
||||
|
||||
def set_delete(key, member)
|
||||
write "SREM #{key} #{member.to_s.size}\r\n#{member}\r\n"
|
||||
case get_response
|
||||
when 1
|
||||
true
|
||||
when 0
|
||||
false
|
||||
when -2
|
||||
raise RedisError, "key: #{key} contains a non set value"
|
||||
end
|
||||
end
|
||||
|
||||
def set_count(key)
|
||||
write "SCARD #{key}\r\n"
|
||||
case i = get_response
|
||||
when -2
|
||||
raise RedisError, "key: #{key} contains a non set value"
|
||||
else
|
||||
i
|
||||
end
|
||||
end
|
||||
|
||||
def set_member?(key, member)
|
||||
write "SISMEMBER #{key} #{member.to_s.size}\r\n#{member}\r\n"
|
||||
case get_response
|
||||
when 1
|
||||
true
|
||||
when 0
|
||||
false
|
||||
when -2
|
||||
raise RedisError, "key: #{key} contains a non set value"
|
||||
end
|
||||
end
|
||||
|
||||
def set_members(key)
|
||||
write "SMEMBERS #{key}\r\n"
|
||||
Set.new(get_response)
|
||||
end
|
||||
|
||||
def set_intersect(*keys)
|
||||
write "SINTER #{keys.join(' ')}\r\n"
|
||||
Set.new(get_response)
|
||||
end
|
||||
|
||||
def set_inter_store(destkey, *keys)
|
||||
write "SINTERSTORE #{destkey} #{keys.join(' ')}\r\n"
|
||||
get_response
|
||||
end
|
||||
|
||||
def set_union(*keys)
|
||||
write "SUNION #{keys.join(' ')}\r\n"
|
||||
Set.new(get_response)
|
||||
end
|
||||
|
||||
def set_union_store(destkey, *keys)
|
||||
write "SUNIONSTORE #{destkey} #{keys.join(' ')}\r\n"
|
||||
get_response
|
||||
end
|
||||
|
||||
def set_diff(*keys)
|
||||
write "SDIFF #{keys.join(' ')}\r\n"
|
||||
Set.new(get_response)
|
||||
end
|
||||
|
||||
def set_diff_store(destkey, *keys)
|
||||
write "SDIFFSTORE #{destkey} #{keys.join(' ')}\r\n"
|
||||
get_response
|
||||
end
|
||||
|
||||
def set_move(srckey, destkey, member)
|
||||
write "SMOVE #{srckey} #{destkey} #{member.to_s.size}\r\n#{member}\r\n"
|
||||
get_response == 1
|
||||
end
|
||||
|
||||
def sort(key, opts={})
|
||||
cmd = "SORT #{key}"
|
||||
cmd << " BY #{opts[:by]}" if opts[:by]
|
||||
cmd << " GET #{opts[:get]}" if opts[:get]
|
||||
cmd << " INCR #{opts[:incr]}" if opts[:incr]
|
||||
cmd << " DEL #{opts[:del]}" if opts[:del]
|
||||
cmd << " DECR #{opts[:decr]}" if opts[:decr]
|
||||
cmd << " #{opts[:order]}" if opts[:order]
|
||||
cmd << " LIMIT #{opts[:limit].join(' ')}" if opts[:limit]
|
||||
cmd << "\r\n"
|
||||
write(cmd)
|
||||
get_response
|
||||
def read(length = 0)
|
||||
length = read_proto unless length > 0
|
||||
res = @socket.read(length)
|
||||
puts "read is #{res.inspect}" if $debug
|
||||
res
|
||||
end
|
||||
|
||||
def multi_bulk
|
||||
@ -418,28 +359,6 @@ class Redis
|
||||
r
|
||||
end
|
||||
|
||||
def []=(key, val)
|
||||
set(key,val)
|
||||
end
|
||||
|
||||
|
||||
def set(key, val, expiry=nil)
|
||||
write("SET #{key} #{val.to_s.size}\r\n#{val}\r\n")
|
||||
s = get_response == OK
|
||||
return expire(key, expiry) if s && expiry
|
||||
s
|
||||
end
|
||||
|
||||
def expire(key, expiry=nil)
|
||||
write("EXPIRE #{key} #{expiry}\r\n")
|
||||
get_response == 1
|
||||
end
|
||||
|
||||
def set_unless_exists(key, val)
|
||||
write "SETNX #{key} #{val.to_s.size}\r\n#{val}\r\n"
|
||||
get_response == 1
|
||||
end
|
||||
|
||||
def status_code_reply
|
||||
begin
|
||||
res = read_proto
|
||||
@ -452,13 +371,26 @@ class Redis
|
||||
raise RedisError
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
def execute_command(command, ignore_response=false)
|
||||
ss = server.socket
|
||||
unless ss.object_id == @socket.object_id
|
||||
@socket = ss
|
||||
puts "Socket changed, selecting DB" if $debug
|
||||
unless command[0..6] == 'SELECT'
|
||||
#BTM - Ugh- DRY but better than infinite recursion
|
||||
write("SELECT #{@db}\r\n")
|
||||
get_response
|
||||
end
|
||||
end
|
||||
write(command)
|
||||
get_response unless ignore_response
|
||||
rescue Errno::ECONNRESET, Errno::EPIPE, NoMethodError, Timeout::Error => e
|
||||
raise RedisError, "Connection error"
|
||||
end
|
||||
|
||||
def get_response
|
||||
begin
|
||||
rtype = get_reply
|
||||
rescue => e
|
||||
raise RedisError, e.inspect
|
||||
end
|
||||
rtype = get_reply
|
||||
puts "reply_type is #{rtype.inspect}" if $debug
|
||||
case rtype
|
||||
when SINGLE
|
||||
@ -512,13 +444,21 @@ class Redis
|
||||
end
|
||||
|
||||
def read_proto
|
||||
with_socket_management(@server) do |socket|
|
||||
if res = socket.gets
|
||||
x = res.chomp
|
||||
puts "read_proto is #{x.inspect}\n\n" if $debug
|
||||
x.to_i
|
||||
end
|
||||
res = @socket.readline
|
||||
x = res.chomp
|
||||
puts "read_proto is #{x.inspect}\n\n" if $debug
|
||||
x.to_i
|
||||
end
|
||||
|
||||
private
|
||||
def value_to_wire(value)
|
||||
value_str = value.to_s
|
||||
if value_str.respond_to?(:bytesize)
|
||||
value_size = value_str.bytesize
|
||||
else
|
||||
value_size = value_str.size
|
||||
end
|
||||
"#{value_size}\r\n#{value_str}"
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
@ -24,12 +24,6 @@ end
|
||||
|
||||
class Server
|
||||
|
||||
##
|
||||
# The amount of time to wait before attempting to re-establish a
|
||||
# connection with a server that is marked dead.
|
||||
|
||||
RETRY_DELAY = 30.0
|
||||
|
||||
##
|
||||
# The host the redis server is running on.
|
||||
|
||||
@ -40,16 +34,6 @@ class Server
|
||||
|
||||
attr_reader :port
|
||||
|
||||
##
|
||||
#
|
||||
|
||||
attr_reader :replica
|
||||
|
||||
##
|
||||
# The time of next retry if the connection is dead.
|
||||
|
||||
attr_reader :retry
|
||||
|
||||
##
|
||||
# A text status string describing the state of the server.
|
||||
|
||||
@ -67,7 +51,6 @@ class Server
|
||||
@port = port.to_i
|
||||
|
||||
@sock = nil
|
||||
@retry = nil
|
||||
@status = 'NOT CONNECTED'
|
||||
@timeout = timeout
|
||||
end
|
||||
@ -83,38 +66,31 @@ class Server
|
||||
# Returns the connected socket object on success or nil on failure.
|
||||
|
||||
def socket
|
||||
return @sock if @sock and not @sock.closed?
|
||||
|
||||
@sock = nil
|
||||
|
||||
# If the host was dead, don't retry for a while.
|
||||
return if @retry and @retry > Time.now
|
||||
|
||||
return @sock if socket_alive?
|
||||
close
|
||||
# Attempt to connect if not already connected.
|
||||
begin
|
||||
@sock = connect_to(@host, @port, @timeout)
|
||||
@sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
|
||||
@retry = nil
|
||||
@status = 'CONNECTED'
|
||||
rescue Errno::EPIPE, Errno::ECONNREFUSED => e
|
||||
puts "Socket died... socket: #{@sock.inspect}\n" if $debug
|
||||
@sock.close
|
||||
puts "Socket died... : #{e}\n" if $debug
|
||||
retry
|
||||
rescue SocketError, SystemCallError, IOError => err
|
||||
puts "Unable to open socket: #{err.class.name}, #{err.message}" if $debug
|
||||
mark_dead err
|
||||
end
|
||||
@sock
|
||||
end
|
||||
|
||||
def connect_to(host, port, timeout=nil)
|
||||
socket = TCPSocket.new(host, port, 0)
|
||||
socket = TCPSocket.new(host, port)
|
||||
socket.set_encoding(Encoding::BINARY) if socket.respond_to?(:set_encoding)
|
||||
if timeout
|
||||
socket.instance_eval <<-EOR
|
||||
alias :blocking_gets :gets
|
||||
def gets(*args)
|
||||
alias :blocking_readline :readline
|
||||
def readline(*args)
|
||||
RedisTimer.timeout(#{timeout}) do
|
||||
self.blocking_gets(*args)
|
||||
self.blocking_readline(*args)
|
||||
end
|
||||
end
|
||||
alias :blocking_read :read
|
||||
@ -134,27 +110,22 @@ class Server
|
||||
socket
|
||||
end
|
||||
|
||||
##
|
||||
# Close the connection to the redis server targeted by this
|
||||
# object. The server is not considered dead.
|
||||
# object.
|
||||
|
||||
def close
|
||||
@sock.close if @sock && !@sock.closed?
|
||||
@sock.close if !@sock.nil? && !@sock.closed?
|
||||
@sock = nil
|
||||
@retry = nil
|
||||
@status = "NOT CONNECTED"
|
||||
end
|
||||
|
||||
##
|
||||
# Mark the server as dead and close its socket.
|
||||
def mark_dead(error)
|
||||
@sock.close if @sock && !@sock.closed?
|
||||
@sock = nil
|
||||
@retry = Time.now #+ RETRY_DELAY
|
||||
|
||||
reason = "#{error.class.name}: #{error.message}"
|
||||
@status = sprintf "%s:%s DEAD (%s), will retry at %s", @host, @port, reason, @retry
|
||||
puts @status
|
||||
end
|
||||
|
||||
private
|
||||
def socket_alive?
|
||||
#BTM - TODO - FileStat is borked under JRuby
|
||||
unless defined?(JRUBY_VERSION)
|
||||
!@sock.nil? && !@sock.closed? && @sock.stat.readable?
|
||||
else
|
||||
!@sock.nil? && !@sock.closed?
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
Reference in New Issue
Block a user