roma 0.8.11 → 0.8.12

data/ruby/server/lib/roma/routing/random_partitioner.rb

@@ -0,0 +1,95 @@
+module Roma
+  module Routing
+    module RandomPartitioner
+
+      def exclude_nodes(ap_str, rep_host)
+        exclude_nodes = self.nodes
+        if rep_host
+          exclude_nodes = [ap_str]
+        else
+          myhost = ap_str.split(/[:_]/)[0]
+          exclude_nodes.delete_if{|nid| nid.split(/[:_]/)[0] != myhost }
+        end
+        exclude_nodes
+      end
+      
+      alias :exclude_nodes_for_join :exclude_nodes
+      alias :exclude_nodes_for_recover :exclude_nodes
+      alias :exclude_nodes_for_balance :exclude_nodes
+
+      # vnode sampling exclude +exclude_nodes+
+      def select_vn_for_join(exclude_nodes)
+        short_idx = {}
+        idx = {}
+        @rd.v_idx.each_pair do |vn, nids|
+          unless list_include?(nids, exclude_nodes)
+            idx[vn] = nids
+            short_idx[vn] = nids if nids.length < @rd.rn
+          end
+        end
+        idx = short_idx if short_idx.length > 0
+      
+        ks = idx.keys
+        return nil if ks.length == 0
+        vn = ks[rand(ks.length)]
+        nids = idx[vn]
+        [vn, nids, rand(@rd.rn) == 0]
+      end
+
+      # select a vnodes where short of redundancy.
+      def select_vn_for_recover(exclude_nodes)
+        ret = []
+        @rd.v_idx.each_pair do |vn, nids|
+          if nids.length < @rd.rn && list_include?(nids,exclude_nodes) == false
+            ret << [vn,nids]
+          end
+        end
+        if ret.length == 0
+          nil
+        else
+          n = rand(ret.length)
+          [ret[n][0], ret[n][1], (rand(@rd.rn) == 0)]
+        end
+      end
+
+      def select_node_for_release(ap_str, rep_host, nids)
+        buf = self.nodes
+
+        unless rep_host
+          deny_hosts = []
+          nids.each{ |nid|
+            host = nid.split(/[:_]/)[0]
+            deny_hosts << host if host != ap_str.split(/[:_]/)[0]
+          }
+          buf.delete_if{|nid| deny_hosts.include?(nid.split(/[:_]/)[0])}
+        else
+          nids.each{|nid| buf.delete(nid) }
+        end
+        
+        to_nid = buf[rand(buf.length)]
+        new_nids = nids.map{|n| n == ap_str ? to_nid : n }
+        [to_nid, new_nids]
+      end
+
+      # vnode sampling exclude +exclude_nodes+
+      def select_vn_for_balance(exclude_nodes)
+        short_idx = {}
+        idx = {}
+        @rd.v_idx.each_pair do |vn, nids|
+          unless list_include?(nids, exclude_nodes)
+            idx[vn] = nids
+            short_idx[vn] = nids if nids.length < @rd.rn
+          end
+        end
+        idx = short_idx if short_idx.length > 0
+      
+        ks = idx.keys
+        return nil if ks.length == 0
+        vn = ks[rand(ks.length)]
+        nids = idx[vn]
+        [vn, nids, rand(@rd.rn) == 0]
+      end
+
+    end
+  end
+end

data/ruby/server/lib/roma/routing/routing_data.rb

@@ -70,6 +70,7 @@ module Roma
           bin = bin[2..-1]
           nid, = bin.unpack("a#{len}")
           bin = bin[len..-1]
+          nid.encode!("utf-8") if RUBY_VERSION >= "1.9.3"
           rd.nodes << nid 
         }
         (2**div_bits).times{|i|

data/ruby/server/lib/roma/stats.rb

@@ -16,23 +16,29 @@ module Roma
     attr_accessor :name
     attr_accessor :verbose
     attr_accessor :enabled_repetition_host_in_routing
+    alias :rep_host :enabled_repetition_host_in_routing
     attr_accessor :disabled_cmd_protect
 
     # proc mode
     attr_accessor :enabled_vnodes_balance
 
     # proc status
-    attr_accessor :run_acquire_vnodes
     attr_accessor :run_recover
     attr_accessor :run_sync_routing
     attr_accessor :run_iterate_storage
     attr_accessor :run_storage_clean_up
     attr_accessor :run_receive_a_vnode
     attr_accessor :run_release
+    attr_accessor :run_join
+    attr_accessor :run_balance
+
+    attr_accessor :last_clean_up
+    attr_accessor :spushv_protection
 
     # proc param
     attr_accessor :stream_copy_wait_param
     attr_accessor :dcnice
+    attr_accessor :clean_up_interval
 
     # compressed redundant param
     attr_accessor :size_of_zredundant
@@ -52,15 +58,19 @@ module Roma
 
     def initialize
       @config_path = nil
-      @run_acquire_vnodes = false
       @run_recover = false
       @run_sync_routing = false
       @run_iterate_storage = false
       @run_storage_clean_up = false
-      @run_receive_a_vnode = false
+      @run_receive_a_vnode = {}
       @run_release = false
+      @run_join = false
+      @run_balance = false
+      @last_clean_up = Time.now
+      @spushv_protection = false
       @stream_copy_wait_param = 0.0001
       @dcnice = 3
+      @clean_up_interval = 300
       @enabled_vnodes_balance = nil
       @write_count = 0
       @read_count = 0
@@ -85,15 +95,20 @@ module Roma
       ret['stats.daemon'] = @daemon
       ret['stats.name'] = @name
       ret['stats.verbose'] = @verbose
-      ret['stats.enabled_repetition_host_in_routing'] = @enabled_repetition_host_in_routing
-      ret['stats.run_acquire_vnodes'] = @run_acquire_vnodes
+      ret['stats.enabled_repetition_host_in_routing'] = rep_host
       ret['stats.run_recover'] = @run_recover
       ret['stats.run_sync_routing'] = @run_sync_routing
       ret['stats.run_iterate_storage'] = @run_iterate_storage
       ret['stats.run_storage_clean_up'] = @run_storage_clean_up
+      ret['stats.run_receive_a_vnode'] = @run_receive_a_vnode.inspect
       ret['stats.run_release'] = @run_release
+      ret['stats.run_join'] = @run_join
+      ret['stats.run_balance'] = @run_balance
+      ret['stats.last_clean_up'] = @last_clean_up
+      ret['stats.spushv_protection'] = @spushv_protection
       ret['stats.stream_copy_wait_param'] = @stream_copy_wait_param
       ret['stats.dcnice'] = @dcnice
+      ret['stats.clean_up_interval'] = @clean_up_interval
       ret['stats.size_of_zredundant'] = @size_of_zredundant
       ret['stats.write_count'] = @write_count
       ret['stats.read_count'] = @read_count
@@ -115,6 +130,10 @@ module Roma
       clear_count(:@redundant_count)
     end
 
+    def do_clean_up?
+      @last_clean_up.to_i + @clean_up_interval < Time.now.to_i
+    end
+
     private
 
     def clear_count(var)

data/ruby/server/lib/roma/storage/basic_storage.rb

@@ -366,16 +366,19 @@ module Roma
         nt = Time.now.to_i
         @hdb.each{ |hdb|
           hdb.each{ |k, v|
-            return unless @do_clean_up
+            return unless @do_clean_up # 1st check
             vn, last, clk, expt = unpack_header(v)
             vn_stat = vnhash[vn]
             if vn_stat == :primary && ( (expt != 0 && nt > expt) || (expt == 0 && t > last) )
-              yield k, vn
-              hdb.out(k) if hdb.get(k) == v
+              if yield k, vn
+                hdb.out(k) if hdb.get(k) == v
+              end
             elsif vn_stat == nil && t > last
-              yield k, vn
-              hdb.out(k) if hdb.get(k) == v
+              if yield k, vn
+                hdb.out(k) if hdb.get(k) == v
+              end
             end
+            return unless @do_clean_up # 2nd ckeck 
             sleep @each_clean_up_sleep
           }
         }
@@ -457,21 +460,19 @@ module Roma
 
       def each_vn_dump(target_vn)
         count = 0
-        @divnum.times{|i|
-          tn =  Time.now.to_i
-          @hdb[i].each{|k,v|
-            vn, last, clk, expt, val = unpack_data(v)
-            if vn != target_vn || (expt != 0 && tn > expt)
-              count += 1              
-              sleep @each_vn_dump_sleep if count % @each_vn_dump_sleep_count == 0
-              next
-            end
-            if val
-              yield [vn, last, clk, expt, k.length, k, val.length, val].pack("NNNNNa#{k.length}Na#{val.length}")
-            else
-              yield [vn, last, clk, expt, k.length, k, 0].pack("NNNNNa#{k.length}N")
-            end
-          }
+        tn =  Time.now.to_i
+        @hdb[@hdiv[target_vn]].each{|k,v|
+          vn, last, clk, expt, val = unpack_data(v)
+          if vn != target_vn || (expt != 0 && tn > expt)
+            count += 1
+            sleep @each_vn_dump_sleep if count % @each_vn_dump_sleep_count == 0
+            next
+          end
+          if val
+            yield [vn, last, clk, expt, k.length, k, val.length, val].pack("NNNNNa#{k.length}Na#{val.length}")
+          else
+            yield [vn, last, clk, expt, k.length, k, 0].pack("NNNNNa#{k.length}N")
+          end
         }
       end
 

data/ruby/server/lib/roma/storage/rh_storage.rb

@@ -44,23 +44,21 @@ module Roma
 
         def each_vn_dump(target_vn)
           count = 0
-          @divnum.times{|i|
-            tn =  Time.now.to_i
-            keys = @hdb[i].keys
-            keys.each{|k|
-              v = @hdb[i][k]
-              vn, last, clk, expt, val = unpack_data(v)
-              if vn != target_vn || (expt != 0 && tn > expt)
-                count += 1              
-                sleep @each_vn_dump_sleep if count % @each_vn_dump_sleep_count == 0
-                next
-              end
-              if val
-                yield [vn, last, clk, expt, k.length, k, val.length, val].pack("NNNNNa#{k.length}Na#{val.length}")
-              else
-                yield [vn, last, clk, expt, k.length, k, 0].pack("NNNNNa#{k.length}N")
-              end
-            }
+          tn =  Time.now.to_i
+          keys = @hdb[@hdiv[target_vn]].keys
+          keys.each{|k|
+            v = @hdb[@hdiv[target_vn]][k]
+            vn, last, clk, expt, val = unpack_data(v)
+            if vn != target_vn || (expt != 0 && tn > expt)
+              count += 1
+              sleep @each_vn_dump_sleep if count % @each_vn_dump_sleep_count == 0
+              next
+            end
+            if val
+              yield [vn, last, clk, expt, k.length, k, val.length, val].pack("NNNNNa#{k.length}Na#{val.length}")
+            else
+              yield [vn, last, clk, expt, k.length, k, 0].pack("NNNNNa#{k.length}N")
+            end
           }
         end
 

data/ruby/server/lib/roma/storage/sqlite3_storage.rb

@@ -6,6 +6,7 @@ module Roma
 
     module SQLite3_Ext
       def put(k,v)
+        k = k.encode("ascii-8bit") if RUBY_VERSION >= "1.9.3"
         if self.execute("select count(*) from t_roma where key=?",k)[0][0].to_i==0
           self.execute("insert into t_roma values (?,?)",k,SQLite3::Blob.new(v))
         else
@@ -14,12 +15,14 @@ module Roma
       end
 
       def get(k)
+        k = k.encode("ascii-8bit") if RUBY_VERSION >= "1.9.3"
         r = self.execute("select * from t_roma where key=?",k)
         return nil if r.length==0
         r[0][1]
       end
 
       def out(k)
+        k = k.encode("ascii-8bit") if RUBY_VERSION >= "1.9.3"
         return nil if get(k) == nil
         self.execute("delete from t_roma where key=?",k)
       end

data/ruby/server/lib/roma/tools/simple_bench.rb

@@ -1,12 +1,13 @@
 #!/usr/bin/env ruby
+require 'optparse'
 require 'date'
 require 'roma/client/rclient'
 
-@@cnt=0
-@@tmax=0
-@@tmin=100
+@@cnt = 0
+@@tmax = 0
+@@tmin = 100
 
-Thread.new {
+Thread.new do
   sleep_time=10
   while(true)
     sleep sleep_time
@@ -15,13 +16,13 @@ Thread.new {
     @@tmax=0
     @@tmin=100
   end
-}
+end
 
-def random_rquest_sender(ini_nodes)
+def random_rquest_sender(ini_nodes, n)
+  puts __method__
   rc=Roma::Client::RomaClient.new(ini_nodes)
 
-  n=10000
-  loop{
+  loop do
     i=rand(n)
     ts = DateTime.now
     case rand(3)
@@ -39,21 +40,69 @@ def random_rquest_sender(ini_nodes)
     @@tmax=t if t > @@tmax
     @@tmin=t if t < @@tmin
     @@cnt+=1
-  }
+  end
 end
  
+def set_sequence(ini_nodes, n)
+  puts __method__
+  rc=Roma::Client::RomaClient.new(ini_nodes)
+
+  n.times do |i|
+    ts = DateTime.now
+    res=rc.set("key_#{i}","value_#{i}")
+    puts "set k=#{i} #{res}" if res==nil || res.chomp != 'STORED'
+    t=(DateTime.now - ts).to_f * 86400.0
+    @@tmax=t if t > @@tmax
+    @@tmin=t if t < @@tmin
+    @@cnt+=1
+  end
+end
+
+def get_sequence(ini_nodes, n)
+  puts __method__
+  rc=Roma::Client::RomaClient.new(ini_nodes)
+
+  n.times do |i|
+    ts = DateTime.now
+    res=rc.get("key_#{i}")
+    puts "get #{i} #{res}" if res != "value_#{i}"
+    t=(DateTime.now - ts).to_f * 86400.0
+    @@tmax=t if t > @@tmax
+    @@tmin=t if t < @@tmin
+    @@cnt+=1
+  end
+end
+
+param = { :num=>10000, :th=>1 }
+
+opts = OptionParser.new
+opts.banner = "usage:#{File.basename($0)} [options] addr:port"
+opts.on("-s", "--set", "set request"){|v| param[:set] = v }
+opts.on("-g", "--get", "get request"){|v| param[:get] = v }
+opts.on("-r", "--rand", "random request"){|v| param[:rand] = v }
+opts.on("-n", "--num [num]", "number of kyes"){|v| param[:num] = v.to_i }
+opts.on("-t", "--threads [num]", "number of threads"){|v| param[:th] = v.to_i }
+opts.parse!(ARGV)
+
 if ARGV.length == 0
-  STDERR.puts "usage:simple_bench addr:port"
+  STDERR.puts opts.help
   exit
 end
 
-tn=10
-t=[]
-tn.times{
-  t << Thread.new{
-    random_rquest_sender(ARGV)
-  }
-}
+if param.key?(:get) == false && param.key?(:set) == false
+  param[:rand] = true
+end
+
+t = []
+param[:th].times do |i|
+  puts "Start thread #{i}"
+  t << Thread.new do
+    get_sequence(ARGV, param[:num]) if param.key?(:get)
+    set_sequence(ARGV, param[:num]) if param.key?(:set)
+    random_rquest_sender(ARGV, param[:num]) if param.key?(:rand)
+  end
+end
 
-t[0].join
+t.each{|th| th.join }
 
+puts "#{File.basename($0)} has done."

data/ruby/server/lib/roma/version.rb

@@ -1,4 +1,4 @@
 
 module Roma
-  VERSION = "0.8.11"
+  VERSION = "0.8.12"
 end

data/ruby/server/test/t_cpdata.rb

@@ -98,56 +98,7 @@ class CopyDataTest < Test::Unit::TestCase
     @th.kill
     $gs.close
     Roma::Messaging::ConPool::instance.close_all
-  end
-
-  def test_pushv
-    make_dummy(1000)
-    dat = reqpushv('roma',0)
-    assert_not_nil( dat )
-    # 正常ケース
-    con = Roma::Messaging::ConPool.instance.get_connection("localhost_11211")
-    assert_equal("STORED", push_a_vnode('roma',0,con,Marshal.dump(dat)))
-
-    # 存在しない仮想ストレージ
-    con = Roma::Messaging::ConPool.instance.get_connection("localhost_11211")
-    assert_equal("SERVER_ERROR @storages[roma1] dose not found.",
-                 push_a_vnode('roma1',0,con,Marshal.dump(dat)))
-
-    # END を送らない
-    con = Roma::Messaging::ConPool.instance.get_connection("localhost_11211")
-    assert_equal("SERVER_ERROR END was not able to be received.",
-                 push_a_vnode('roma',0,con,Marshal.dump(dat),true))
-    
-    # 壊れたデータを送る
-    dat['abc']="ajjkdlfsoifulwkejrweorlkjflksjflskaf"
-    con = Roma::Messaging::ConPool.instance.get_connection("localhost_11211")
-    assert_equal(
-      "SERVER_ERROR An invalid vnode number is include.key=abc vn=1634364011",
-       push_a_vnode('roma',2,con,Marshal.dump(dat)))
-  end
-
-  def push_a_vnode(hname ,vn, con, dmp, nonend=false)
-    con.write("pushv #{hname} #{vn}\r\n")
-    res = con.gets # READY\r\n or error string
-    if res != "READY\r\n"
-      con.close
-      return res.chomp
-    end
-    if nonend
-      con.write("#{dmp.length}\r\n#{dmp}\r\n\r\n")
-    else
-      con.write("#{dmp.length}\r\n#{dmp}\r\nEND\r\n")
-    end
-    res = con.gets # STORED\r\n or error string
-    con.close
-    res.chomp! if res
-    res
-  rescue =>e
-    con.close if con
-    "#{e}"
-  end
-  private :push_a_vnode
-  
+  end  
 
   def test_spushv
     # vn = 0 のキー

data/ruby/server/test/t_eventmachine.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require 'eventmachine'
+
+class EventMachineTest < Test::Unit::TestCase
+  LOOP_NUM = 5
+
+  def test_context_switch
+    EM.epoll
+    t = Thread.new do
+      LOOP_NUM.times do |i|
+        100.times{ Thread.pass }
+        sleep 1
+        #puts i
+      end
+      EM.stop_event_loop
+    end
+    s = Time.now
+    EventMachine::run
+    e = Time.now
+    assert((e - s) < (LOOP_NUM + 1))
+  end
+end

data/ruby/server/test/t_mhash.rb

@@ -203,20 +203,3 @@ class MHashTest < Test::Unit::TestCase
     assert_equal("STORED", @rc.set("key", "value"))
   end
 end
-
-class MHashTestForward < RClientTest
-  def setup
-    super
-    @rc.rttable.instance_eval{
-      undef search_node
-
-      def search_node(key); search_node2(key); end
-
-      def search_node2(key)
-        d = Digest::SHA1.hexdigest(key).hex % @hbits
-        @rd.v_idx[d & @search_mask][1]
-      end
-    }
-  end  
-
-end

data/ruby/server/test/t_protocol.rb

@@ -0,0 +1,131 @@
+#!/usr/bin/env ruby
+
+require 'socket'
+
+class ProtocolTest < Test::Unit::TestCase
+  include RomaTestUtils
+
+  def setup
+    start_roma
+    @sock = TCPSocket.new("localhost", 11211)
+  end
+
+  def teardown
+    @sock.close
+    stop_roma
+  rescue => e
+    puts "#{e} #{$@}"
+  end
+
+  def test_set_get_delete
+    # Set data
+    @sock.write("set key 0 0 5\r\nvalue\r\n")
+    assert_equal("STORED", @sock.gets.chomp)
+
+    # Get data
+    @sock.write("get key\r\n")
+    assert_equal("VALUE key 0 5", @sock.gets.chomp)
+    assert_equal("value", @sock.gets.chomp)
+    assert_equal("END", @sock.gets.chomp)
+
+    # Update data
+    @sock.write("set key 0 0 9\r\nnew_value\r\n")
+    assert_equal("STORED", @sock.gets.chomp)
+
+    # Confirm updated data
+    @sock.write("get key\r\n")
+    assert_equal("VALUE key 0 9", @sock.gets.chomp)
+    assert_equal("new_value", @sock.gets.chomp)
+    assert_equal("END", @sock.gets.chomp)
+
+    # Delete data
+    @sock.write("delete key\r\n")
+    assert_equal("DELETED", @sock.gets.chomp)
+
+    # Confirm deleted data
+    @sock.write("get key\r\n")
+    assert_equal("END", @sock.gets.chomp)
+  end
+
+  def test_gets
+    # Set first data
+    @sock.write("set key-1 0 0 7\r\nvalue-1\r\n")
+    assert_equal("STORED", @sock.gets.chomp)
+
+    # Gets data
+    @sock.write("gets key-1 key-2\r\n")
+    assert_equal("VALUE key-1 0 7 0", @sock.gets.chomp)
+    assert_equal("value-1", @sock.gets.chomp)
+    assert_equal("END", @sock.gets.chomp)
+
+    # Set second data
+    @sock.write("set key-2 0 0 7\r\nvalue-2\r\n")
+    assert_equal("STORED", @sock.gets.chomp)
+
+    # Gets data (order is not sorted)
+    @sock.write("gets key-1 key-2\r\n")
+    if(@sock.gets.include?("key-1"))
+      assert_equal("value-1", @sock.gets.chomp)
+      assert_equal("VALUE key-2 0 7 0", @sock.gets.chomp)
+      assert_equal("value-2", @sock.gets.chomp)
+    else
+      assert_equal("value-2", @sock.gets.chomp)
+      assert_equal("VALUE key-1 0 7 0", @sock.gets.chomp)
+      assert_equal("value-1", @sock.gets.chomp)
+    end
+    assert_equal("END", @sock.gets.chomp)
+  end
+
+  def test_get_non_exisitent_key
+    @sock.write("get key\r\n")
+    assert_equal("END", @sock.gets.chomp)
+  end
+
+  def test_delete_non_exisitent_key
+    @sock.write("delete key\r\n")
+    assert_equal("NOT_FOUND", @sock.gets.chomp)
+  end
+
+  def test_gets_non_exisitent_key
+    @sock.write("gets key\r\n")
+    assert_equal("END", @sock.gets.chomp)
+  end
+
+  def test_set_zero_arguments
+    @sock.write("get\r\n")
+    assert(@sock.gets.chomp.start_with?("CLIENT_ERROR"))
+  end
+
+  def test_get_zero_arguments
+    @sock.write("get\r\n")
+    assert(@sock.gets.chomp.start_with?("CLIENT_ERROR"))
+  end
+
+  def test_delete_zero_arguments
+    @sock.write("delete\r\n")
+    assert(@sock.gets.chomp.start_with?("CLIENT_ERROR"))
+  end
+
+  def test_gets_zero_arguments
+    @sock.write("gets\r\n")
+    assert_equal("END", @sock.gets.chomp)
+  end
+
+  def test_set_too_much_arguments
+    @sock.write("set key 0 0 5 0\r\nvalue\r\n")
+    assert(@sock.gets.chomp.start_with?("CLIENT_ERROR"))
+  end
+
+  def test_set_wrong_key_size
+    @sock.write("set key 0 0 -1\r\nvalue\r\n")
+    assert(@sock.gets.start_with?("CLIENT_ERROR"))
+  end
+
+  def test_set_zero_byte_value
+    @sock.write("set key 0 0 0\r\n\r\n")
+    assert_equal("STORED", @sock.gets.chomp)
+    @sock.write("get key\r\n")
+    assert_equal("VALUE key 0 0", @sock.gets.chomp)
+    assert_equal("", @sock.gets.chomp)
+  end
+end

data/ruby/server/test/t_routing_data.rb

@@ -47,6 +47,15 @@ class RoutingDataTest < Test::Unit::TestCase
     assert( 0x56000000 == rd.next_vnode(0x55000000) )
   end
 
+  def test_saved_format
+    rd=Roma::Routing::RoutingData.create(32,8,1,['roma0_3300'])
+    decoded_rd=Roma::Routing::RoutingData.decode_binary(rd.dump_binary)
+    decoded_rd.save("routing_data.test.route")
+    rd_text=File.open("routing_data.test.route"){|f| f.read }
+    assert( /\!binary \|\-/ !~ rd_text )
+    File::unlink("routing_data.test.route")
+  end
+
   def test_create_nodes_from_v_idx
     rd=Roma::Routing::RoutingData.create(32,8,1,['roma0','roma1','roma2'])
     rd.nodes.clear