consistent-cluster 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a4ea10f872a6d170d1827ad5660abb2344a9ec21
+  data.tar.gz: 9f7e1dd8bc5399a5130bb7002b3c21383437b602
+SHA512:
+  metadata.gz: c910179b9c06d4453a66ce4759a2333ebe1369b4592fb3846f7c90861452bcf0d17f1a59f8e932d74cfbf8434977d5bdac4faa3b5d80f2a115bc83d2cbe320fd
+  data.tar.gz: 02f5644a6729bcda86222fc3d7c3912062455223a03f4507abce2735cac1698128133b412084258edfabe6b155f95b07ab98e3f0b9e087b0ffa250029f9af3cb

data/lib/consistent-cluster/client.rb

@@ -0,0 +1,38 @@
+
+require "consistent-cluster/version"
+
+require "consistent-cluster/consistent_hashing"
+
+require "json"
+
+module ConsistentCluster
+
+  class Client
+
+    def initialize(options)
+
+      @cluster = options[:cluster]
+
+      replicas = options[:consistent_hashing_replicas] || 3
+      @ring = ConsistentHashing::Ring.new(@cluster.keys,replicas)
+
+      @shard_num = 0
+    end
+
+    def shard(key=nil)
+      cluster_sum = @cluster.length
+      raise "no service available" if cluster_sum < 1
+      if key
+        point = @ring.point_for(key)
+        server = @cluster[point.node]
+      else
+        @shard_num += 1
+        @shard_num = @shard_num%cluster_sum
+        server = @cluster.values[@shard_num]
+      end
+      server
+    end
+
+  end
+
+end

data/lib/consistent-cluster/consistent_hashing/red_black_tree.rb

@@ -0,0 +1,600 @@
+require 'atomic'
+
+module ConsistentCluster
+  class RedBlackTree
+    include Enumerable
+
+    class Node
+      UNDEFINED = Object.new
+
+      attr_reader :key, :value, :color
+      attr_reader :left, :right
+
+      def initialize(key, value, left, right, color = :RED)
+        @key = key
+        @value = value
+        @left = left
+        @right = right
+        # new node is added as RED
+        @color = color
+      end
+
+      def set_root
+        @color = :BLACK
+      end
+
+      def red?
+        @color == :RED
+      end
+
+      def black?
+        @color == :BLACK
+      end
+
+      def empty?
+        false
+      end
+
+      def size
+        @left.size + 1 + @right.size
+      end
+
+      # inorder
+      def each(&block)
+        @left.each(&block)
+        yield [@key, @value]
+        @right.each(&block)
+      end
+
+      def each_key
+        each do |k, v|
+          yield k
+        end
+      end
+
+      def each_value
+        each do |k, v|
+          yield v
+        end
+      end
+
+      def keys
+        collect { |k, v| k }
+      end
+
+      def values
+        collect { |k, v| v }
+      end
+
+      # returns new_root
+      def insert(key, value)
+        ret = self
+        case key <=> @key
+        when -1
+          @left = @left.insert(key, value)
+          if black? and @right.black? and @left.red? and !@left.children_color?(:BLACK)
+            ret = rebalance_for_left_insert
+          end
+        when 0
+          @value = value
+        when 1
+          @right = @right.insert(key, value)
+          if black? and @left.black? and @right.red? and !@right.children_color?(:BLACK)
+            ret = rebalance_for_right_insert
+          end
+        else
+          raise TypeError, "cannot compare #{key} and #{@key} with <=>"
+        end
+        ret.pullup_red
+      end
+
+      # returns value
+      def retrieve(key)
+        case key <=> @key
+        when -1
+          @left.retrieve(key)
+        when 0
+          @value
+        when 1
+          @right.retrieve(key)
+        else
+          nil
+        end
+      end
+
+      # returns [deleted_node, new_root, is_rebalance_needed]
+      def delete(key)
+        ret = self
+        case key <=> @key
+        when -1
+          deleted, @left, rebalance = @left.delete(key)
+          if rebalance
+            ret, rebalance = rebalance_for_left_delete
+          end
+        when 0
+          deleted = self
+          ret, rebalance = delete_node
+        when 1
+          deleted, @right, rebalance = @right.delete(key)
+          if rebalance
+            ret, rebalance = rebalance_for_right_delete
+          end
+        else
+          raise TypeError, "cannot compare #{key} and #{@key} with <=>"
+        end
+        [deleted, ret, rebalance]
+      end
+
+      def dump_tree(io, indent = '')
+        @right.dump_tree(io, indent + '  ')
+        io << indent << sprintf("#<%s:0x%010x %s %s> => %s", self.class.name, __id__, @color, @key.inspect, @value.inspect) << $/
+        @left.dump_tree(io, indent + '  ')
+      end
+
+      def dump_sexp
+        left = @left.dump_sexp
+        right = @right.dump_sexp
+        if left or right
+          '(' + [@key, left || '-', right].compact.join(' ') + ')'
+        else
+          @key
+        end
+      end
+
+      # for debugging
+      def check_height
+        lh = @left.nil?  || @left.empty? ? 0 : @left.check_height
+        rh = @right.nil? || @right.empty? ? 0 : @right.check_height
+        if red?
+          if @left.red? or @right.red?
+            puts dump_tree(STDERR)
+            raise 'red/red assertion failed'
+          end
+        else
+          if lh != rh
+            puts dump_tree(STDERR)
+            raise "black height unbalanced: #{lh} #{rh}"
+          end
+        end
+        (lh > rh ? lh : rh) + (black? ? 1 : 0)
+      end
+
+    protected
+
+      def children_color?(color)
+        @right.color == @left.color && @right.color == color
+      end
+
+      def color=(color)
+        @color = color
+      end
+
+      def left=(left)
+        @left = left
+      end
+
+      def right=(right)
+        @right = right
+      end
+
+      def color_flip(other)
+        @color, other.color = other.color, @color
+      end
+
+      def delete_min
+        if @left.empty?
+          [self, *delete_node]
+        else
+          ret = self
+          deleted, @left, rebalance = @left.delete_min
+          if rebalance
+            ret, rebalance = rebalance_for_left_delete
+          end
+          [deleted, ret, rebalance]
+        end
+      end
+
+      # trying to rebalance when the left sub-tree is 1 level lower than the right
+      def rebalance_for_left_delete
+        ret = self
+        rebalance = false
+        if black?
+          if @right.black?
+            if @right.children_color?(:BLACK)
+              # make whole sub-tree 1 level lower and ask rebalance
+              @right.color = :RED
+              rebalance = true
+            else
+              # move 1 black from the right to the left by single/double rotation
+              ret = balanced_rotate_left
+            end
+          else
+            # flip this sub-tree into another type of 3-children node
+            ret = rotate_left
+            # try to rebalance in sub-tree
+            ret.left, rebalance = ret.left.rebalance_for_left_delete
+            raise 'should not happen' if rebalance
+          end
+        else # red
+          if @right.children_color?(:BLACK)
+            # make right sub-tree 1 level lower
+            color_flip(@right)
+          else
+            # move 1 black from the right to the left by single/double rotation
+            ret = balanced_rotate_left
+          end
+        end
+        [ret, rebalance]
+      end
+
+      # trying to rebalance when the right sub-tree is 1 level lower than the left
+      # See rebalance_for_left_delete.
+      def rebalance_for_right_delete
+        ret = self
+        rebalance = false
+        if black?
+          if @left.black?
+            if @left.children_color?(:BLACK)
+              @left.color = :RED
+              rebalance = true
+            else
+              ret = balanced_rotate_right
+            end
+          else
+            ret = rotate_right
+            ret.right, rebalance = ret.right.rebalance_for_right_delete
+            raise 'should not happen' if rebalance
+          end
+        else # red
+          if @left.children_color?(:BLACK)
+            color_flip(@left)
+          else
+            ret = balanced_rotate_right
+          end
+        end
+        [ret, rebalance]
+      end
+
+      # move 1 black from the right to the left by single/double rotation
+      def balanced_rotate_left
+        if @right.left.red? and @right.right.black?
+          @right = @right.rotate_right
+        end
+        ret = rotate_left
+        ret.right.color = ret.left.color = :BLACK
+        ret
+      end
+
+      # move 1 black from the left to the right by single/double rotation
+      def balanced_rotate_right
+        if @left.right.red? and @left.left.black?
+          @left = @left.rotate_left
+        end
+        ret = rotate_right
+        ret.right.color = ret.left.color = :BLACK
+        ret
+      end
+
+      # Right single rotation
+      # (b a (D c E)) where D and E are RED --> (d (B a c) E)
+      #
+      #   b              d
+      #  / \            / \
+      # a   D    ->    B   E
+      #    / \        / \
+      #   c   E      a   c
+      #
+      def rotate_left
+        root = @right
+        @right = root.left
+        root.left = self
+        root.color_flip(root.left)
+        root
+      end
+
+      # Left single rotation
+      # (d (B A c) e) where A and B are RED --> (b A (D c e))
+      #
+      #     d          b
+      #    / \        / \
+      #   B   e  ->  A   D
+      #  / \            / \
+      # A   c          c   e
+      #
+      def rotate_right
+        root = @left
+        @left = root.right
+        root.right = self
+        root.color_flip(root.right)
+        root
+      end
+
+      # Pull up red nodes
+      # (b (A C)) where A and C are RED --> (B (a c))
+      #
+      #   b          B
+      #  / \   ->   / \
+      # A   C      a   c
+      #
+      def pullup_red
+        if black? and children_color?(:RED)
+          @left.color = @right.color = :BLACK
+          self.color = :RED
+        end
+        self
+      end
+
+    private
+
+      # trying to rebalance when the left sub-tree is 1 level higher than the right
+      # precondition: self is black and @left is red
+      def rebalance_for_left_insert
+        # move 1 black from the left to the right by single/double rotation
+        if @left.right.red?
+          @left = @left.rotate_left
+        end
+        rotate_right
+      end
+
+      # trying to rebalance when the right sub-tree is 1 level higher than the left
+      # See rebalance_for_left_insert.
+      def rebalance_for_right_insert
+        if @right.left.red?
+          @right = @right.rotate_right
+        end
+        rotate_left
+      end
+
+      def delete_node
+        rebalance = false
+        if @left.empty? and @right.empty?
+          # just remove this node and ask rebalance to the parent
+          new_root = EMPTY
+          if black?
+            rebalance = true
+          end
+        elsif @left.empty? or @right.empty?
+          # pick the single children
+          new_root = @left.empty? ? @right : @left
+          if black?
+            # keep the color black
+            raise 'should not happen' unless new_root.red?
+            color_flip(new_root)
+          else
+            # just remove the red node
+          end
+        else
+          # pick the minimum node from the right sub-tree and replace self with it
+          deleted, @right, rebalance = @right.delete_min
+          new_root = Node.new(deleted.key, deleted.value, @left, @right, @color)
+          if rebalance
+            new_root, rebalance = new_root.rebalance_for_right_delete
+          end
+        end
+        [new_root, rebalance]
+      end
+
+      def collect
+        pool = []
+        each do |key, value|
+          pool << yield(key, value)
+        end
+        pool
+      end
+
+      class EmptyNode < Node
+        def initialize
+          @value = nil
+          @color = :BLACK
+        end
+
+        def empty?
+          true
+        end
+
+        def size
+          0
+        end
+
+        def each(&block)
+          # intentionally blank
+        end
+
+        # returns new_root
+        def insert(key, value)
+          Node.new(key, value, self, self)
+        end
+
+        # returns value
+        def retrieve(key)
+          UNDEFINED
+        end
+
+        # returns [deleted_node, new_root, is_rebalance_needed]
+        def delete(key)
+          [self, self, false]
+        end
+
+        def dump_tree(io, indent = '')
+          # intentionally blank
+        end
+
+        def dump_sexp
+          # intentionally blank
+        end
+      end
+      EMPTY = Node::EmptyNode.new.freeze
+    end
+
+    DEFAULT = Object.new
+
+    attr_accessor :default
+    attr_reader :default_proc
+
+    def initialize(default = DEFAULT, &block)
+      if block && default != DEFAULT
+        raise ArgumentError, 'wrong number of arguments'
+      end
+      @root = Node::EMPTY
+      @default = default
+      @default_proc = block
+    end
+
+    def root
+      @root
+    end
+
+    def empty?
+      root == Node::EMPTY
+    end
+
+    def size
+      root.size
+    end
+    alias length size
+
+    def each(&block)
+      if block_given?
+        root.each(&block)
+        self
+      else
+        Enumerator.new(root)
+      end
+    end
+    alias each_pair each
+
+    def each_key
+      if block_given?
+        root.each do |k, v|
+          yield k
+        end
+        self
+      else
+        Enumerator.new(root, :each_key)
+      end
+    end
+
+    def each_value
+      if block_given?
+        root.each do |k, v|
+          yield v
+        end
+        self
+      else
+        Enumerator.new(root, :each_value)
+      end
+    end
+
+    def keys
+      root.keys
+    end
+
+    def values
+      root.values
+    end
+
+    def clear
+      @root = Node::EMPTY
+    end
+
+    def []=(key, value)
+      @root = @root.insert(key, value)
+      @root.set_root
+      @root.check_height if $DEBUG
+    end
+    alias insert []=
+
+    def key?(key)
+      root.retrieve(key) != Node::UNDEFINED
+    end
+    alias has_key? key?
+
+    def [](key)
+      value = @root.retrieve(key)
+      if value == Node::UNDEFINED
+        default_value
+      else
+        value
+      end
+    end
+
+    def delete(key)
+      deleted, @root, rebalance = @root.delete(key)
+      unless empty?
+        @root.set_root
+        @root.check_height if $DEBUG
+      end
+      deleted.value
+    end
+
+    def dump_tree(io = '')
+      root.dump_tree(io)
+      io << $/
+      io
+    end
+
+    def dump_sexp
+      root.dump_sexp || ''
+    end
+
+    def to_hash
+      inject({}) { |r, (k, v)| r[k] = v; r }
+    end
+
+    def minimum_pair()
+        # Return the key with the smallest key value.
+        return nil if @root.empty?
+
+        current_node = @root
+        while not current_node.left.empty?
+          current_node = current_node.left
+        end
+
+        [current_node.key, current_node.value]
+     end
+
+     def next_gte_pair(key)
+       # Returns the key/value pair with a key that follows the provided key in
+       # sorted order.
+       node = next_gte_node(@root, key)
+       [node.key, node.value] if not node.empty?
+     end
+
+  protected
+
+     def next_gte_node(node, key)
+        return RedBlackTree::Node::EMPTY if node.empty?
+
+        if key < node.key
+         # The current key qualifies as after the provided key. However, we need
+         # to check the tree on the left to see if there's a key in there also
+         # greater than the provided key but less than the current key.
+         after = next_gte_node(node.left, key)
+         after = node if after.empty?
+       elsif key > node.key
+         # The current key will not be after the provided key, but something
+         # in the right branch maybe. Check the right branch for the first key
+         # larger than our value.
+         after = next_gte_node(node.right, key)
+       elsif node.key == key
+         # An exact match qualifies as the next largest node.
+         after = node
+       end
+
+       return after
+     end
+
+  private
+
+    def default_value
+      if @default != DEFAULT
+        @default
+      elsif @default_proc
+        @default_proc.call
+      else
+        nil
+      end
+    end
+  end
+  
+end

data/lib/consistent-cluster/consistent_hashing/ring.rb

@@ -0,0 +1,106 @@
+
+require 'digest/md5'
+#require 'zlib'
+
+module ConsistentCluster
+
+  module ConsistentHashing
+
+    # Public: the hash ring containing all configured nodes
+    #
+    class Ring
+
+      # Public: returns a new ring object
+      def initialize(nodes = [], replicas = 3)
+        @replicas = replicas
+        @ring = RedBlackTree.new
+
+        nodes.each { |node| add(node) }
+      end
+
+      # Public: returns the (virtual) points in the hash ring
+      #
+      # Returns: a Fixnum
+      def length
+        @ring.length
+      end
+
+      # Public: adds a new node into the hash ring
+      #
+      def add(node)
+        @replicas.times do |i|
+          # generate the key of this (virtual) point in the hash
+          key = hash_key(node, i)
+
+          @ring[key] = VirtualPoint.new(node, key)
+        end
+      end
+
+      # Public: adds a new node into the hash ring like `add` but returns
+      # a reference to the ring to be used as a fluent interface
+      #
+      def <<(node)
+        add(node)
+        self
+      end
+
+      # Public: removes a node from the hash ring
+      #
+      def delete(node)
+        @replicas.times do |i|
+          key = hash_key(node, i)
+
+          @ring.delete key
+        end
+
+        self
+      end
+
+      # Public: gets the point for an arbitrary key
+      #
+      #
+      def point_for(key)
+        return nil if @ring.empty?
+        key = hash_key(key)
+        _, value = @ring.next_gte_pair(key)
+        _, value = @ring.minimum_pair unless value
+        value
+      end
+
+      # Public: gets the node where to store the key
+      #
+      # Returns: the node Object
+      def node_for(key)
+        point_for(key).node
+      end
+
+      # Public: get all nodes in the ring
+      #
+      # Returns: an Array of the nodes in the ring
+      def nodes
+        nodes = points.map { |point| point.node }
+        nodes.uniq
+      end
+
+      # Public: gets all points in the ring
+      #
+      # Returns: an Array of the points in the ring
+      def points
+        @ring.map { |point| point[1] }
+      end
+
+      protected
+
+      # Internal: hashes the key
+      #
+      # Returns: a String
+      def hash_key(key, index = nil)
+        key = "#{key}:#{index}" if index
+        #value = Zlib::crc32(key.to_s)
+        value = Digest::MD5.hexdigest(key.to_s)[0..16].hex
+        value
+      end
+    end
+  end
+
+end

data/lib/consistent-cluster/consistent_hashing/virtual_point.rb

@@ -0,0 +1,23 @@
+
+module ConsistentCluster
+
+  module ConsistentHashing
+
+    # Public: represents a virtual point on the hash ring
+    #
+    class VirtualPoint
+      attr_reader :node, :index
+
+      def initialize(node, index)
+        @node = node
+        @index = index.to_i
+      end
+
+      # Public: set a new index for the virtual point. Useful if the point gets duplicated
+      def index=(index)
+        @index = index.to_i
+      end
+    end
+  end
+
+end

data/lib/consistent-cluster/consistent_hashing.rb

@@ -0,0 +1,6 @@
+
+require "consistent-cluster/consistent_hashing/red_black_tree"
+
+require "consistent-cluster/consistent_hashing/virtual_point"
+
+require "consistent-cluster/consistent_hashing/ring"

data/lib/consistent-cluster/demo/client_debug.rb

@@ -0,0 +1,59 @@
+
+require "consistent-cluster/client"
+
+require "thrift_client"
+
+require "happy_profile/client/thrift" #thrift client example
+
+cluster = {}
+
+["127.0.0.1:9091","127.0.0.1:9092","127.0.0.1:9093"].each do |iport|
+  cluster[iport] = ThriftClient.new("servers" => iport,
+                  "multiplexed" => false,
+                  "protocol" => 'binary',
+                  "transport" => 'socket',
+                  "framed" => false,
+                  "disconnect_exception_classes" => '',
+                  "application_exception_classes" => '',
+                  "size" => 1,
+                  "timeout" => 12,
+                  "client_class" => "HappyProfile::HappyProfileThriftService::Client",
+                  "test_on_borrow" => true,
+                  "pool_timeout" => 12)
+end
+
+all_config = {
+  consistent_hashing_replicas: 100,
+  cluster: cluster
+}
+
+profile_services = ConsistentCluster::Client.new(all_config)
+
+while true
+
+  sleep 1
+
+  key = rand(10000)
+
+  2.times do
+    begin
+      profile_services.shard(key).ping.inspect
+    rescue Exception => boom
+      puts boom.message
+    end
+  end
+
+end
+
+# while true
+
+#   sleep 1
+
+#   begin
+#     profile_services.shard.ping.inspect
+#   rescue Exception => boom
+#     puts boom.message
+#   end
+
+# end
+

data/lib/consistent-cluster/demo/rbtree_debug.rb

@@ -0,0 +1,18 @@
+
+require "consistent-cluster"
+
+profile_servers_map = {
+  x1:  {ip: "192.168.1.136", port: "8081"},
+  x2:  {ip: "192.168.1.136", port: "8081"},
+  x3:  {ip: "192.168.1.136", port: "8081"},
+  x4:  {ip: "192.168.1.136", port: "8081"}
+}
+
+nodes = profile_servers_map.keys
+
+ch_ring = ConsistentCluster::ConsistentHashing::Ring.new(nodes,10)
+
+
+(1..100).each do |key|
+  p ch_ring.point_for(key)
+end

data/lib/consistent-cluster/demo/sync_client_debug.rb

@@ -0,0 +1,66 @@
+
+require "consistent-cluster/sync-client"
+
+require "thrift_client"
+
+require "happy_profile/client/thrift" #thrift client example
+
+require "json"
+
+all_config = {
+  consistent_hashing_replicas: 100,
+  create_proc: Proc.new { |zk_content|
+    app_info = JSON.parse(zk_content)
+    ThriftClient.new("servers" => "#{app_info["host"]}:#{app_info["port"]}",
+                    "multiplexed" => app_info["serviceNames"].length > 1,
+                    "protocol" => 'binary',
+                    "transport" => 'socket',
+                    "framed" => false,
+                    "disconnect_exception_classes" => '',
+                    "application_exception_classes" => '',
+                    "size" => 1,
+                    "timeout" => 12,
+                    "client_class" => "HappyProfile::HappyProfileThriftService::Client",
+                    "test_on_borrow" => true,
+                    "pool_timeout" => 12)
+  },
+  destroy_proc: Proc.new { |client|
+    client.destroy
+  },
+  after_sync_proc: Proc.new { |info|
+    puts info.inspect
+  },
+  zookeeper_service: "127.0.0.1:2181",
+  zookeeper_path: "/test"
+}
+
+profile_services = ConsistentCluster::SyncClient.new(all_config)
+
+while true
+
+  sleep 1
+
+  key = rand(10000)
+
+  2.times do
+    begin
+      profile_services.shard(key).ping.inspect
+    rescue Exception => boom
+      puts boom.message
+    end
+  end
+
+end
+
+# while true
+
+#   sleep 1
+
+#   begin
+#     profile_services.shard.ping.inspect
+#   rescue Exception => boom
+#     puts boom.message
+#   end
+
+# end
+

data/lib/consistent-cluster/demo/zk_debug.rb

@@ -0,0 +1,69 @@
+require 'zk'
+require 'json'
+
+$zk = ZK.new("127.0.0.1:2181")
+
+$path = "/test"
+
+def create(hash)
+  app_name = hash[:id]
+
+  $zk.create("#{$path}/#{app_name}",hash.to_json)
+end
+
+def set(hash)
+  app_name = hash[:id]
+  $zk.set("#{$path}/#{app_name}",hash.to_json)
+end
+
+def delete(app)
+  $zk.delete("#{$path}/#{app}")
+end
+
+def clear
+  apps = $zk.children($path)
+  apps.each do |app|
+    delete(app)
+  end
+end
+
+
+app1 = {
+  group: "uts",
+  host: "127.0.0.1",
+  port: "9091",
+  id: "127.0.0.1:9091",
+  protocolType: "thrift",
+  serviceNames: ["com.ximalaya.service.uts.api.thrift.IUserTrackRecordServiceHandler$Iface"]
+}
+
+app2 = {
+  group: "uts",
+  host: "127.0.0.1",
+  port: "9092",
+  id: "127.0.0.1:9092",
+  protocolType: "thrift",
+  serviceNames: ["com.ximalaya.service.uts.api.thrift.IUserTrackRecordServiceHandler$Iface"]
+}
+
+app3 = {
+  group: "uts",
+  host: "127.0.0.1",
+  port: "9093",
+  id: "127.0.0.1:9093",
+  protocolType: "thrift",
+  serviceNames: ["com.ximalaya.service.uts.api.thrift.IUserTrackRecordServiceHandler$Iface"]
+}
+
+clear
+
+create(app1)
+
+create(app2)
+
+create(app3)
+
+#set(app2)
+
+
+

data/lib/consistent-cluster/sync-client.rb

@@ -0,0 +1,152 @@
+
+require "consistent-cluster/version"
+
+require "consistent-cluster/consistent_hashing"
+
+gem "zk", "~> 1.9.5" #gem本身不默认依赖zk,此处补充依赖
+
+require "zk"
+
+module ConsistentCluster
+
+  class SyncClient
+
+    def initialize(options)
+      @zk = ZK.new(options[:zookeeper_service])
+      @path = options[:zookeeper_path]
+
+      @data = {}
+      @cluster = {}
+
+      replicas = options[:consistent_hashing_replicas] || 3
+      @ring = ConsistentHashing::Ring.new([],replicas)
+
+      @create_proc = options[:create_proc]
+      @destroy_proc = options[:destroy_proc]
+      @after_sync_proc = options[:after_sync_proc] 
+
+      @to_sync,@syncing = false,false
+
+      @zk.register(@path) do |event|
+        sync_services
+      end
+
+      sync_services
+
+      @shard_num = 0
+    end
+
+    def shard(key=nil)
+      cluster_sum = @cluster.length
+      raise "no service available" if cluster_sum < 1
+      if key
+        point = @ring.point_for(key)
+        server = @cluster[point.node]
+      else
+        @shard_num += 1
+        @shard_num = @shard_num%cluster_sum
+        server = @cluster.values[@shard_num]
+      end
+      server
+    end
+
+    protected
+
+    def sync_services
+      @to_sync = true
+      if !@syncing
+        syncing_process
+      end
+    end
+
+    def syncing_process
+      @syncing = true
+      while @to_sync
+        @to_sync = false
+        app_names = sync_children
+        current_app_names = @cluster.keys
+
+        to_update = current_app_names&app_names
+        to_create = app_names - current_app_names
+        to_destroy = current_app_names - app_names
+
+        to_update.each do |app_name|
+          update_service(app_name)
+        end
+
+        to_create.each do |app_name|
+          create_service(app_name)
+        end
+
+        to_destroy.each do |app_name|
+          destroy_service(app_name)
+        end
+      end
+      @syncing = false
+      if @after_sync_proc
+        clone_data = Marshal.load(Marshal.dump(@data)) #avoid change outside
+        @after_sync_proc.call(clone_data)
+      end
+    end
+
+    def sync_children
+      @zk.children(@path, watch: true)
+    end
+
+    def create_service(app_name)
+
+      app_content = get_app_content(app_name)
+
+      server = @create_proc.call(app_content)
+
+      @data[app_name] = app_content
+
+      @cluster[app_name] = server
+
+      @ring.add(app_name)
+
+      app_path = "#{@path}/#{app_name}"
+      @zk.get(app_path, watch: true)
+    rescue Exception => boom
+      puts "sync create :#{app_name} raise #{boom.class} - #{boom.message}"
+    end
+
+    def destroy_service(app_name)
+      return if app_name.to_s.empty?
+      @ring.delete(app_name)
+
+      if server = @cluster[app_name]
+        @data.delete(app_name)
+        @cluster.delete(app_name)
+        if @destroy_proc
+          @destroy_proc.call(server)
+        end
+      end
+
+    rescue Exception => boom
+      puts "sync destroy :#{app_name} raise #{boom.class} - #{boom.message}"
+    end
+
+    def update_service(app_name)
+      return if app_name.to_s.empty?
+
+      app_content = get_app_content(app_name)
+
+      cache_info = @data[app_name]
+      if cache_info != app_content
+        destroy_service(app_name)
+        create_service(app_name)
+      end
+    rescue Exception => boom
+      puts "sync update :#{app_name} raise #{boom.class} - #{boom.message}"
+    end
+
+    def get_app_content(app_name)
+      app_path = "#{@path}/#{app_name}"
+      content = @zk.get(app_path).first
+      content
+    end
+
+  end
+
+end

data/lib/consistent-cluster/version.rb

@@ -0,0 +1,3 @@
+module ConsistentCluster
+  Version = "1.0.0"
+end

data/lib/consistent-cluster.rb

@@ -0,0 +1,2 @@
+
+#nothing default

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: consistent-cluster
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- jeffrey6052
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: atomic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.99
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.99
+description: |2-
+
+  红黑树,一致性Hash算法，Hash环
+  支持zookeeper同步(依赖gem： zk)
+email:
+- jeffrey6052@163.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/consistent-cluster.rb
+- lib/consistent-cluster/client.rb
+- lib/consistent-cluster/consistent_hashing.rb
+- lib/consistent-cluster/consistent_hashing/red_black_tree.rb
+- lib/consistent-cluster/consistent_hashing/ring.rb
+- lib/consistent-cluster/consistent_hashing/virtual_point.rb
+- lib/consistent-cluster/demo/client_debug.rb
+- lib/consistent-cluster/demo/rbtree_debug.rb
+- lib/consistent-cluster/demo/sync_client_debug.rb
+- lib/consistent-cluster/demo/zk_debug.rb
+- lib/consistent-cluster/sync-client.rb
+- lib/consistent-cluster/version.rb
+homepage: ''
+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.4.5
+signing_key: 
+specification_version: 4
+summary: "用于打包集群服务接口，方便客户端调用"
+test_files: []