roma 0.8.2 → 0.8.10

data/{test → ruby/server/test}/t_cpdata.rb

@@ -2,6 +2,7 @@
 # -*- coding: utf-8 -*-
 
 require 'roma/client/rclient'
+require 'roma/messaging/con_pool'
 
 $dat = {}
 
@@ -164,7 +165,7 @@ class CopyDataTest < Test::Unit::TestCase
     push_a_vnode_stream('roma', 0, nid[0], keys)
 
     keys.each{|k|
-      assert_equal( "#{k}-stream", @rc.get(k))
+      assert_equal( "#{k}-stream", @rc.get(k,true))
 #      puts "#{k} #{@rc.get(k)}"
     }
   end
@@ -242,8 +243,13 @@ class CopyDataTest < Test::Unit::TestCase
   def reqpushv(hname,vn,is_primary=false)
     $dat.delete(vn)
     con = Roma::Messaging::ConPool.instance.get_connection("localhost_11211")
-    con.write("reqpushv #{vn} localhost_11213 #{is_primary}\r\n")
-    res = con.gets
+    res = nil
+    10.times{
+      con.write("reqpushv #{vn} localhost_11213 #{is_primary}\r\n")
+      res = con.gets
+      break if res == "PUSHED\r\n"
+      sleep 0.5
+    }
     assert_equal( "PUSHED\r\n", res )
     con.close
 

data/{test → ruby/server/test}/t_listplugin.rb

@@ -1,9 +1,9 @@
 #!/usr/bin/env ruby
-# -*- coding: utf-8 -*-
-
 require 'roma/client/rclient'
 require 'roma/plugin/plugin_alist'
 require 'roma/storage/tc_storage'
+require 'roma/messaging/con_pool'
+require 'roma/client/plugin/alist'
 
 Roma::Client::RomaClient.class_eval{
   def init_sync_routing_proc
@@ -17,7 +17,7 @@ class ListPluginTest < Test::Unit::TestCase
     start_roma
     @rc=Roma::Client::RomaClient.new(
                                      ["localhost_11211","localhost_11212"],
-                                     [::Roma::ClientPlugin::PluginAshiatoList])
+                                     [Roma::Client::Plugin::Alist])
   end
 
   def teardown
@@ -174,6 +174,16 @@ class ListPluginTest < Test::Unit::TestCase
     assert_equal(["55","66","55","44","33"], @rc.alist_to_s("aa")[1])
     assert_equal('STORED', @rc.alist_sized_insert("aa",3,"22"))
     assert_equal(["22","55","66"], @rc.alist_to_s("aa")[1] )
+    assert_equal('STORED', @rc.alist_sized_insert("aa",6,"77"))
+    assert_equal(["77","22","55","66"], @rc.alist_to_s("aa")[1] )
+    assert_equal('STORED', @rc.alist_sized_insert("aa",6,"88"))
+    assert_equal(["88","77","22","55","66"], @rc.alist_to_s("aa")[1] )
+    assert_equal('STORED', @rc.alist_sized_insert("aa",6,"99"))
+    assert_equal(["99","88","77","22","55","66"], @rc.alist_to_s("aa")[1] )
+    assert_equal('STORED', @rc.alist_sized_insert("aa",6,"00"))
+    assert_equal(["00","99","88","77","22","55"], @rc.alist_to_s("aa")[1] )
+    assert_equal('STORED', @rc.alist_sized_insert("aa",6,"00"))
+    assert_equal(["00","00","99","88","77","22"], @rc.alist_to_s("aa")[1] )
   end
 
   def test_sized_insert2
@@ -278,7 +288,7 @@ class ListPluginTest < Test::Unit::TestCase
     t = Time.now.to_i
     assert( @rc.alist_push("aa","11")=='STORED' )
     assert( @rc.alist_join("aa","|")[1]=="11" )
-    # 挿入時間を取得、おそらく1秒以内
+    # get a time of insert, maybe in 1 sec
     assert_operator(1,:>,t - @rc.alist_join_with_time("aa","|")[2].to_i)
     assert_equal('STORED', @rc.alist_push("aa","22"))
     assert_equal("11|22", @rc.alist_join("aa","|")[1])
@@ -468,6 +478,34 @@ class ListPluginTest < Test::Unit::TestCase
     assert_equal(["44"], @rc.alist_to_s("aa")[1])
   end
 
+  def test_alist_update_at
+    @rc.delete("aa")
+
+    assert_equal('NOT_FOUND', @rc.alist_update_at("aa",0,"a0"))
+
+    assert_equal('STORED', @rc.alist_push("aa","00"))
+    assert_equal('STORED', @rc.alist_push("aa","11"))
+    assert_equal('STORED', @rc.alist_push("aa","22"))
+    assert_equal('STORED', @rc.alist_push("aa","33"))
+    assert_equal('STORED', @rc.alist_push("aa","44"))
+    
+    assert_equal(["00","11","22","33","44"], @rc.alist_to_s("aa")[1])
+
+    assert_equal('NOT_FOUND', @rc.alist_update_at("aa",-1,"a0"))
+    assert_equal('NOT_FOUND', @rc.alist_update_at("aa",5,"a0"))
+
+    assert_equal('STORED', @rc.alist_update_at("aa",2,"a2"))
+    assert_equal(["00","11","a2","33","44"], @rc.alist_to_s("aa")[1])
+    assert_equal('STORED', @rc.alist_update_at("aa",0,"a0"))
+    assert_equal(["a0","11","a2","33","44"], @rc.alist_to_s("aa")[1])
+    assert_equal('STORED', @rc.alist_update_at("aa",1,"a1"))
+    assert_equal(["a0","a1","a2","33","44"], @rc.alist_to_s("aa")[1])
+    assert_equal('STORED', @rc.alist_update_at("aa",3,"a3"))
+    assert_equal(["a0","a1","a2","a3","44"], @rc.alist_to_s("aa")[1])
+    assert_equal('STORED', @rc.alist_update_at("aa",4,"a4"))
+    assert_equal(["a0","a1","a2","a3","a4"], @rc.alist_to_s("aa")[1])
+  end
+
   def test_shift
     @rc.delete("aa")
 
@@ -514,9 +552,7 @@ class ListPluginTest < Test::Unit::TestCase
 
     st, nid, vn = create_storage_and_calc_vn('aa')
 
-    # 過去のデータを作成
-    # 時刻は適当で OK 
-    # リストの結合ロジックは delete and push
+    # create a data ,it's a past time
     pt =Time.now.to_i
     st.set(vn,'aa',0,0xffffffff,Marshal.dump([['11','22','33','44','55'],[pt,pt,pt,pt,pt]]))
 
@@ -529,19 +565,19 @@ class ListPluginTest < Test::Unit::TestCase
     
     assert_equal(["55", "33", "11", "22", "44"], @rc.alist_to_s("aa")[1])
     
-    # list 以外のデータを作成
+    # create a data out of list
     st.set(vn,'aa',0,0xffffffff,'val-aa')
     push_a_vnode_stream(st, vn, nid)
-    # 論クロックが小さいので上書きされない
+    # do not write a value
     assert_equal(["55", "33", "11", "22", "44"], @rc.alist_to_s("aa")[1])
 
-    # 論理クロックを進める
+    # increases to logical clock
     10.times{
       st.set(vn,'aa',0,0xffffffff,'val-aa')
     }
     push_a_vnode_stream(st, vn, nid)
-    # 論クロックが大きいので上書きされる
-    assert_equal('val-aa', @rc.get("aa"))
+    # write over a value, cause increased a logical clock
+    assert_equal('val-aa', @rc.get("aa",true))
   end
 
   def create_storage_and_calc_vn(k)

data/ruby/server/test/t_mapcountplugin.rb

@@ -0,0 +1,231 @@
+#!/usr/bin/env ruby
+require 'roma/client'
+require 'roma/client/plugin/mapcount'
+
+Roma::Client::RomaClient.class_eval{
+  def init_sync_routing_proc
+  end
+}
+
+class MapCountPluginTest < Test::Unit::TestCase
+  include RomaTestUtils
+
+  DATE_FORMAT = "%Y-%m-%dT%H:%M:%S +00"
+
+  def setup
+    start_roma
+    @rc=Roma::Client::RomaClient.new(["localhost_11211","localhost_11212"], [Roma::Client::Plugin::MapCount])
+  end
+
+  def teardown
+    stop_roma
+  end
+
+  def test_mapcount_get(n = 5)
+    n.times do |i|
+      k = "subkey#{i}"
+      expt = i
+      lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
+
+      retc = {"last_updated_date"=>lt}
+      (i+1).times do |j|
+        retc["subkey#{j}"] = 1
+      end
+      assert_equal retc, @rc.mapcount_countup('key1', k, 0)
+
+      retg = {"last_updated_date"=>lt}
+      retg["subkey#{i}"] = 1
+      assert_equal retg, @rc.mapcount_get('key1', k)
+      assert_equal retc, @rc.mapcount_get('key1')
+    end    
+
+    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
+    ret = {"last_updated_date"=>lt, "subkey0"=>1, "subkey1"=>1}
+    assert_equal ret, @rc.mapcount_get('key1', 'subkey0,subkey1')
+  end
+
+  def test_mapcount_countup_expt
+    k = "subkey1"
+    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
+    ret = {"last_updated_date"=>lt, k=>1}
+
+    assert_nil @rc.mapcount_get('key1', k)
+    assert_equal ret, @rc.mapcount_countup('key1', k, 1)
+    assert_equal ret, @rc.mapcount_get('key1', k)
+    sleep 2
+    assert_nil @rc.mapcount_get('key1', k)
+  end
+
+  def test_mapcount_update
+    k = "subkey1"
+    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
+    ret_time = {"last_updated_date"=>lt}
+    ret_all = {"last_updated_date"=>lt, k=>1}
+
+    assert_nil @rc.mapcount_update('key1')
+    assert_equal ret_all, @rc.mapcount_countup('key1', k, 0)
+    assert_equal ret_all, @rc.mapcount_update('key1')
+    assert_equal ret_time, @rc.mapcount_update('key1', 'subkey2')
+
+    assert_equal ret_all, @rc.mapcount_update('key1', nil, 1)
+    sleep 2
+    assert_nil @rc.mapcount_get('key1')
+
+    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
+    ret_all = {"last_updated_date"=>lt, k=>1}
+    assert_equal ret_all, @rc.mapcount_countup('key1', k, 0)
+    assert_equal ret_all, @rc.mapcount_update('key1', k, 1)
+    sleep 2
+    assert_nil @rc.mapcount_get('key1')
+
+    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
+    ret_all = {"last_updated_date"=>lt, k=>1}
+    assert_equal ret_all, @rc.mapcount_countup('key1', k, 0)
+    sleep 2
+    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
+    ret_all = {"last_updated_date"=>lt, k=>1}
+    assert_equal ret_all, @rc.mapcount_update('key1')
+  end
+
+  def test_counts
+    conn = Roma::Messaging::ConPool.instance.get_connection("localhost_11211")
+    if conn
+      conn.write "stat read_count\n"
+      r = conn.gets.split(" ")
+      assert_equal 0, r[1].to_i
+      conn.gets
+
+      @rc.mapcount_get('key')
+      sleep 10
+      conn.write "stat read_count\n"
+      r = conn.gets.split(" ")
+      assert_equal 1, r[1].to_i
+      conn.gets
+
+      conn.write "stat write_count\n"
+      r = conn.gets.split(" ")
+      assert_equal 0, r[1].to_i
+      conn.gets
+
+      @rc.mapcount_countup('key', 'subkey', 0)
+      sleep 10
+      conn.write "stat write_count\n"
+      r = conn.gets.split(" ")
+      assert_equal 1, r[1].to_i
+      conn.gets
+
+      @rc.mapcount_update('key')
+      sleep 10
+      conn.write "stat write_count\n"
+      r = conn.gets.split(" ")
+      assert_equal 2, r[1].to_i
+      conn.gets
+
+      conn.close
+    end
+  end
+
+  def test_mapcount_get_ms(n = 5)
+    n.times do |i|
+      k = "subkey#{i}"
+      expt = i
+      lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
+
+      retc = {"last_updated_date"=>lt}
+      (i+1).times do |j|
+        retc["subkey#{j}"] = 1
+      end
+      assert_equal retc, @rc.mapcount_countup_ms('key1', k, 0)
+
+      retg = {"last_updated_date"=>lt}
+      retg["subkey#{i}"] = 1
+      assert_equal retg, @rc.mapcount_get_ms('key1', k)
+      assert_equal retc, @rc.mapcount_get_ms('key1')
+    end    
+
+    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
+    ret = {"last_updated_date"=>lt, "subkey0"=>1, "subkey1"=>1}
+    assert_equal ret, @rc.mapcount_get_ms('key1', 'subkey0,subkey1')
+  end
+
+  def test_mapcount_countup_ms_expt
+    k = "subkey1"
+    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
+    ret = {"last_updated_date"=>lt, k=>1}
+
+    assert_nil @rc.mapcount_get_ms('key1', k)
+    assert_equal ret, @rc.mapcount_countup_ms('key1', k, 1)
+    assert_equal ret, @rc.mapcount_get_ms('key1', k)
+    sleep 2
+    assert_nil @rc.mapcount_get_ms('key1', k)
+  end
+
+  def test_mapcount_update_ms
+    k = "subkey1"
+    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
+    ret_time = {"last_updated_date"=>lt}
+    ret_all = {"last_updated_date"=>lt, k=>1}
+
+    assert_nil @rc.mapcount_update_ms('key1')
+    assert_equal ret_all, @rc.mapcount_countup_ms('key1', k, 0)
+    assert_equal ret_all, @rc.mapcount_update_ms('key1')
+    assert_equal ret_time, @rc.mapcount_update_ms('key1', 'subkey2')
+
+    assert_equal ret_all, @rc.mapcount_update_ms('key1', nil, 1)
+    sleep 2
+    assert_nil @rc.mapcount_get_ms('key1')
+
+    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
+    ret_all = {"last_updated_date"=>lt, k=>1}
+    assert_equal ret_all, @rc.mapcount_countup_ms('key1', k, 0)
+    assert_equal ret_all, @rc.mapcount_update_ms('key1', k, 1)
+    sleep 2
+    assert_nil @rc.mapcount_get_ms('key1')
+
+    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
+    ret_all = {"last_updated_date"=>lt, k=>1}
+    assert_equal ret_all, @rc.mapcount_countup_ms('key1', k, 0)
+    sleep 2
+    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
+    ret_all = {"last_updated_date"=>lt, k=>1}
+    assert_equal ret_all, @rc.mapcount_update_ms('key1')
+  end
+
+  def test_counts_ms
+    conn = Roma::Messaging::ConPool.instance.get_connection("localhost_11211")
+    if conn
+      conn.write "stat read_count\n"
+      r = conn.gets.split(" ")
+      assert_equal 0, r[1].to_i
+      conn.gets
+
+      @rc.mapcount_get_ms('key')
+      sleep 10
+      conn.write "stat read_count\n"
+      r = conn.gets.split(" ")
+      assert_equal 1, r[1].to_i
+      conn.gets
+
+      conn.write "stat write_count\n"
+      r = conn.gets.split(" ")
+      assert_equal 0, r[1].to_i
+      conn.gets
+
+      @rc.mapcount_countup_ms('key', 'subkey', 0)
+      sleep 10
+      conn.write "stat write_count\n"
+      r = conn.gets.split(" ")
+      assert_equal 1, r[1].to_i
+      conn.gets
+
+      @rc.mapcount_update_ms('key')
+      sleep 10
+      conn.write "stat write_count\n"
+      r = conn.gets.split(" ")
+      assert_equal 2, r[1].to_i
+      conn.gets
+
+      conn.close
+    end
+  end
+end # MapCountPluginTest

data/ruby/server/test/t_mapplugin.rb

@@ -0,0 +1,131 @@
+#!/usr/bin/env ruby
+require 'roma/client/rclient'
+require 'roma/plugin/plugin_map'
+require 'roma/client/plugin/map'
+
+Roma::Client::RomaClient.class_eval{
+  def init_sync_routing_proc
+  end
+}
+
+class MapPluginTest < Test::Unit::TestCase
+  include RomaTestUtils
+
+  def setup
+    start_roma
+    @rc=Roma::Client::RomaClient.new(
+                                     ["localhost_11211","localhost_11212"],
+                                     [Roma::Client::Plugin::Map])
+  end
+
+  def teardown
+    stop_roma
+    Roma::Messaging::ConPool::instance.close_all
+  end
+
+  def mk_data(n = 10)
+    n.times do |i|
+      v = "value#{i}"
+      k = "mapkey#{i}"
+      assert_equal 'STORED', @rc.map_set('key1', k, v)
+      assert_equal v, @rc.map_get('key1', k)
+    end    
+  end
+
+  def test_map_set_expt
+    assert_equal 'STORED', @rc.map_set('key1','mapkey1','value1', 1)
+    assert_equal 'value1', @rc.map_get('key1','mapkey1')
+    sleep 2
+    assert_nil @rc.map_get('key1','mapkey1')
+  end
+
+  def test_map_set
+    assert_nil @rc.map_get('key1','mapkey1')
+    assert_equal 'STORED', @rc.map_set('key1','mapkey1','value1')
+    assert_equal 'value1', @rc.map_get('key1','mapkey1')
+
+    assert_equal 'STORED', @rc.map_set('key1','mapkey1','value2')
+    assert_equal 'value2', @rc.map_get('key1','mapkey1')
+  end
+
+  def test_map_delete
+    mk_data
+    assert_equal 'NOT_FOUND', @rc.map_delete('key2', 'key1')
+    assert_equal 'NOT_DELETED', @rc.map_delete('key1', 'key1')
+    assert_equal 'DELETED', @rc.map_delete('key1', 'mapkey1')
+    assert_nil @rc.map_get('key1', 'mapkey1')
+  end
+
+  def test_map_clear
+    assert_equal 'NOT_FOUND', @rc.map_empty?('key1')
+    assert_equal 'NOT_FOUND', @rc.map_size('key1')
+    assert_equal 'NOT_FOUND', @rc.map_clear('key1')
+    mk_data
+    assert !@rc.map_empty?('key1')
+    assert_equal 10, @rc.map_size('key1')
+    assert_equal 'CLEARED', @rc.map_clear('key1')
+    assert @rc.map_empty?('key1')
+    assert_equal 0, @rc.map_size('key1')
+  end
+
+  def test_map_key?
+    assert_equal 'NOT_FOUND', @rc.map_key?('key1', 'key1')
+    mk_data
+    assert !@rc.map_key?('key1', 'key1')
+    assert @rc.map_key?('key1', 'mapkey1')
+  end
+
+  def test_map_value?
+    assert_equal 'NOT_FOUND', @rc.map_value?('key1', 'value1')
+    mk_data
+    assert !@rc.map_value?('key1', 'key1')
+    assert @rc.map_value?('key1', 'value1')
+  end
+  
+  def test_map_keys
+    assert_nil @rc.map_keys('key1')
+    mk_data
+    v = [10]
+    10.times{|i| v << "mapkey#{i}" }
+    assert_equal v, @rc.map_keys('key1')
+  end
+
+  def test_map_values
+    assert_nil @rc.map_values('key1')
+    mk_data
+    v = [10]
+    10.times{|i| v << "value#{i}" }
+    assert_equal v, @rc.map_values('key1')
+  end
+
+  def test_map_to_s
+    assert !@rc.map_to_s('key1')
+    mk_data
+    h = {}
+    10.times do |i|
+      v = "value#{i}"
+      k = "mapkey#{i}"
+      h[k] = v
+    end    
+    assert_equal h, eval(@rc.map_to_s('key1'))
+  end
+
+end # MapPluginTest
+
+class MapPluginTestForceForward < MapPluginTest
+  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
+
+