ruster 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c35baea7d1a295313170c4ef1345c6f22f872697
-  data.tar.gz: 76f8ba9ddf5ae1cf2cc5df865fe733770786fc21
+  metadata.gz: 96027b4bdf2c2795b11fd73f8810481dc3f8216b
+  data.tar.gz: 95eb3adb68b769c09c72413f6579815ab1e11cc9
 SHA512:
-  metadata.gz: ef371dc30165f7284d3e0d1c1b250125320f675cc27391790195147f0ddd17d53b287ac130b10e23c1ffe48052fea74ca0cfebb641d4d0d0d86c5900ddf26609
-  data.tar.gz: d5c88f5c3cc8389231029ceea8a69153457056cc5c452eb1113b53a5c921d9d45d5df1b6dae60de1180b18fd0e0626aa78347a3f0ac765eb178f47010e6db5bf
+  metadata.gz: 04da50f39fdf89bb5030fe9044df8a67e60f8ca62471e83c6bed6d587a771d0b7659de17780dcd8f7e2161c9d6f6b6f7de47c51fbba59fa958a3d8eba75385ae
+  data.tar.gz: 6f71ed0fb738302ffb98c10bfb4929c68e6a72b52a2874fffc8f722c79e4ca0b39c95c24f4d8b2d198bf08a882816ad773036d70a532e5906770ae4c136d036c

data/README.md

@@ -107,6 +107,8 @@ Also, I'd like to thank to [Eruca Sativa][eruca] and [Cirse][cirse]
 for the music that's currently blasting my speakers while I write
 this.
 
+Who said programming shouldn't be [fun][lovestory]? [Discuss on Hacker News][lovestoryhn].
+
 [redis]: http://redis.io/
 [redis-cluster]: http://redis.io/topics/cluster-tutorial
 [redic]: https://github.com/amakawa/redic
@@ -120,3 +122,5 @@ this.
 [@pote]: https://twitter.com/poteland
 [@lucasefe]: https://twitter.com/lucasefe
 [nameme]: https://twitter.com/inkel/status/444638064393326592
+[lovestory]: https://github.com/inkel/ruster/blob/90f7da1c281bfc1a5fe01ccf8057f948278b3685/test/node.rb#L150-198
+[lovestoryhn]: https://news.ycombinator.com/item?id=7406297

data/bin/ruster

@@ -1,7 +1,7 @@
 #! /usr/bin/env ruby
 
-require "redic"
 require "clap"
+require_relative "../lib/ruster"
 
 $verbose = 0
 
@@ -41,306 +41,46 @@ EOU
 
 abort USAGE if action.nil? or args.nil? or args.empty?
 
-module UI
-  def err msg
-    $stderr.puts msg
-  end
-
-  def abort msg, backtrace=[]
-    err msg
-    backtrace.each { |line| err line } if $verbose > 1
-    exit 1
-  end
-
-  def info *args
-    $stdout.puts args.join(" ")
-  end
-
-  def log *args
-    $stdout.puts args.join(" ") if $verbose > 0
-  end
-
-  def debug *args
-    $stdout.puts args.join(" ") if $verbose > 1
-  end
-
-  extend self
-end
-
-class Node
-  [:id, :ip_port, :flags, :master_id, :ping, :pong, :config, :state, :slots].each do |a|
-    attr a
-  end
-
-  def initialize(ip_port)
-    @ip_port = ip_port
-    load_info!
-  end
-
-  def cluster_enabled?
-    call("INFO", "cluster").include?("cluster_enabled:1")
-  end
-
-  def only_node?
-    call("CLUSTER", "INFO").include?("cluster_known_nodes:1")
-  end
-
-  def empty?
-    call("INFO", "keyspace").strip == "# Keyspace"
-  end
-
-  def load_info!
-    call("CLUSTER", "NODES").split("\n").each do |line|
-      parts = line.split
-      next unless parts[2].include?("myself")
-      set_info!(*parts)
-    end
-  end
-
-  def set_info!(id, ip_port, flags, master_id, ping, pong, config, state, *slots)
-    @id = id
-    @flags = flags.split(",")
-    @master_id = master_id
-    @ping = ping
-    @pong = pong
-    @config = config
-    @state = state
-    @slots = slots
-    @ip_port = ip_port unless flags.include?("myself")
-  end
-
-  def ip
-    @ip_port.split(":").first
-  end
-
-  def port
-    @ip_port.split(":").last
-  end
-
-  def client
-    @client ||= Redic.new("redis://#{@ip_port}")
-  end
-
-  def call(*args)
-    UI.debug ">", *args
-    client.call(*args)
-  end
-
-  def dead?
-    %w{ disconnected fail noaddr }.any? do |flag|
-      flags.include?(flag)
-    end
-  end
-
-  def alive?
-    p [ip_port, flags, state]
-    !dead?
-  end
-
-  def to_s
-    "#{@id} [#{@ip_port}]"
-  end
-
-  def slots
-    return @_slots if @_slots
-
-    slots = { slots: [], migrating: {}, importing: {} }
-
-    @slots.each do |data|
-      if data[0] == /\[(\d+)-([<>])-(\d+)\]/
-        if $2 == ">"
-          slots[:migrating][$1] = $2
-        else
-          slots[:importing][$1] = $2
-        end
-      elsif data =~ /(\d+)-(\d+)/
-        b, e = $1.to_i, $2.to_i
-        (b..e).each { |slot| slots[:slots] << slot }
-      else
-        slots[:slots] << data.to_i
-      end
-    end
-
-    @_slots = slots
-  end
-end
-
-class Cluster
-  SLOTS = 16384
-
-  def initialize(addrs)
-    @addrs = Array(addrs)
-  end
-
-  def nodes
-    @nodes ||= @addrs.map { |addr| Node.new(addr) }
-  end
-
-  def allocate_slots(node, slots)
-    UI.log "Allocating #{slots.size} slots (#{slots.first}..#{slots.last}) in node #{node}"
-
-    UI.debug "> CLUSTER ADDSLOTS #{slots.first}..#{slots.last}"
-
-    res = node.client.call("CLUSTER", "ADDSLOTS", *slots)
-
-    UI.abort res.message if res.is_a?(RuntimeError)
-  end
-
-  def add_node(node)
-    default = nodes.first
-
-    UI.log "Joining node #{node} to node #{default}"
-
-    ip, port = node.ip_port.split(":")
-
-    res = default.call("CLUSTER", "MEET", ip, port)
-
-    UI.abort res.message if res.is_a?(RuntimeError)
-  end
-
-  def create!
-    nodes.each do |node|
-      raise ArgumentError, "Redis Server at #{node.ip_port} not running in cluster mode" unless node.cluster_enabled?
-      raise ArgumentError, "Redis Server at #{node.ip_port} already exists in a cluster" unless node.only_node?
-      raise ArgumentError, "Redis Server at #{node.ip_port} is not empty" unless node.empty?
-    end
-
-    UI.log "Allocating #{SLOTS} slots in #{nodes.length} nodes"
-
-    available_slots = 0.upto(SLOTS - 1).each_slice((SLOTS.to_f / nodes.length).ceil)
-
-    nodes.each do |node|
-      slots = available_slots.next.to_a
-
-      allocate_slots(node, slots)
-    end
-
-    nodes.each { |node| add_node node }
-  end
-
-  def remove_node(node)
-    default = nodes.first
-
-    UI.log "Removing node #{node} from cluster"
-
-    res = default.call("CLUSTER", "FORGET", node.id)
-
-    UI.abort res.message if res.is_a?(RuntimeError)
-  end
-
-  def nodes!
-    node = nodes.sample
-
-    node.call("CLUSTER", "NODES").split("\n").map do |line|
-      _, ip_port, flags, _ = line.split
-
-      if flags.include?("myself")
-        node
-      else
-        Node.new(ip_port)
-      end
-    end
-  end
-
-  def each(*args)
-    nodes!.each do |node|
-      UI.info "#{node}: #{args.join(' ')}"
-
-      res = node.call(*args)
-      UI.info res
-      UI.info "--"
-    end
-  end
-
-  def reshard(target_addr, slots, sources, opts={})
-    options = { timeout: 1_000, db: 0 }.merge(opts)
-
-    target = Node.new(target_addr)
-
-    from = sources.map{ |addr| Node.new(addr) } \
-      .sort{ |a, b| b.slots[:slots].size <=> a.slots[:slots].size }
-
-    total_slots = from.inject(0) do |sum, source|
-      sum + source.slots[:slots].size
-    end
-
-    UI.abort "No slots found to migrate" unless total_slots > 0
-
-    from.each do |source|
-      # Proportional number of slots, based on current assigned slots
-      node_slots = (slots.to_f / total_slots * source.slots[:slots].size).to_i
-
-      UI.info "Moving #{node_slots} slots from #{source} to #{target}"
-
-      source.slots[:slots].take(node_slots).each do |slot|
-        count = source.call("CLUSTER", "COUNTKEYSINSLOT", slot)
-
-        UI.log "  Moving slot #{slot} (#{count} keys)"
-
-        target.call("CLUSTER", "SETSLOT", slot, "IMPORTING", source.id)
-        source.call("CLUSTER", "SETSLOT", slot, "MIGRATING", target.id)
-
-        done = false
-
-        until done
-          keys = source.call("CLUSTER", "GETKEYSINSLOT", slot, 10)
-
-          done = keys.empty?
-
-          keys.each do |key|
-            res = source.call("MIGRATE", target.ip, target.port, key, options[:db], options[:timeout])
-
-            UI.abort res.message if res.is_a?(RuntimeError)
-
-            $stdout.print '.' if $verbose > 2
-          end
-        end
-
-        nodes!.each do |node|
-          res = node.call("CLUSTER", "SETSLOT", slot, "NODE", target.id)
-
-          UI.err res.message if res.is_a?(RuntimeError)
-        end
-      end
-    end
-  end
-end
-
 begin
   case action
   when "create"
-    cluster = Cluster.new(args)
-    cluster.create!
+    Ruster::Cluster.create!(args)
   when "add"
-    cluster = Cluster.new(args.shift)
+    cluster = Ruster::Cluster.new(Ruster::Node.new(args.shift))
 
     args.each do |addr|
-      cluster.add_node(Node.new(addr))
+      ip, port = addr.split(":")
+      cluster.add_node(ip, port)
     end
   when "remove"
-    cluster = Cluster.new(args.shift)
+    cluster = Ruster::Cluster.new(Ruster::Node.new(args.shift))
 
     args.each do |addr|
-      cluster.remove_node(Node.new(addr))
+      node = Ruster::Node.new(addr)
+      node.load!
+      cluster.remove_node(node)
     end
   when "each"
-    cluster = Cluster.new(args.shift)
+    cluster = Ruster::Cluster.new(Ruster::Node.new(args.shift))
 
-    cluster.each(*args)
+    cluster.each(*args) do |node, res|
+      puts "> #{node}"
+      puts res
+    end
   when "reshard"
-    options = {}
+    cluster = Ruster::Cluster.new(Ruster::Node.new(args.shift))
 
-    cluster_addr, slots, target_addr, *sources = Clap.run args, {
-      "-t" => ->(ms) { options[:timeout] = Integer(ms) },
-      "-n" => ->(db) { options[:db] = db }
-    }
+    num_slots, target_addr, *sources_addr = args
 
-    cluster = Cluster.new(cluster_addr)
+    target  = Ruster::Node.new(target_addr)
+    sources = sources_addr.map{ |addr| Ruster::Node.new(addr) }
 
-    cluster.reshard(target_addr, slots, sources, options)
+    cluster.reshard(target, num_slots.to_i, sources)
   else
-    UI.abort "Unrecognized action `#{action}'\n#{USAGE}"
+    abort "Unrecognized action `#{action}'\n#{USAGE}"
   end
 rescue => ex
-  UI.abort ex.message, ex.backtrace
+  $stderr.puts ex.message
+  ex.backtrace.each{ |line| $stderr.puts line } if $verbose > 1
+  exit 2
 end

data/lib/ruster.rb

@@ -0,0 +1,8 @@
+require "redic"
+
+class Ruster
+end
+
+require_relative "ruster/util"
+require_relative "ruster/node"
+require_relative "ruster/cluster"

data/lib/ruster/cluster.rb

@@ -0,0 +1,143 @@
+class Ruster::Cluster
+  include Ruster::Util
+
+  attr :entry
+
+  SLOTS = 16384
+
+  def initialize(entry)
+    @entry = entry
+  end
+
+  def info
+    @entry.cluster_info
+  end
+
+  def state
+    info[:cluster_state]
+  end
+
+  def ok?
+    state == "ok"
+  end
+
+  def fail?
+    state == "fail"
+  end
+
+  def slots_assigned
+    info[:cluster_slots_assigned].to_i
+  end
+
+  def slots_ok
+    info[:cluster_slots_ok].to_i
+  end
+
+  def slots_pfail
+    info[:cluster_slots_pfail].to_i
+  end
+
+  def slots_fail
+    info[:cluster_slots_fail].to_i
+  end
+
+  def known_nodes
+    info[:cluster_known_nodes].to_i
+  end
+
+  def size
+    info[:cluster_size].to_i
+  end
+
+  def current_epoch
+    info[:cluster_current_epoch].to_i
+  end
+
+  def stats_messages_sent
+    info[:cluster_stats_messages_sent].to_i
+  end
+
+  def stats_messages_received
+    info[:stats_messages_received].to_i
+  end
+
+  def nodes
+    @entry.load!
+    [@entry] + @entry.friends
+  end
+
+  def add_node(ip, port)
+    @entry.meet(ip, port)
+  end
+
+  def remove_node(bye)
+    nodes.each do |node|
+      next if node.id == bye.id
+      node.forget(bye)
+    end
+  end
+
+  def self.create!(addrs)
+    # Check nodes
+    nodes = addrs.map do |addr|
+      node = ::Ruster::Node.new(addr)
+
+      raise ArgumentError, "Redis Server at #{addr} not running in cluster mode" unless node.enabled?
+      raise ArgumentError, "Redis Server at #{addr} already exists in a cluster" unless node.only_node?
+      raise ArgumentError, "Redis Server at #{addr} is not empty" unless node.empty?
+
+      node
+    end
+
+    # Allocate slots evenly among all nodes
+    slots_by_node = 0.upto(SLOTS - 1).each_slice((SLOTS.to_f / nodes.length).ceil)
+
+    nodes.each do |node|
+      slots = slots_by_node.next.to_a
+
+      node.add_slots(*slots)
+    end
+
+    # Create cluster by meeting nodes
+    entry = nodes.shift
+
+    nodes.each { |node| entry.meet node.ip, node.port }
+
+    new(entry)
+  end
+
+  def each(*args, &block)
+    nodes.each do |node|
+      yield node, node.call(*args)
+    end
+  end
+
+  def reshard(target, num_slots, sources)
+    raise ArgumentError, "Target node #{target} is not part of the cluster" unless in_cluster?(target)
+    target.load!
+
+    sources.each do |source|
+      raise ArgumentError, "Source node #{source} is not part of the cluster" unless in_cluster?(source)
+      source.load!
+    end
+
+    sources.sort_by!{ |node| -node.slots.size }
+
+    total_slots = sources.inject(0) do |sum, node|
+      sum + node.all_slots.size
+    end
+
+    sources.each do |node|
+      # Proportional number of slots based on node size
+      node_slots = (num_slots.to_f / total_slots * node.all_slots.size)
+
+      node.all_slots.take(node_slots).each do |slot|
+        node.move_slot!(slot, target)
+      end
+    end
+  end
+
+  def in_cluster?(node)
+    nodes.any?{ |n| n.addr == node.addr }
+  end
+end

data/lib/ruster/node.rb

@@ -0,0 +1,172 @@
+class Ruster::Node
+  include Ruster::Util
+
+  attr :addr
+  attr :id
+  attr :flags
+  attr :master_id
+  attr :ping_epoch
+  attr :pong_epoch
+  attr :config_epoch
+  attr :state
+  attr :slots
+  attr :migrating
+  attr :importing
+  attr :friends
+
+  def initialize(addr)
+    @addr = addr
+  end
+
+  def client
+    @client ||= Redic.new("redis://#{addr}")
+  end
+
+  def call(*args)
+    res = client.call(*args)
+    raise res if res.is_a?(RuntimeError)
+    res
+  end
+
+  def enabled?
+    parse_info(call("INFO", "cluster"))[:cluster_enabled] == "1"
+  end
+
+  def read_info_line!(info_line)
+    parts = info_line.split
+
+    @id = parts.shift
+    addr = parts.shift
+    @flags = parts.shift.split(",")
+    @addr = addr unless @flags.include?("myself")
+    @master_id = parts.shift
+    @ping_epoch = parts.shift.to_i
+    @pong_epoch = parts.shift.to_i
+    @config_epoch = parts.shift.to_i
+    @state = parts.shift
+    @slots = []
+    @migrating = {}
+    @importing = {}
+
+    parts.each do |slots|
+      case slots
+      when /^(\d+)-(\d+)$/ then @slots << ($1.to_i..$2.to_i)
+      when /^\d+$/ then @slots << (slots.to_i..slots.to_i)
+      when /^\[(\d+)-([<>])-([a-z0-9]+)\]$/
+        case $2
+        when ">" then @migrating[$1.to_i] = $3
+        when "<" then @importing[$1.to_i] = $3
+        end
+      end
+    end
+  end
+
+  def all_slots
+    slots.map(&:to_a).flatten
+  end
+
+  def to_s
+    "#{addr} [#{id}]"
+  end
+
+  def self.from_info_line(info_line)
+    _, addr, _ = info_line.split
+    new(addr).tap { |node| node.read_info_line!(info_line) }
+  end
+
+  def load!
+    @friends = []
+
+    call("CLUSTER", "NODES").split("\n").each do |line|
+      if line.include?("myself")
+        read_info_line!(line)
+      else
+        @friends << self.class.from_info_line(line)
+      end
+    end
+  end
+
+  def meet(ip, port)
+    call("CLUSTER", "MEET", ip, port)
+  end
+
+  def forget(node)
+    raise ArgumentError, "Node #{node} is not empty" unless node.slots.empty? and node.migrating.empty? and node.importing.empty?
+    call("CLUSTER", "FORGET", node.id)
+  end
+
+  def replicate(node)
+    call("CLUSTER", "REPLICATE", node.id)
+  end
+
+  def slaves
+    call("CLUSTER", "SLAVES", id).map do |line|
+      self.class.from_info_line(line)
+    end
+  end
+
+  def add_slots(*slots)
+    call("CLUSTER", "ADDSLOTS", *slots)
+  end
+
+  def del_slots(*slots)
+    call("CLUSTER", "DELSLOTS", *slots)
+  end
+
+  def flush_slots!
+    call("CLUSTER", "FLUSHSLOTS")
+  end
+
+  def cluster_info
+    parse_info(call("CLUSTER", "INFO"))
+  end
+
+  def ip
+    addr.split(":").first
+  end
+
+  def port
+    addr.split(":").last
+  end
+
+  # In Redis Cluster only DB 0 is enabled
+  DB0 = 0
+
+  def move_slot!(slot, target, options={})
+    options[:num_keys] ||= 10
+    options[:timeout]  ||= call("CONFIG", "GET", "cluster-node-timeout")
+
+    # Tell the target node to import the slot
+    target.call("CLUSTER", "SETSLOT", slot, "IMPORTING", id)
+
+    # Tell the current node to export the slot
+    call("CLUSTER", "SETSLOT", slot, "MIGRATING", target.id)
+
+    # Export keys
+    done = false
+    until done
+      keys = call("CLUSTER", "GETKEYSINSLOT", slot, options[:num_keys])
+
+      done = keys.empty?
+
+      keys.each do |key|
+        call("MIGRATE", target.ip, target.port, key, DB0, options[:timeout])
+      end
+
+      # Tell cluster the location of the new slot
+      call("CLUSTER", "SETSLOT", slot, "NODE", target.id)
+
+      friends.each do |node|
+        node.call("CLUSTER", "SETSLOT", slot, "NODE", target.id)
+      end
+    end
+  end
+
+  def empty?
+    call("DBSIZE") == 0
+  end
+
+  def only_node?
+    parse_info(call("CLUSTER", "INFO"))[:cluster_known_nodes] == "1"
+  end
+end

data/lib/ruster/util.rb

@@ -0,0 +1,11 @@
+module Ruster::Util
+  def parse_info(info)
+    {}.tap do |data|
+      info.split("\r\n").each do |line|
+        next if line[0] == "#"
+        key, val = line.split(":")
+        data[key.to_sym] = val
+      end
+    end
+  end
+end

data/ruster.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name              = "ruster"
-  s.version           = "0.0.3"
+  s.version           = "0.0.4"
   s.summary           = "A simple Redis Cluster Administration tool"
   s.description       = "Control your Redis Cluster from the command line."
   s.authors           = ["Leandro López"]
@@ -15,5 +15,7 @@ Gem::Specification.new do |s|
   s.add_dependency   "redic"
   s.add_dependency   "clap"
 
+  s.add_development_dependency "protest"
+
   s.files             = `git ls-files`.split("\n")
 end

data/test/cluster.rb

@@ -0,0 +1,81 @@
+require_relative "./helper"
+
+require "timeout"
+
+Protest.describe "Ruster::Cluster" do
+  test "add node" do
+    with_nodes(n: 2) do |ports|
+      port_a, port_b = ports.to_a
+
+      bob = Ruster::Node.new("127.0.0.1:#{port_a}")
+      bob.add_slots(*0..16383)
+      cluster = Ruster::Cluster.new(bob)
+
+      Timeout.timeout(10) { sleep 0.05 until cluster.ok? }
+
+      assert_equal 1, cluster.nodes.size
+      assert_equal [0..16383], bob.slots
+
+      cluster.add_node("127.0.0.1", port_b)
+
+      Timeout.timeout(10) { sleep 0.05 until cluster.ok? }
+
+      assert_equal 2, cluster.nodes.size
+
+      slots = cluster.nodes.map do |node|
+        [node.addr, node.slots]
+      end
+
+      # Do not realloce slots
+      assert_equal 2, slots.size
+      assert slots.include?(["127.0.0.1:#{port_a}", [0..16383]])
+      assert slots.include?(["127.0.0.1:#{port_b}", []])
+    end
+  end
+
+  context "remove node" do
+    test "empty node" do
+      with_nodes(n: 3) do |ports|
+        port_a, port_b, port_c = ports.to_a
+
+        soveran = Ruster::Node.new("127.0.0.1:#{port_a}")
+        cuervo  = Ruster::Node.new("127.0.0.1:#{port_b}")
+        inkel   = Ruster::Node.new("127.0.0.1:#{port_c}")
+
+        soveran.add_slots(*0..8191)
+        cuervo.add_slots(*8192..16383)
+
+        cluster = Ruster::Cluster.new(soveran)
+        cluster.add_node(cuervo.ip, cuervo.port)
+        cluster.add_node(inkel.ip, inkel.port)
+
+        Timeout.timeout(10) { sleep 0.05 until cluster.ok? }
+
+        soveran.load!
+        cuervo.load!
+        inkel.load!
+
+        cluster.remove_node(inkel)
+
+        Timeout.timeout(10) { sleep 0.05 until cluster.ok? }
+
+        assert_equal 2, cluster.nodes.size
+
+        ids = cluster.nodes.map(&:id)
+
+        assert ids.include?(soveran.id)
+        assert ids.include?(cuervo.id)
+        assert !ids.include?(inkel.id)
+
+        slots = cluster.nodes.map do |node|
+          [node.addr, node.slots]
+        end
+
+        # Do not realloce slots
+        assert_equal 2, slots.size
+        assert slots.include?([soveran.addr, [0..8191]])
+        assert slots.include?([cuervo.addr, [8192..16383]])
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,58 @@
+$:.unshift(File.expand_path("../lib", File.dirname(__FILE__)))
+
+require "protest"
+require "ruster"
+require "tmpdir"
+
+def with_nodes(opts={})
+  options = {
+             n: 3,
+             init_port: 12701,
+             enabled: "yes"
+            }
+
+  options.merge!(opts)
+
+  end_port = options[:init_port] + options[:n] - 1
+
+  tmp = Dir.mktmpdir
+
+  pids  = []
+  ports = (options[:init_port]..end_port)
+
+  ports.each do |port|
+    pids << fork do
+      dir = File.join(tmp, port.to_s)
+
+      Dir.mkdir(dir)
+
+      args = [
+              "--port", port.to_s,
+              "--dir", dir,
+              "--save", "",
+              "--logfile", "./redis.log"
+             ]
+
+      if options[:enabled] == "yes"
+        args.concat(["--cluster-enabled", "yes",
+                     "--cluster-config-file", "redis.conf",
+                     "--cluster-node-timeout", "5000"])
+      end
+
+      exec "redis-server", *args
+    end
+  end
+
+  # Wait for redis-server to start
+  sleep 0.125
+
+  yield ports
+ensure
+  pids.each { |pid| Process.kill :TERM, pid }
+
+  Process.waitall
+
+  FileUtils.remove_entry_secure tmp
+end
+
+Protest.report_with((ENV["PROTEST_REPORT"] || "documentation").to_sym)

data/test/node.rb

@@ -0,0 +1,255 @@
+require_relative "./helper"
+
+Protest.describe "Node" do
+  test "is cluster enabled" do
+    with_nodes(n: 1) do |ports|
+      node = Ruster::Node.new("127.0.0.1:#{ports.first}")
+
+      assert node.enabled?
+    end
+  end
+
+  test "is not cluster enabled" do
+    with_nodes(n: 1, enabled: "no") do |ports|
+      node = Ruster::Node.new("127.0.0.1:#{ports.first}")
+
+      assert !node.enabled?
+    end
+  end
+
+  context "information" do
+    test "read and parses info line" do
+      info_line = "9aee954a0b7d6b49d7e68c18d08873c56aaead6b :0 myself,master - 0 1 2 connected"
+
+      node = Ruster::Node.new("127.0.0.1:12701")
+
+      node.read_info_line!(info_line)
+
+      assert_equal "9aee954a0b7d6b49d7e68c18d08873c56aaead6b", node.id
+      assert_equal "127.0.0.1:12701", node.addr
+      assert_equal ["myself", "master"], node.flags
+      assert_equal "-", node.master_id
+      assert_equal 0, node.ping_epoch
+      assert_equal 1, node.pong_epoch
+      assert_equal 2, node.config_epoch
+      assert_equal "connected", node.state
+      assert_equal [], node.slots
+
+      assert_equal "127.0.0.1:12701 [9aee954a0b7d6b49d7e68c18d08873c56aaead6b]", node.to_s
+    end
+
+    context "allocated slots" do
+      test "contiguous block" do
+        info_line = "9aee954a0b7d6b49d7e68c18d08873c56aaead6b :0 myself,master - 0 1 2 connected 0-16383"
+
+        node = Ruster::Node.new("127.0.0.1:12701")
+
+        node.read_info_line!(info_line)
+
+        assert_equal [(0..16383)], node.slots
+        assert       node.migrating.empty?
+        assert       node.importing.empty?
+      end
+
+      test "single" do
+        info_line = "9aee954a0b7d6b49d7e68c18d08873c56aaead6b :0 myself,master - 0 1 2 connected 4096"
+
+        node = Ruster::Node.new("127.0.0.1:12701")
+
+        node.read_info_line!(info_line)
+
+        assert_equal [(4096..4096)], node.slots
+        assert       node.migrating.empty?
+        assert       node.importing.empty?
+      end
+
+      test "migrating" do
+        info_line = "9aee954a0b7d6b49d7e68c18d08873c56aaead6b :0 myself,master - 0 1 2 connected [16383->-6daeaa65c37880d81c86e7d94b6d7b0a459eea9]"
+
+        node = Ruster::Node.new("127.0.0.1:12701")
+
+        node.read_info_line!(info_line)
+
+        assert_equal [], node.slots
+        assert_equal 1, node.migrating.size
+        assert_equal "6daeaa65c37880d81c86e7d94b6d7b0a459eea9", node.migrating[16383]
+        assert       node.importing.empty?
+      end
+
+      test "importing" do
+        info_line = "9aee954a0b7d6b49d7e68c18d08873c56aaead6b :0 myself,master - 0 1 2 connected [16383-<-6daeaa65c37880d81c86e7d94b6d7b0a459eea9]"
+
+        node = Ruster::Node.new("127.0.0.1:12701")
+
+        node.read_info_line!(info_line)
+
+        assert_equal [], node.slots
+        assert_equal 1, node.importing.size
+        assert_equal "6daeaa65c37880d81c86e7d94b6d7b0a459eea9", node.importing[16383]
+        assert       node.migrating.empty?
+      end
+
+      test "combined" do
+        info_line = "9aee954a0b7d6b49d7e68c18d08873c56aaead6b :0 myself,master - 0 1 2 connected 0-1024 2048 [3072->-6daeaa65c37880d81c86e7d94b6d7b0a459eea9] 4096 [6144-<-6daeaa65c37880d81c86e7d94b6d7b0a459eea9] 8192-16383"
+
+        node = Ruster::Node.new("127.0.0.1:12701")
+
+        node.read_info_line!(info_line)
+
+        assert_equal [(0..1024), (2048..2048), (4096..4096), (8192..16383)], node.slots
+
+        assert_equal 1, node.migrating.size
+        assert_equal "6daeaa65c37880d81c86e7d94b6d7b0a459eea9", node.migrating[3072]
+
+        assert_equal 1, node.importing.size
+        assert_equal "6daeaa65c37880d81c86e7d94b6d7b0a459eea9", node.importing[6144]
+      end
+
+      test "all allocated slots as an array" do
+        info_line = "9aee954a0b7d6b49d7e68c18d08873c56aaead6b :0 myself,master - 0 1 2 connected 0-3 5 10-13 16383"
+
+        node = Ruster::Node.new("127.0.0.1:12701")
+
+        node.read_info_line!(info_line)
+
+        assert_equal [0, 1, 2, 3, 5, 10, 11, 12, 13, 16383], node.all_slots
+      end
+    end
+
+    test "create from info line" do
+      info_line = "9aee954a0b7d6b49d7e68c18d08873c56aaead6b 127.0.0.1:12701 master - 0 1 2 connected"
+
+      node = Ruster::Node.from_info_line(info_line)
+
+      assert_equal "9aee954a0b7d6b49d7e68c18d08873c56aaead6b", node.id
+      assert_equal "127.0.0.1:12701", node.addr
+      assert_equal ["master"], node.flags
+      assert_equal "-", node.master_id
+      assert_equal 0, node.ping_epoch
+      assert_equal 1, node.pong_epoch
+      assert_equal 2, node.config_epoch
+      assert_equal "connected", node.state
+      assert_equal [], node.slots
+
+      assert_equal "127.0.0.1:12701 [9aee954a0b7d6b49d7e68c18d08873c56aaead6b]", node.to_s
+    end
+  end
+
+  context "in cluster" do
+    test "only node" do
+      with_nodes(n: 1) do |ports|
+        node = Ruster::Node.new("127.0.0.1:#{ports.first}")
+
+        node.load!
+
+        assert       node.id
+        assert_equal [], node.friends
+      end
+    end
+
+    test "meet and forget node, a tragic love story" do
+      with_nodes(n: 2) do |ports|
+        port_a, port_b = ports.to_a
+
+        # This is the story of two nodes
+        joel = Ruster::Node.new("127.0.0.1:#{port_a}")
+        clem = Ruster::Node.new("127.0.0.1:#{port_b}")
+
+        # One day they met for the first time and fell for each other
+        joel.meet("127.0.0.1", port_b)
+
+        # Give the nodes some time to get to know each other
+        sleep 0.5
+
+        joel.load!
+        clem.load!
+
+        assert_equal 1, joel.friends.size
+        assert_equal 1, clem.friends.size
+
+        assert_equal clem.id, joel.friends.first.id
+        assert_equal joel.id, clem.friends.first.id
+
+        # But one tragic afternoon, clem took a terrible decision
+        clem.forget(joel)
+
+        # Give the nodes some time to process their breakup
+        sleep 0.5
+
+        joel.load!
+        clem.load!
+
+        # joel still remembers clem...
+        assert_equal 1, joel.friends.size
+
+        # ...but clem has already moved on
+        assert_equal 0, clem.friends.size
+
+        # joel now decides to use the machine from Eternal sunshine of the spotless mind...
+        joel.forget(clem)
+
+        # ...and after a while, this story ends
+        sleep 0.5
+
+        joel.load!
+
+        assert_equal 0, joel.friends.size
+      end
+    end
+
+    test "replicate/slaves" do
+      with_nodes(n: 2) do |ports|
+        port_a, port_b = ports.to_a
+
+        leo    = Ruster::Node.new("127.0.0.1:#{port_a}")
+        django = Ruster::Node.new("127.0.0.1:#{port_b}")
+
+        leo.meet("127.0.0.1", port_b)
+
+        # Give the nodes some time to get to know each other
+        sleep 0.5
+
+        leo.load!
+
+        django.replicate(leo)
+
+        # Wait for configuration to update
+        sleep 0.5
+
+        assert_equal 1, leo.slaves.size
+
+        django.load!
+
+        assert_equal django.id, leo.slaves.first.id
+      end
+    end
+
+    test "allocate, deallocate and flush slots" do
+      with_nodes(n: 1) do |ports|
+        node = Ruster::Node.new("127.0.0.1:#{ports.first}")
+
+        # Single slot
+        node.add_slots(1024)
+
+        # Multiple slots
+        node.add_slots(2048, 4096)
+
+        node.load!
+
+        assert_equal [1024..1024, 2048..2048, 4096..4096], node.slots
+
+        node.del_slots(1024)
+
+        node.load!
+
+        assert_equal [2048..2048, 4096..4096], node.slots
+
+        node.flush_slots!
+
+        node.load!
+
+        assert_equal [], node.slots
+      end
+    end
+  end
+end

data/test/util.rb

@@ -0,0 +1,30 @@
+require_relative "./helper"
+
+Protest.describe "Ruster::Util" do
+  U = Module.new { extend Ruster::Util }
+
+  test "parse INFO as hash"do
+    info = "cluster_state:fail\r\ncluster_slots_assigned:0\r\ncluster_slots_ok:0\r\ncluster_slots_pfail:0\r\ncluster_slots_fail:0\r\ncluster_known_nodes:1\r\ncluster_size:0\r\ncluster_current_epoch:0\r\ncluster_stats_messages_sent:0\r\ncluster_stats_messages_received:0\r\n"
+
+    data = U.parse_info(info)
+
+    assert data.is_a?(Hash)
+
+    assert_equal "fail", data[:cluster_state]
+    assert_equal "0",    data[:cluster_slots_assigned]
+    assert_equal "0",    data[:cluster_slots_ok]
+    assert_equal "0",    data[:cluster_slots_pfail]
+    assert_equal "0",    data[:cluster_slots_fail]
+    assert_equal "1",    data[:cluster_known_nodes]
+    assert_equal "0",    data[:cluster_size]
+    assert_equal "0",    data[:cluster_current_epoch]
+    assert_equal "0",    data[:cluster_stats_messages_sent]
+    assert_equal "0",    data[:cluster_stats_messages_received]
+  end
+
+  test "ignore comments in INFO parsing" do
+    data = U.parse_info("# Cluster\r\ncluster_enabled:1\r\n")
+
+    assert_equal 1, data.size
+  end
+end

metadata

@@ -1,41 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: ruster
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Leandro López
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-15 00:00:00.000000000 Z
+date: 2015-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redic
   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: clap
   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: protest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Control your Redis Cluster from the command line.
@@ -46,11 +60,19 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - LICENSE
 - README.md
 - bin/ruster
+- lib/ruster.rb
+- lib/ruster/cluster.rb
+- lib/ruster/node.rb
+- lib/ruster/util.rb
 - ruster.gemspec
+- test/cluster.rb
+- test/helper.rb
+- test/node.rb
+- test/util.rb
 homepage: http://inkel.github.com/ruster
 licenses:
 - MIT
@@ -61,17 +83,17 @@ 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.0.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A simple Redis Cluster Administration tool