em_redis_cluster 0.5.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f700c069e9d3c1188c82873779fefc78900a0937
+  data.tar.gz: bd97730d324bdb476a8f55cb79bc7ac785e9d346
+SHA512:
+  metadata.gz: 044bdd943741a8b2abf92da8837231789a8257d39bd3448e854578891d1c6a0578e787f59a84ca90380390540d73f1f3ef680511c8198f8dd6c1eeda7bbb2591
+  data.tar.gz: a0f46fb192cbae4209fbdfbef23efa6883afecabd6e314464e9006d531d320f031866c50a9ba6ae61ebb573ae4e8e18092d1990c104c8f876d53f64b3e07fc0f

data/History.txt

@@ -0,0 +1,22 @@
+== 0.2.2 / 2009-12-29
+* reselect database after reconnecting
+
+== 0.2.1 / 2009-12-15
+* updated gem dependencies
+
+== 0.2 / 2009-12-15
+* rip off stock redis gem
+* sort is no longer compatible with 0.1 version
+* response of exists, sismember, sadd, srem, smove, zadd, zrem, move, setnx, del, renamenx, and expire is either true or false, not 0 or 1 as in 0.1
+* info returns hash of symbols now
+* lrem has different argument order
+
+== 0.1.1 / 2009-05-01
+
+* added a number of aliases to redis-based method names
+* refactored process_cmd method for greater clarity
+
+== 0.1.0 / 2009-04-28
+
+* initial release
+* compatible with Redis 0.093

data/lib/em_redis_cluster.rb

@@ -0,0 +1,3 @@
+require File.expand_path('../em_redis_cluster/version', __FILE__)
+require File.expand_path('../em_redis_cluster/redis_protocol', __FILE__)
+require File.expand_path('../em_redis_cluster/cluster', __FILE__)

data/lib/em_redis_cluster/cluster.rb

@@ -0,0 +1,335 @@
+# Copyright (C) 2013 Salvatore Sanfilippo <antirez@gmail.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'rubygems'
+require_relative 'redis_protocol'
+require_relative 'redis_error'
+require_relative 'crc16'
+
+module EventMachine
+  module Protocols
+    class RedisCluster
+
+      RedisClusterHashSlots = 16384
+      RedisClusterRequestTTL = 16
+      RedisClusterDefaultTimeout = 1
+
+      def initialize(startup_nodes, opt={})
+        @startup_nodes = startup_nodes
+        
+        @connections = {}
+        @opt = opt
+        
+        # Redis Cluster does not support multiple databases like the stand alone version of Redis. 
+        # There is just database 0 and the SELECT command is not allowed
+        @opt.delete(:db)
+        @logger = @opt[:logger]
+
+        @refresh_table_asap = false
+        @slots_initialized = false
+        @command_before_init = []
+        initialize_slots_cache {|c| yield(c) if block_given?}
+      end
+
+      def log(severity, msg)
+        @logger && @logger.send(severity, "em_redis_cluster: #{msg}")
+      end
+
+      def ready?
+        @slots_initialized
+      end
+
+      def any_error?
+        ready? && all_connections.any?{|c| c.error?}
+      end
+
+      def conn_status
+        status = {}
+        @connections.each {|k,c| status[k] = !c.error?}
+        status
+      end
+
+      def get_redis_link(host, port)
+        EM::Protocols::Redis.connect({:host => host, :port => port}.merge @opt)
+      end
+
+      # Given a node (that is just a Ruby hash) give it a name just
+      # concatenating the host and port. We use the node name as a key
+      # to cache connections to that node.
+      def set_node_name!(n)
+        n[:name] ||= "#{n[:host]}:#{n[:port]}"
+        n
+      end
+
+      # Contact the startup nodes and try to fetch the hash slots -> instances
+      # map in order to initialize the @slots hash.
+      def initialize_slots_cache
+        @slots = Array.new(RedisClusterHashSlots)
+
+        fiber = Fiber.new do
+      
+          @startup_nodes.each do |n|
+            @nodes = []
+
+            r = get_redis_link(n[:host], n[:port])
+
+            r.errback {|e| fiber.resume(nil)}
+
+            r.cluster("slots") {|rsp| fiber.resume(rsp)}
+
+            rsp = Fiber.yield
+            r.close_connection
+
+            if rsp.is_a?(Array)
+              rsp.each do |r|
+                
+                ip, port = r[2]
+                # somehow redis return "" for the node it's querying
+                ip = n[:host] if ip == ""
+
+                node = set_node_name!(host: ip, port: port)
+                @nodes << node
+
+                (r[0]..r[1]).each {|slot| @slots[slot] = node}
+              end
+
+              populate_startup_nodes
+              @refresh_table_asap = false
+              @slots_initialized = true
+
+              # Exit the loop as long as the first node replies
+              break
+            else
+              next
+            end
+          end
+
+          log :debug, "RedisCluster: #{@nodes}"
+
+          yield(self) if block_given?
+
+          # run cached commands before initialization
+          if ready?
+            @command_before_init.each do |argv|
+              argv.respond_to?(:call) ? argv.call : send_cluster_command(argv)
+            end
+          end
+          @command_before_init = []
+        end
+
+        fiber.resume
+      end
+
+      # Use @nodes to populate @startup_nodes, so that we have more chances
+      # if a subset of the cluster fails.
+      def populate_startup_nodes
+        # Make sure every node has already a name, so that later the
+        # Array uniq! method will work reliably.
+        @startup_nodes.each{|n| set_node_name!(n)}
+        @nodes.each{|n| @startup_nodes << n}
+        @startup_nodes.uniq!
+      end
+
+      # Flush the cache, mostly useful for debugging when we want to force
+      # redirection.
+      def flush_slots_cache
+        @slots = Array.new(RedisClusterHashSlots)
+      end
+
+      # Return the hash slot from the key.
+      def keyslot(key)
+        # Only hash what is inside {...} if there is such a pattern in the key.
+        # Note that the specification requires the content that is between
+        # the first { and the first } after the first {. If we found {} without
+        # nothing in the middle, the whole key is hashed as usually.
+        s = key.index "{"
+        if s
+          e = key.index "}",s+1
+          if e && e != s+1
+            key = key[s+1..e-1]
+          end
+        end
+
+        RedisClusterCRC16.crc16(key) % RedisClusterHashSlots
+      end
+
+      # Return the first key in the command arguments.
+      #
+      # Currently we just return argv[1], that is, the first argument
+      # after the command name.
+      #
+      # This is indeed the key for most commands, and when it is not true
+      # the cluster redirection will point us to the right node anyway.
+      #
+      # For commands we want to explicitly bad as they don't make sense
+      # in the context of cluster, nil is returned.
+      def get_key_from_command(argv)
+        case argv[0].to_s.downcase
+        when "info","multi","exec","slaveof","config","shutdown","select"
+          nil
+        else
+          # Unknown commands, and all the commands having the key
+          # as first argument are handled here:
+          # set, get, ...
+          argv[1]
+        end
+      end
+
+      def get_random_connection
+        n = @startup_nodes.shuffle.first
+        @connections[n[:name]] ||= get_redis_link(n[:host], n[:port])
+      end
+
+      # Given a slot return the link (Redis instance) to the mapped node.
+      # Make sure to create a connection with the node if we don't have
+      # one.
+      def get_connection_by_key(key)
+        if n = @slots[keyslot(key)]
+          @connections[n[:name]] ||= get_redis_link(n[:host], n[:port])
+        else
+          # If we don't know what the mapping is, return a random node.
+          get_random_connection
+        end
+      end
+
+      def get_connection_by_node(n)
+        set_node_name!(n)
+        @connections[n[:name]] ||= get_redis_link(n[:host], n[:port])
+      end
+
+      def all_connections
+        @startup_nodes.each do |n|
+          @connections[n[:name]] ||= get_redis_link(n[:host], n[:port])
+        end
+        @connections.values
+      end
+
+      # Dispatch commands.
+      def send_cluster_command(argv)
+        
+        callback = argv.pop
+        callback = nil unless callback.respond_to?(:call)
+
+        ttl = RedisClusterRequestTTL
+        asking = false
+        conn_for_next_cmd = nil
+        try_random_node = false
+
+
+        fiber = Fiber.new do
+          while ttl > 0 do
+            key = get_key_from_command(argv)
+
+            # raise Redis::ParserError.new("No way to dispatch this command to Redis Cluster.") unless key
+
+            # The full semantics of ASK redirection from the point of view of the client is as follows:
+            #   If ASK redirection is received, send only the query that was redirected to the specified node but continue sending subsequent queries to the old node.
+            #   Start the redirected query with the ASKING command.
+            #   Don't yet update local client tables to map hash slot 8 to B.
+            conn_for_next_cmd ||= (key ? get_connection_by_key(key) : get_random_connection)
+            conn_for_next_cmd.asking if asking
+            conn_for_next_cmd.send(argv[0].to_sym, *argv[1..-1]) {|rsp| fiber.resume(rsp) }
+
+            rsp = Fiber.yield
+
+            conn_for_next_cmd = nil
+            asking = false
+
+            if rsp.is_a?(RedisError)
+              errv = rsp.to_s.split
+              if errv[0] == "MOVED" || errv[0] == "ASK"
+                log :debug, rsp.to_s
+
+                newslot = errv[1].to_i
+                node_ip, node_port = errv[2].split(":").map{|x|x.strip}
+
+                if errv[0] == "ASK"
+                  asking = true
+                  conn_for_next_cmd = get_connection_by_node(host: node_ip, port: node_port)
+                else
+                  # Serve replied with MOVED. It's better for us to ask for CLUSTER NODES the next time.
+                  @refresh_table_asap = true
+                  @slots[newslot] = set_node_name!(host: node_ip, port: node_port.to_i)
+                end
+              else
+                callback && callback.call(rsp)
+                break
+              end
+            else
+              callback && callback.call(rsp)
+              break
+            end
+
+            ttl -= 1
+          end
+          
+          callback && callback.call(rsp) if ttl == 0
+
+          initialize_slots_cache if @refresh_table_asap
+        end
+
+        fiber.resume
+      end
+
+      # Currently we handle all the commands using method_missing for
+      # simplicity. For a Cluster client actually it will be better to have
+      # every single command as a method with the right arity and possibly
+      # additional checks (example: RPOPLPUSH with same src/dst key, SORT
+      # without GET or BY, and so forth).
+      def method_missing(*argv, &blk)
+        argv << blk
+        if ready?
+          send_cluster_command(argv)
+        else
+          @command_before_init << argv
+        end
+      end
+
+      [:flushdb, :flushall].each do |fn|
+        define_method fn do
+          if ready?
+            all_connections.each {|c| c.send(fn)}
+          else
+            @command_before_init << proc {self.send(fn)}
+          end
+        end
+      end
+
+      # used for testing connection auto-recovery
+      def conn_close(key)
+        c = get_connection_by_key(key)
+        c && c.close_connection_after_writing
+      end
+ 
+      # used for testing connection auto-recovery
+      def conn_error?(key)
+        c = get_connection_by_key(key)
+        c && c.error?
+      end
+      
+      # used for testing connection auto-recovery
+      def get_slotname_by_key(key)
+        @slots[keyslot(key)][:name] rescue nil
+      end
+
+    end
+  end
+end

data/lib/em_redis_cluster/crc16.rb

@@ -0,0 +1,85 @@
+# Copyright (C) 2013 Salvatore Sanfilippo <antirez@gmail.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# -----------------------------------------------------------------------------
+#
+# This is the CRC16 algorithm used by Redis Cluster to hash keys.
+# Implementation according to CCITT standards.
+#
+# This is actually the XMODEM CRC 16 algorithm, using the
+# following parameters:
+#
+# Name                       : "XMODEM", also known as "ZMODEM", "CRC-16/ACORN"
+# Width                      : 16 bit
+# Poly                       : 1021 (That is actually x^16 + x^12 + x^5 + 1)
+# Initialization             : 0000
+# Reflect Input byte         : False
+# Reflect Output CRC         : False
+# Xor constant to output CRC : 0000
+# Output for "123456789"     : 31C3
+
+module RedisClusterCRC16
+
+    def RedisClusterCRC16.crc16(bytes)
+        crc = 0
+        bytes.each_byte{|b|
+            crc = ((crc<<8) & 0xffff) ^ XMODEMCRC16Lookup[((crc>>8)^b) & 0xff]
+        }
+        crc
+    end
+
+private
+
+    XMODEMCRC16Lookup = [
+        0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
+        0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef,
+        0x1231,0x0210,0x3273,0x2252,0x52b5,0x4294,0x72f7,0x62d6,
+        0x9339,0x8318,0xb37b,0xa35a,0xd3bd,0xc39c,0xf3ff,0xe3de,
+        0x2462,0x3443,0x0420,0x1401,0x64e6,0x74c7,0x44a4,0x5485,
+        0xa56a,0xb54b,0x8528,0x9509,0xe5ee,0xf5cf,0xc5ac,0xd58d,
+        0x3653,0x2672,0x1611,0x0630,0x76d7,0x66f6,0x5695,0x46b4,
+        0xb75b,0xa77a,0x9719,0x8738,0xf7df,0xe7fe,0xd79d,0xc7bc,
+        0x48c4,0x58e5,0x6886,0x78a7,0x0840,0x1861,0x2802,0x3823,
+        0xc9cc,0xd9ed,0xe98e,0xf9af,0x8948,0x9969,0xa90a,0xb92b,
+        0x5af5,0x4ad4,0x7ab7,0x6a96,0x1a71,0x0a50,0x3a33,0x2a12,
+        0xdbfd,0xcbdc,0xfbbf,0xeb9e,0x9b79,0x8b58,0xbb3b,0xab1a,
+        0x6ca6,0x7c87,0x4ce4,0x5cc5,0x2c22,0x3c03,0x0c60,0x1c41,
+        0xedae,0xfd8f,0xcdec,0xddcd,0xad2a,0xbd0b,0x8d68,0x9d49,
+        0x7e97,0x6eb6,0x5ed5,0x4ef4,0x3e13,0x2e32,0x1e51,0x0e70,
+        0xff9f,0xefbe,0xdfdd,0xcffc,0xbf1b,0xaf3a,0x9f59,0x8f78,
+        0x9188,0x81a9,0xb1ca,0xa1eb,0xd10c,0xc12d,0xf14e,0xe16f,
+        0x1080,0x00a1,0x30c2,0x20e3,0x5004,0x4025,0x7046,0x6067,
+        0x83b9,0x9398,0xa3fb,0xb3da,0xc33d,0xd31c,0xe37f,0xf35e,
+        0x02b1,0x1290,0x22f3,0x32d2,0x4235,0x5214,0x6277,0x7256,
+        0xb5ea,0xa5cb,0x95a8,0x8589,0xf56e,0xe54f,0xd52c,0xc50d,
+        0x34e2,0x24c3,0x14a0,0x0481,0x7466,0x6447,0x5424,0x4405,
+        0xa7db,0xb7fa,0x8799,0x97b8,0xe75f,0xf77e,0xc71d,0xd73c,
+        0x26d3,0x36f2,0x0691,0x16b0,0x6657,0x7676,0x4615,0x5634,
+        0xd94c,0xc96d,0xf90e,0xe92f,0x99c8,0x89e9,0xb98a,0xa9ab,
+        0x5844,0x4865,0x7806,0x6827,0x18c0,0x08e1,0x3882,0x28a3,
+        0xcb7d,0xdb5c,0xeb3f,0xfb1e,0x8bf9,0x9bd8,0xabbb,0xbb9a,
+        0x4a75,0x5a54,0x6a37,0x7a16,0x0af1,0x1ad0,0x2ab3,0x3a92,
+        0xfd2e,0xed0f,0xdd6c,0xcd4d,0xbdaa,0xad8b,0x9de8,0x8dc9,
+        0x7c26,0x6c07,0x5c64,0x4c45,0x3ca2,0x2c83,0x1ce0,0x0cc1,
+        0xef1f,0xff3e,0xcf5d,0xdf7c,0xaf9b,0xbfba,0x8fd9,0x9ff8,
+        0x6e17,0x7e36,0x4e55,0x5e74,0x2e93,0x3eb2,0x0ed1,0x1ef0
+    ]
+end

data/lib/em_redis_cluster/redis_error.rb

@@ -0,0 +1,10 @@
+module EventMachine
+  module Protocols
+      # errors
+      class ParserError < StandardError; end
+      class ProtocolError < StandardError; end
+      class TimeoutError < StandardError; end
+      class ConnectError < StandardError; end
+      class RedisError < StandardError; end
+  end
+end

data/lib/em_redis_cluster/redis_protocol.rb

@@ -0,0 +1,491 @@
+require 'rubygems'
+require 'eventmachine'
+
+require_relative 'redis_error'
+
+module EventMachine
+  module Protocols
+    module Redis
+
+      include EM::Deferrable
+
+      ##
+      # constants
+      #########################
+
+      OK      = "OK".freeze
+      MINUS    = "-".freeze
+      PLUS     = "+".freeze
+      COLON    = ":".freeze
+      DOLLAR   = "$".freeze
+      ASTERISK = "*".freeze
+      DELIM    = "\r\n".freeze
+
+      BOOLEAN_PROCESSOR = lambda{|r| r == 1 }
+
+      REPLY_PROCESSOR = {
+        "exists"    => BOOLEAN_PROCESSOR,
+        "sismember" => BOOLEAN_PROCESSOR,
+        # "sadd"      => BOOLEAN_PROCESSOR,
+        # "srem"      => BOOLEAN_PROCESSOR,
+        "smove"     => BOOLEAN_PROCESSOR,
+        "zadd"      => BOOLEAN_PROCESSOR,
+        "zrem"      => BOOLEAN_PROCESSOR,
+        "move"      => BOOLEAN_PROCESSOR,
+        "setnx"     => BOOLEAN_PROCESSOR,
+        "del"       => BOOLEAN_PROCESSOR,
+        "renamenx"  => BOOLEAN_PROCESSOR,
+        "expire"    => BOOLEAN_PROCESSOR,
+        "select"    => BOOLEAN_PROCESSOR, # not in redis gem
+        "hset"      => BOOLEAN_PROCESSOR,
+        "hdel"      => BOOLEAN_PROCESSOR,
+        "hexists"   => BOOLEAN_PROCESSOR,
+        "keys"      => lambda {|r|
+          if r.is_a?(Array)
+            r
+          else
+            r.split(" ")
+          end
+        },
+        "info"      => lambda{|r|
+          info = {}
+          r.each_line {|kv|
+            k,v = kv.split(":",2).map{|x| x.chomp}
+            info[k.to_sym] = v
+          }
+          info
+        },
+        "hgetall"   => lambda{|r|
+          Hash[*r]
+        }
+      }
+
+      ALIASES = {
+        "flush_db"             => "flushdb",
+        "flush_all"            => "flushall",
+        "last_save"            => "lastsave",
+        "key?"                 => "exists",
+        "delete"               => "del",
+        "randkey"              => "randomkey",
+        "list_length"          => "llen",
+        "push_tail"            => "rpush",
+        "push_head"            => "lpush",
+        "pop_tail"             => "rpop",
+        "pop_head"             => "lpop",
+        "list_set"             => "lset",
+        "list_range"           => "lrange",
+        "list_trim"            => "ltrim",
+        "list_index"           => "lindex",
+        "list_rm"              => "lrem",
+        "set_add"              => "sadd",
+        "set_delete"           => "srem",
+        "set_count"            => "scard",
+        "set_member?"          => "sismember",
+        "set_members"          => "smembers",
+        "set_intersect"        => "sinter",
+        "set_intersect_store"  => "sinterstore",
+        "set_inter_store"      => "sinterstore",
+        "set_union"            => "sunion",
+        "set_union_store"      => "sunionstore",
+        "set_diff"             => "sdiff",
+        "set_diff_store"       => "sdiffstore",
+        "set_move"             => "smove",
+        "set_unless_exists"    => "setnx",
+        "rename_unless_exists" => "renamenx",
+        "type?"                => "type",
+        "zset_add"             => "zadd",
+        "zset_count"           => "zcard",
+        "zset_range_by_score"  => "zrangebyscore",
+        "zset_reverse_range"   => "zrevrange",
+        "zset_range"           => "zrange",
+        "zset_delete"          => "zrem",
+        "zset_score"           => "zscore",
+        "zset_incr_by"         => "zincrby",
+        "zset_increment_by"    => "zincrby",
+        # these aliases aren't in redis gem
+        "background_save"      => 'bgsave',
+        "async_save"           => 'bgsave',
+        "members"              => 'smembers',
+        "decrement_by"         => "decrby",
+        "decrement"            => "decr",
+        "increment_by"         => "incrby",
+        "increment"            => "incr",
+        "set_if_nil"           => "setnx",
+        "multi_get"            => "mget",
+        "random_key"           => "randomkey",
+        "random"               => "randomkey",
+        "rename_if_nil"        => "renamenx",
+        "tail_pop"             => "rpop",
+        "pop"                  => "rpop",
+        "head_pop"             => "lpop",
+        "shift"                => "lpop",
+        "list_remove"          => "lrem",
+        "index"                => "lindex",
+        "trim"                 => "ltrim",
+        "range"                => "lrange",
+        "list_len"             => "llen",
+        "len"                  => "llen",
+        "head_push"            => "lpush",
+        "unshift"              => "lpush",
+        "tail_push"            => "rpush",
+        "push"                 => "rpush",
+        "add"                  => "sadd",
+        "set_remove"           => "srem",
+        "set_size"             => "scard",
+        "member?"              => "sismember",
+        "intersect"            => "sinter",
+        "intersect_and_store"  => "sinterstore",
+        "exists?"              => "exists"
+      }
+
+      DISABLED_COMMANDS = {
+        "monitor" => true,
+        "sync"    => true
+      }
+
+      def []=(key,value)
+        set(key,value)
+      end
+
+      def set(key, value, expiry=nil)
+        call_command([:set, key, value]) do |s|
+          yield s if block_given?
+        end
+        expire(key, expiry) if expiry
+      end
+
+      def sort(key, options={}, &blk)
+        cmd = ["SORT"]
+        cmd << key
+        cmd << ["BY", options[:by]] if options[:by]
+        cmd << [options[:get]].flatten.map { |key| ["GET", key] } if options[:get]
+        cmd << options[:order].split(/\s+/) if options[:order]
+        cmd << ["LIMIT", options[:limit]] if options[:limit]
+        call_command(cmd.flatten, &blk)
+      end
+
+      def incr(key, increment = nil, &blk)
+        call_command(increment ? ["incrby",key,increment] : ["incr",key], &blk)
+      end
+
+      def decr(key, decrement = nil, &blk)
+        call_command(decrement ? ["decrby",key,decrement] : ["decr",key], &blk)
+      end
+
+      def select(db, &blk)
+        @db = db.to_i
+        call_command(['select', @db], &blk)
+      end
+
+      def auth(password, &blk)
+        @password = password
+        call_command(['auth', password], &blk)
+      end
+
+      def sadd(key, member)
+        call_command([:sadd, key, *member]) do |s|
+          yield s if block_given?
+        end
+      end
+
+      def srem(key, member)
+        call_command([:srem, key, *member]) do |s|
+          yield s if block_given?
+        end
+      end
+
+      def hmset(key, value)
+        call_command([:hmset, key, *value.to_a.flatten]) do |s|
+          yield s if block_given?
+        end
+      end
+
+      def mapped_hmset(key, hash)
+        hmset(key, hash.to_a.flatten) do |s|
+          yield s if block_given?
+        end
+      end
+
+      # Similar to memcache.rb's #get_multi, returns a hash mapping
+      # keys to values.
+      def mapped_mget(*keys)
+        mget(*keys) do |response|
+          result = {}
+          response.each do |value|
+            key = keys.shift
+            result.merge!(key => value) unless value.nil?
+          end
+          yield result if block_given?
+        end
+      end
+
+      # Ruby defines a now deprecated type method so we need to override it here
+      # since it will never hit method_missing
+      def type(key, &blk)
+        call_command(['type', key], &blk)
+      end
+
+      def quit(&blk)
+        call_command(['quit'], &blk)
+      end
+
+      def exec(&blk)
+        call_command(['exec'], &blk)
+      end
+
+      # I'm not sure autocommit is a good idea.
+      # For example:
+      #   r.multi { r.set('a', 'b') { raise "kaboom" } }
+      # will commit "a" and will stop EM
+      def multi
+        call_command(['multi'])
+        if block_given?
+          begin
+            yield self
+            exec
+          rescue Exception => e
+            discard
+            raise e
+          end
+        end
+      end
+
+      def mset(*args, &blk)
+        hsh = args.pop if Hash === args.last
+        if hsh
+          call_command(hsh.to_a.flatten.unshift(:mset), &blk)
+        else
+          call_command(args.unshift(:mset), &blk)
+        end
+      end
+
+      def msetnx(*args, &blk)
+        hsh = args.pop if Hash === args.last
+        if hsh
+          call_command(hsh.to_a.flatten.unshift(:msetnx), &blk)
+        else
+          call_command(args.unshift(:msetnx), &blk)
+        end
+      end
+
+      def errback(&blk)
+        @error_callback = blk
+      end
+      alias_method :on_error, :errback
+
+      def method_missing(*argv, &blk)
+        call_command(argv, &blk)
+      end
+
+      def maybe_lock(&blk)
+        if !EM.reactor_thread?
+          EM.schedule { maybe_lock(&blk) }
+        elsif @connected
+          yield
+        else
+          callback { yield }
+        end
+      end
+
+      def call_command(argv, &blk)
+        argv = argv.dup
+
+        argv[0] = argv[0].to_s.downcase
+        argv[0] = ALIASES[argv[0]] if ALIASES[argv[0]]
+        raise "#{argv[0]} command is disabled" if DISABLED_COMMANDS[argv[0]]
+
+        command = ""
+        command << "*#{argv.size}\r\n"
+        argv.each do |a|
+          a = a.to_s
+          command << "$#{get_size(a)}\r\n"
+          command << a
+          command << "\r\n"
+        end
+
+        # log :debug, "sending: #{command}"
+
+        maybe_lock do
+          @redis_callbacks << [REPLY_PROCESSOR[argv[0]], blk]
+          send_data command
+        end
+      end
+
+      ##
+      # em hooks
+      #########################
+
+      def self.connect(*args)
+        case args.length
+        when 0
+          options = {}
+        when 1
+          arg = args.shift
+          case arg
+          when Hash then options = arg
+          when String then options = {:host => arg}
+          else raise ArgumentError, 'first argument must be Hash or String'
+          end
+        when 2
+          options = {:host => args[0], :port => args[1]}
+        else
+          raise ArgumentError, "wrong number of arguments (#{args.length} for 1)"
+        end
+        options[:host] ||= '127.0.0.1'
+        options[:port]   = (options[:port] || 6379).to_i
+        EM.connect options[:host], options[:port], self, options
+      end
+
+      def initialize(options = {})
+        @host             = options[:host]
+        @port             = options[:port]
+        @db               = (options[:db] || 0).to_i
+        @password         = options[:password]
+        @logger           = options[:logger]
+        @reconn_timer     = options[:reconn_timer] || 0.2 # reconnect after second
+        @redis_callbacks  = []
+        @error_callback   = nil
+
+        # These commands should be first
+        auth_and_select_db
+      end
+
+      def log(severity, msg)
+        @logger && @logger.send(severity, "em_redis: #{msg}")
+      end
+
+      def auth_and_select_db
+        call_command(["auth", @password]) if @password
+        call_command(["select", @db]) unless @db == 0
+      end
+      private :auth_and_select_db
+
+      def connection_completed
+        log :debug, "Connected to #{@host}:#{@port}"
+        dispatch_on_conn_err
+
+        @previous_multibulks = []
+        @multibulk_n     = false
+        @connected       = true
+
+        succeed
+      end
+
+      # 19Feb09 Switched to a custom parser, LineText2 is recursive and can cause
+      #         stack overflows when there is too much data.
+      # include EM::P::LineText2
+      def receive_data(data)
+        (@buffer ||= '') << data
+        while index = @buffer.index(DELIM)
+          begin
+            line = @buffer.slice!(0, index+2)
+            process_cmd line
+          rescue ParserError
+            @buffer[0...0] = line
+            break
+          end
+        end
+      end
+
+      def process_cmd(line)
+        # log :debug, "processing #{line}"
+        # first character of buffer will always be the response type
+        reply_type = line[0, 1]
+        reply_args = line.slice(1..-3) # remove type character and \r\n
+        case reply_type
+
+        #e.g. -MISSING
+        when MINUS
+          excep = RedisError.new(reply_args)
+          dispatch_response(excep)
+          @error_callback && @error_callback.call(excep)
+        # e.g. +OK
+        when PLUS
+          dispatch_response(reply_args)
+        # e.g. $3\r\nabc\r\n
+        # 'bulk' is more complex because it could be part of multi-bulk
+        when DOLLAR
+          data_len = Integer(reply_args)
+          if data_len == -1 # expect no data; return nil
+            dispatch_response(nil)
+          elsif @buffer.size >= data_len + 2 # buffer is full of expected data
+            dispatch_response(@buffer.slice!(0, data_len))
+            @buffer.slice!(0,2) # tossing \r\n
+          else # buffer isn't full or nil
+            # TODO: don't control execution with exceptions
+            raise ParserError
+          end
+        #e.g. :8
+        when COLON
+          dispatch_response(Integer(reply_args))
+        #e.g. *2\r\n$1\r\na\r\n$1\r\nb\r\n
+        when ASTERISK
+          multibulk_count = Integer(reply_args)
+          if multibulk_count == -1 || multibulk_count == 0
+            dispatch_response([])
+          else
+            if @multibulk_n
+              @previous_multibulks << [@multibulk_n, @multibulk_values]
+            end
+            @multibulk_n = multibulk_count
+            @multibulk_values = []
+          end
+        # Whu?
+        else
+          excep = ProtocolError.new("unknown reply_type: #{reply_type}")
+          dispatch_response(excep)
+          @error_callback && @error_callback.call(excep)
+        end
+      end
+
+      def dispatch_response(value)
+        if @multibulk_n
+          @multibulk_values << value
+          @multibulk_n -= 1
+
+          if @multibulk_n == 0
+            value = @multibulk_values
+            @multibulk_n, @multibulk_values = @previous_multibulks.pop
+            if @multibulk_n
+              dispatch_response(value)
+              return
+            end
+          else
+            return
+          end
+        end
+
+        processor, blk = @redis_callbacks.shift
+        value = processor.call(value) if processor
+        blk.call(value) if blk
+      end
+
+      def unbind(reason)
+        log :debug, "Disconnected from #{@host}:#{@port}: #{reason}"
+        dispatch_on_conn_err
+
+        # keep re-connecting
+        EM.add_timer(@reconn_timer) do
+          @logger.debug { "Reconnecting to #{@host}:#{@port}" }  if @logger
+          reconnect @host, @port
+          auth_and_select_db
+        end
+        @connected = false
+        @deferred_status = nil
+      end
+
+      private
+        def dispatch_on_conn_err
+          while @redis_callbacks.size > 0
+            processor, blk = @redis_callbacks.shift
+            blk && blk.call(ConnectError.new("Connection error"))
+          end
+        end
+
+        def get_size(string)
+          string.respond_to?(:bytesize) ? string.bytesize : string.size
+        end
+
+    end
+  end
+end

data/lib/em_redis_cluster/version.rb

@@ -0,0 +1,3 @@
+module EMRedis
+  VERSION = '0.5.1' unless defined? ::EMRedis::VERSION
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: em_redis_cluster
+version: !ruby/object:Gem::Version
+  version: 0.5.1
+platform: ruby
+authors:
+- Jonathan Broad
+- Eugene Pimenov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.rc.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.rc.6
+description: An eventmachine-based implementation of the Redis protocol and Redis
+  cluster support
+email: lxz.tty@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- History.txt
+- lib/em_redis_cluster.rb
+- lib/em_redis_cluster/cluster.rb
+- lib/em_redis_cluster/crc16.rb
+- lib/em_redis_cluster/redis_error.rb
+- lib/em_redis_cluster/redis_protocol.rb
+- lib/em_redis_cluster/version.rb
+homepage: https://github.com/xiuzhong/em_redis_cluster
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: An eventmachine-based implementation of the Redis protocol and Redis cluster
+  support
+test_files: []