renoir 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bdd9e26d7c799ce66755d415eb1fcb5f54c0f3c7
+  data.tar.gz: bd3eedd262e8bb76d81b2808346c59221229a667
+SHA512:
+  metadata.gz: 090813818dcccb2e6606629c2296d4104057a12548d7bb45bc909dec159153acde2811e5c43745ec6f5677e08dcff2f313af4e5ff0ae67d75b690f7bc0216d36
+  data.tar.gz: 4c230945ee38e7db2e6ef546c71467805aedfb911ba89471668c2aa622e040176e1e45a64ed38f96b840514637075a5d236085a6231a93f18e384a4d543a8e58

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,12 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+before_install:
+  - gem install bundler -v 1.13.6
+  - git clone https://github.com/antirez/redis $TRAVIS_BUILD_DIR/redis && cd $TRAVIS_BUILD_DIR/redis && make
+before_script:
+  - cd $TRAVIS_BUILD_DIR/redis/utils/create-cluster && ./create-cluster start && yes yes | ./create-cluster create
+  - cd $TRAVIS_BUILD_DIR
+after_script:
+  - cd $TRAVIS_BUILD_DIR/redis/utils/create-cluster && ./create-cluster stop && ./create-cluster clean

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at saito.die@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in renoir.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Salvatore Sanfilippo <antirez@gmail.com>
+Copyright (c) 2016 Hiroshi Saito
+
+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.

data/README.md

@@ -0,0 +1,120 @@
+# Renoir
+
+[![Build Status](https://travis-ci.org/saidie/renoir.svg?branch=master)](https://travis-ci.org/saidie/renoir)
+
+A production ready Redis cluster client for Ruby.
+
+Renoir provides compatible interface with [redis-rb](https://github.com/redis/redis-rb/).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'renoir'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install renoir
+
+## Usage
+
+You can request to a Redis cluster by instantiating `Renoir::Client` with `cluster_nodes` option.
+
+```ruby
+require 'renoir'
+
+rc = Renoir::Client.new(cluster_nodes: ['127.0.0.1:30001'])
+
+puts rc.set('hoge', 123) #=> OK
+puts rc.set('fuga', 456) #=> OK
+puts rc.get('hoge') #=> 123
+puts rc.get('fuga') #=> 456
+```
+
+Options for [redis-rb](https://github.com/redis/redis-rb/) could also be passed as an argument:
+
+```ruby
+rc = Renoir::Client.new(
+  cluster_nodes: ['127.0.0.1:30001'],
+
+  # redis-rb options
+  timeout: 100,
+  password: 'password'
+)
+```
+
+### Dispatch command to nodes directly
+
+Renoir dispatches a command only if a slot is determined by the command. This also includes no-keys commands like `KEYS`, `BGSAVE` and so on.
+
+If you would like to dispatch such commands, `Renoir::Client#each_node` could be used:
+
+```ruby
+keys = []
+rc.each_node do |node|
+  keys += node.keys('test_*')
+end
+p keys
+```
+
+## Configuration
+
+Following options could be passed to `Renoir::Client#new`:
+
+### `cluster_nodes` (required)
+
+`Array` of cluster node locations. At least one location must be specified.
+
+A location could be `String`, `Array` or `Hash`:
+
+```ruby
+cluster_nodes: [
+  '127.0.0.1:30001',
+  ['127.0.0.1', 30002],
+  { host: 127.0.0.1, port: 30003 }
+]
+```
+
+### `max_redirection`
+
+Max number of redirections. Defaults to `10`.
+
+### `max_connection_error`
+
+Max number of acceptable connection errors. Defaults to `5`.
+
+### `connect_retry_interval`, `connect_retry_random_factor`
+
+Options for adjusting an interval of retry that a client tries to reconnect to same node when connection error is occurred.
+Defaults to `0.001` (sec) and `0.1` respectively.
+
+A retry interval is proportional to a random value sampled from `[connect_retry_interval - connect_retry_random_factor, connect_retry_interval + connect_retry_random_factor]`.
+
+### `connection_adapter`
+
+Adapter name of internal connection that client uses to connect to Redis node. Defaults to `:redis`.
+
+Available adapter is `:redis` so far.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/saidie/renoir. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+The original code is from [antirez/redis-rb-cluster](https://github.com/antirez/redis-rb-cluster).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "renoir"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/renoir.rb

@@ -0,0 +1,10 @@
+require "renoir/version"
+require "renoir/client"
+
+module Renoir
+  class BaseError < RuntimeError
+  end
+
+  class RedirectionError < BaseError
+  end
+end

data/lib/renoir/client.rb

@@ -0,0 +1,183 @@
+require 'thread'
+require "renoir/cluster_info"
+require "renoir/connection_adapters"
+require "renoir/crc16"
+
+module Renoir
+  class Client
+    REDIS_CLUSTER_HASH_SLOTS = 16_384
+
+    DEFAULT_OPTIONS = {
+      cluster_nodes: [
+        ["127.0.0.1", 6379]
+      ],
+      max_redirection: 10,
+      max_connection_error: 5,
+      connect_retry_random_factor: 0.1,
+      connect_retry_interval: 0.001, # 1 ms
+      connection_adapter: :redis,
+    }.freeze
+
+    def initialize(options)
+      @connections = {}
+      @cluster_info = ClusterInfo.new
+      @refresh_slots = true
+
+      options = options.map { |k, v| [k.to_sym, v] }.to_h
+      @options = DEFAULT_OPTIONS.merge(options)
+      @logger = @options[:logger]
+      @adapter_class = ConnectionAdapters.const_get(@options[:connection_adapter].to_s.capitalize)
+
+      cluster_nodes = @options.delete(:cluster_nodes)
+      fail "the cluster_nodes option must contain at least one node" if cluster_nodes.empty?
+      cluster_nodes.each do |node|
+        host, port = case node
+                     when Array
+                       node
+                     when Hash
+                       [node[:host], node[:port]]
+                     when String
+                       node.split(":")
+                     else
+                       fail "invalid entry in cluster_nodes option: #{node}"
+                     end
+        port ||= 6379
+        @cluster_info.add_node(host, port.to_i)
+      end
+
+      @connections_mutex = Mutex.new
+      @refresh_slots_mutex = Mutex.new
+    end
+
+    def call(*command, &block)
+      keys = @adapter_class.get_keys_from_command(command)
+      slots = keys.map { |key| key_slot(key) }.uniq
+      fail "No way to dispatch this command to Redis Cluster." if slots.size != 1
+      slot = slots.first
+
+      refresh = @refresh_slots_mutex.synchronize do
+        refresh = @refresh_slots
+        @refresh_slots = false
+        refresh
+      end
+      refresh_slots if refresh
+
+      call_with_redirection(slot, command, &block)
+    end
+
+    def close
+      while entry = @connections.shift
+        entry[1].close
+      end
+    end
+
+    def each_node
+      return enum_for(:each_node) unless block_given?
+
+      @cluster_info.nodes.each do |node|
+        fetch_connection(node).with_raw_connection do |conn|
+          yield conn
+        end
+      end
+    end
+
+    def method_missing(command, *args, &block)
+      call(command, *args, &block)
+    end
+
+    private
+
+    def key_slot(key)
+      s = key.index("{")
+      if s
+        e = key.index("}", s + 1)
+        if e && e != s + 1
+          key = key[s + 1..e - 1]
+        end
+      end
+      CRC16.crc16(key) % REDIS_CLUSTER_HASH_SLOTS
+    end
+
+    def call_with_redirection(slot, command, &block)
+      nodes = @cluster_info.nodes.dup
+      node = @cluster_info.slot_node(slot) || nodes.sample
+
+      redirect_count = 0
+      connect_error_count = 0
+      connect_retry_count = 0
+      asking = false
+      loop do
+        nodes.delete(node)
+
+        conn = fetch_connection(node)
+        reply = conn.call(command, asking, &block)
+        case reply
+        when ConnectionAdapters::Reply::RedirectionError
+          asking = reply.ask
+          node = @cluster_info.add_node(reply.ip, reply.port)
+          @refresh_slots ||= !asking
+
+          redirect_count += 1
+          raise RedirectionError, "Too many redirections" if @options[:max_redirection] < redirect_count
+        when ConnectionAdapters::Reply::ConnectionError
+          connect_error_count += 1
+          raise reply.cause if @options[:max_connection_error] < connect_error_count
+          if nodes.empty?
+            connect_retry_count += 1
+            sleep(sleep_interval(connect_retry_count))
+          else
+            asking = false
+            node = nodes.sample
+          end
+        else
+          return reply
+        end
+      end
+    end
+
+    def refresh_slots
+      slots = nil
+      @cluster_info.nodes.each do |node|
+        conn = fetch_connection(node)
+        reply = conn.call(["cluster", "slots"])
+        case reply
+        when ConnectionAdapters::Reply::RedirectionError
+          fail "never reach here"
+        when ConnectionAdapters::Reply::ConnectionError
+          if @logger
+            @logger.warn("CLUSTER SLOTS command failed: node_name=#{node[:name]}, message=#{reply.cause}")
+          end
+        else
+          slots = reply
+          break
+        end
+      end
+      return unless slots
+
+      @cluster_info = ClusterInfo.new.tap do |cluster_info|
+        cluster_info.load_slots(slots)
+      end
+
+      (@connections.keys - @cluster_info.node_names).each do |key|
+        conn = @connections.delete(key)
+        conn.close if conn
+      end
+    end
+
+    def fetch_connection(node)
+      name = node[:name]
+      if conn = @connections[name]
+        conn
+      else
+        @connections_mutex.synchronize do
+          @connections[name] ||= @adapter_class.new(node[:host], node[:port], @options)
+        end
+      end
+    end
+
+    def sleep_interval(retry_count)
+      factor = 1 + 2 * (rand - 0.5) * @options[:connect_retry_random_factor]
+      factor * @options[:connect_retry_interval] * 2**(retry_count - 1)
+    end
+  end
+end

data/lib/renoir/cluster_info.rb

@@ -0,0 +1,45 @@
+module Renoir
+  class ClusterInfo
+    class << self
+      def node_name(host, port)
+        "#{host}:#{port}"
+      end
+    end
+
+    def initialize
+      @slots = {}
+      @nodes = {}
+    end
+
+    def load_slots(slots)
+      slots.each do |s, e, master, *slaves|
+        ip, port, = master
+        name = add_node(ip, port)
+        (s..e).each do |slot|
+          @slots[slot] = name
+        end
+      end
+    end
+
+    def slot_node(slot)
+      @nodes[@slots[slot]]
+    end
+
+    def node_names
+      @nodes.keys
+    end
+
+    def nodes
+      @nodes.values
+    end
+
+    def add_node(host, port)
+      name = self.class.node_name(host, port)
+      @nodes[name] = {
+        host: host,
+        port: port,
+        name: name,
+      }
+    end
+  end
+end

data/lib/renoir/connection_adapters.rb

@@ -0,0 +1,7 @@
+require "renoir/connection_adapters/reply"
+
+module Renoir
+  module ConnectionAdapters
+    autoload :Redis, "renoir/connection_adapters/redis"
+  end
+end

data/lib/renoir/connection_adapters/base.rb

@@ -0,0 +1,23 @@
+module Renoir
+  module ConnectionAdapters
+    class Base
+      class << self
+        def get_keys_from_command(command)
+          fail "a connection adapter must override #get_keys_from_command"
+        end
+      end
+
+      def call(command, asking=false, &block)
+        fail "a connection adapter must override #call"
+      end
+
+      def close
+        fail "a connection adapter must override #close"
+      end
+
+      def with_raw_connection
+        fail "a connection adapter must override #with_raw_connection"
+      end
+    end
+  end
+end

data/lib/renoir/connection_adapters/redis.rb

@@ -0,0 +1,95 @@
+require "redis"
+require "renoir/connection_adapters/base"
+
+module Renoir
+  module ConnectionAdapters
+    class Redis < Base
+      class << self
+        def get_keys_from_command(command)
+          case command[0].to_s.downcase.to_sym
+          when :append, :bitcount, :bitfield, :bitpos, :decr, :decrby, :dump,
+              :expire, :expireat, :geoadd, :geodist, :geohash, :geopos, :get,
+              :getbit, :getrange, :getset, :hdel, :hexists, :hget, :hgetall,
+              :hincrby, :hincrbyfloat, :hkeys, :hlen, :hmget, :hmset, :hscan,
+              :hset, :hsetnx, :hstrlen, :hvals, :incr, :incrby, :incrbyfloat,
+              :lindex, :linsert, :llen, :lpop, :lpush, :lpushx, :lrange, :lrem,
+              :lset, :ltrim, :move, :persist, :pexpire, :pexpireat, :pfadd,
+              :psetex, :pttl, :restore, :rpop, :rpush, :rpushx, :sadd, :scard,
+              :set, :setbit, :setex, :setnx, :setrange, :sismember, :smembers,
+              :spop, :srandmember, :srem, :sscan, :strlen, :ttl, :type, :zadd,
+              :zcard, :zcount, :zincrby, :zlexcount, :zrange, :zrangebylex,
+              :zrangebyscore, :zrank, :zrem, :zremrangebylex, :zremrangebyrank,
+              :zremrangebyscore, :zrevrange, :zrevrangebylex,
+              :zrevrangebyscore, :zrevrank, :zscan, :zscore
+            [command[1]]
+          when :del, :exists, :mget, :pfcount, :pfmerge, :sdiff, :sdiffstore,
+              :sinter, :sinterstore, :sunion, :sunionstore, :touch, :unlink,
+              :watch, :rename, :renamenx, :rpoplpush
+            command[1..-1]
+          when :smove
+            command[1..-2]
+          when :blpop, :brpop, :brpoplpush
+            command[-1].is_a?(Hash) ? command[1..-2] : command[1..-1]
+          when :bitop
+            command[2..-1]
+          when :eval, :evalsha
+            (command[2].is_a?(Hash) ? command[2][:keys] : command[2]) || []
+          when :georadius, :georadiusbymember
+            store_index = command.index { |arg| [:store, :storedist].include?(arg.to_s.downcase.to_sym) }
+            [command[1]] + (store_index ? [command[store_index+1]] : [])
+          when :migrate
+            if command[1].empty?
+              # TODO: support multiple keys when the redis-rb gem supports that
+            else
+              [command[1]]
+            end
+          when :mset, :msetnx
+            ((command.size - 1) / 2).times.map { |count| command[1 + count*2] }
+          when :sort
+            [command[1]] + (command[2].is_a?(Hash) ? [command[2][:store]] : [])
+          when :zinterstore, :zunionstore
+            [command[1]] + command[2]
+          else
+            []
+          end
+        end
+      end
+
+      def initialize(host, port, options={})
+        @conn = ::Redis.new(options.merge(host: host, port: port))
+      end
+
+      def call(command, asking=false, &block)
+        command, *args = command
+        if asking
+          @conn.multi do |tx|
+            tx.asking
+            tx.send(command, *args, &block)
+          end
+        else
+          @conn.send(command, *args, &block)
+        end
+      rescue ::Redis::CommandError => e
+        errv = e.to_s.split
+        type = errv[0].downcase.to_sym
+        raise unless [:moved, :ask].include?(type)
+
+        ip, port = errv[2].split(":")
+        Reply::RedirectionError.new(e, type == :ask, ip, port)
+      rescue ::Redis::TimeoutError, ::Redis::CannotConnectError => e
+        Reply::ConnectionError.new(e)
+      end
+
+      def close
+        # Redis#disconnect! is deprecated since redis-rb 3.3.0
+        @conn.mon_synchronize do
+          @conn.respond_to?(:close) ? @conn.close : @conn.disconnect!
+        end
+      end
+
+      def with_raw_connection
+        yield @conn
+      end
+    end
+  end
+end

data/lib/renoir/connection_adapters/reply.rb

@@ -0,0 +1,27 @@
+module Renoir
+  module ConnectionAdapters
+    module Reply
+      class Base
+        attr_reader :cause
+
+        def initialize(cause)
+          @cause = cause
+        end
+      end
+
+      class RedirectionError < Base
+        attr_reader :ask, :ip, :port
+
+        def initialize(cause, ask, ip, port)
+          super(cause)
+          @ask = ask
+          @ip = ip
+          @port = port
+        end
+      end
+
+      class ConnectionError < Base
+      end
+    end
+  end
+end

data/lib/renoir/crc16.rb

@@ -0,0 +1,60 @@
+# 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 Renoir
+  module CRC16
+    def self.crc16(bytes)
+      crc = 0
+      bytes.each_byte do |b|
+        crc = ((crc << 8) & 0xffff) ^ XMODEM_CRC16_LOOKUP[((crc >> 8) ^ b) & 0xff]
+      end
+      crc
+    end
+
+    XMODEM_CRC16_LOOKUP = [
+      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
+    ].freeze
+  end
+end

data/lib/renoir/version.rb

@@ -0,0 +1,3 @@
+module Renoir
+  VERSION = "0.1.0"
+end

data/renoir.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'renoir/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "renoir"
+  spec.version       = Renoir::VERSION
+  spec.authors       = ["Hiroshi Saito"]
+  spec.email         = ["saito.die@gmail.com"]
+
+  spec.summary       = %q{Reliable Redis Cluster client library}
+  spec.description   = %q{Reliable Redis Cluster client library.}
+  spec.homepage      = "https://github.com/saidie/renoir"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'redis', "~> 3.2"
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: renoir
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Hiroshi Saito
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-01-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Reliable Redis Cluster client library.
+email:
+- saito.die@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/renoir.rb
+- lib/renoir/client.rb
+- lib/renoir/cluster_info.rb
+- lib/renoir/connection_adapters.rb
+- lib/renoir/connection_adapters/base.rb
+- lib/renoir/connection_adapters/redis.rb
+- lib/renoir/connection_adapters/reply.rb
+- lib/renoir/crc16.rb
+- lib/renoir/version.rb
+- renoir.gemspec
+homepage: https://github.com/saidie/renoir
+licenses:
+- MIT
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Reliable Redis Cluster client library
+test_files: []