roma 0.8.13 → 0.8.14

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

@@ -21,8 +21,6 @@ module Roma
       def incr(vn, k, d, v); end
       def decr(vn, k, d, v); end
       def true_length; 100; end
-      def add_vnode(vn); end
-      def del_vnode(vn); end
       def clean_up(t); end
 
       def load(dmp); 10 end

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

@@ -8,15 +8,18 @@ module Roma
       def get(k); self[k]; end
       def out(k); delete(k); end
       def rnum; length; end
+      def sync; true; end
     end
 
     class RubyHashStorage < BasicStorage
 
       def opendb
         create_div_hash
-        @divnum.times{ |i|
+        @divnum.times do |i|
           @hdb[i] = open_db(nil)
-        }
+          @hdbc[i] = nil
+          @dbs[i] = :normal
+        end
       end
 
       if RUBY_VERSION >= '1.9.2'
@@ -42,25 +45,23 @@ module Roma
           }
         end
 
-        def each_vn_dump(target_vn)
+        def each_unpacked_db(target_vn, db)
           count = 0
           tn =  Time.now.to_i
-          keys = @hdb[@hdiv[target_vn]].keys
-          keys.each{|k|
-            v = @hdb[@hdiv[target_vn]][k]
+          keys = db[@hdiv[target_vn]].keys
+          keys.each do |k|
+            v = db[@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
-          }
+            yield vn, last, clk, expt, k, val
+          end
         end
+        private :each_unpacked_db
+
 
         def each_hdb_dump(i,except_vnh = nil)
           count = 0

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

@@ -56,6 +56,10 @@ module Roma
           "WHERE type='table' ORDER BY name;"
         self.execute( sql ).flatten
       end
+
+      def sync
+        true
+      end
     end
 
     class SQLite3Storage < BasicStorage

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

@@ -32,7 +32,7 @@ module Roma
           end
           ret
         end
-      end
+      end # class TokyoCabinet::HDB
 
       def initialize
         super
@@ -51,33 +51,18 @@ module Roma
       end
 
       def opendb
-        create_div_hash
-        path = ''
-        @storage_path.split('/').each{|p|
-          if p.length==0
-            path = '/'
-            next
-          end
-          path << p
-          Dir::mkdir(path) unless File.exist?(path)
-          path << '/'
-        }
-
         @fname_lock = "#{@storage_path}/lock"
         if File.exist?(@fname_lock)
           raise RuntimeError.new("Lock file already exists.")
         end
-        open(@fname_lock,"w"){}
 
-        @divnum.times{ |i|
-          @hdb[i] = open_db("#{@storage_path}/#{i}.#{@ext_name}")
-        }
+        super
+
+        open(@fname_lock,"w"){}
       end
 
       def closedb
-        stop_clean_up
-        buf = @hdb; @hdb = []
-        buf.each{ |hdb| close_db(hdb) }
+        super
 
         File.unlink(@fname_lock) if @fname_lock
         @fname_lock = nil
@@ -202,6 +187,7 @@ module Roma
         opts += "#bnum=#{prop['bnum']}" if prop.key?('bnum')
         opts += "#capnum=#{prop['capnum']}" if prop.key?('capnum')
         opts += "#capsiz=#{prop['capsiz']}" if prop.key?('capsiz')
+
         opts = nil unless opts.length > 0
         opts
       end

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

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+
+require 'socket'
+
+module Roma
+  class SafeCopy
+
+    attr_reader :storages
+
+    def initialize(addr, port)
+      @con = TCPSocket.open(addr, port)
+      get_storage_info
+    end
+
+    def backup_all
+      @storages.keys.each do |k|
+        backup(k)
+      end
+    end
+
+    def backup(hname)
+      stat = get_safecopy_stats(hname)
+      if stat.uniq != [:normal]
+        puts "storages[#{hname}].storage.safecopy_stats #{stat.to_s}"
+        puts "ERROR: Status except the :normal exists."
+        return
+      end
+      @storages[hname].each_with_index do |fname, num|
+        ret = set_storage_status(hname, num, "safecopy")
+        if ret != "PUSHED\r\n"
+          puts ret
+          puts "ERROR: Can't change storage status to safecopy."
+          return
+        end
+        wait(hname, num, :safecopy_flushed)
+        puts "copy file : #{fname}"
+        # file copy
+        `cp #{fname} #{fname}.#{Time.now.strftime("%Y%m%d%H%M%S")}`
+        ret = set_storage_status(hname, num, "normal") 
+        if ret != "PUSHED\r\n"
+          puts ret
+          puts "ERROR: Can't change storage status to normal."
+          return
+        end
+        wait(hname, num, :normal)
+      end
+    end
+
+    def wait(hname, num, stat)
+      print "waiting for storages[#{hname}][#{num}] == #{stat} "
+      while get_safecopy_stats(hname)[num] != stat
+        print "."
+        sleep 5
+      end
+      puts
+    end
+
+    def get_storage_info
+      @storages = {}
+      stats do |line|
+        if /^storages\[(.+)\]\.storage\[(\d+)\]\.path\s(.+)/ =~ line
+          @storages[$1] = [] unless @storages.key? $1
+          @storages[$1][$2.to_i] = $3.chomp
+#          puts "#{$1} #{$2} #{$3}"
+        end
+      end
+    end
+
+    def get_safecopy_stats(hname)
+      ret = nil
+      stats do |line|
+        if /^storages\[#{hname}\]\.storage\.safecopy_stats\s(.+)/ =~ line
+          ret = $1.chomp
+        end
+      end
+      eval ret
+    end
+
+    def set_storage_status(hname, num, stat)
+      @con.puts "set_storage_status #{num} #{stat} #{hname}\r\n"
+      @con.gets
+    end
+
+    def stats
+      @con.puts "stat storage\r\n"
+      yield $_ while @con.gets != "END\r\n"
+    end
+
+    def close
+      @con.close if @con
+    end
+
+  end # SafeCopy
+end # Roma
+
+if ARGV.length < 1
+  puts File.basename(__FILE__) + " [port]"
+  exit
+end
+
+sc = Roma::SafeCopy.new("localhost", ARGV[0].to_i)
+sc.backup_all
+sc.close

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

@@ -0,0 +1,247 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'date'
+require 'roma/client/rclient'
+
+@cnt = 0
+@tmax = 0
+@tmin = 100
+
+@m = Mutex.new
+
+Thread.new do
+  sleep_time=10
+  while(true)
+    sleep sleep_time
+    printf("\s\sqps=%d max=%f min=%f ave=%f\n",@cnt/sleep_time,@tmax,@tmin,sleep_time/@cnt.to_f)
+    @cnt=0
+    @tmax=0
+    @tmin=100
+  end
+end
+
+def random_rquest_sender(ini_nodes, n)
+  puts __method__
+  rc=Roma::Client::RomaClient.new(ini_nodes)
+
+  loop do
+    i=rand(n)
+    ts = DateTime.now
+    case rand(3)
+    when 0
+      res=rc.set(i.to_s,'hoge'+i.to_s)
+      puts "set k=#{i} #{res}" if res==nil || res.chomp != 'STORED'
+    when 1
+      res=rc.get(i.to_s)
+      puts "get k=#{i} #{res}" if res == :error
+    when 2
+      res=rc.delete(i.to_s)
+      puts "del k=#{i} #{res}" if res != 'DELETED' && res != 'NOT_FOUND'
+    end
+    t=(DateTime.now - ts).to_f * 86400.0
+    @tmax=t if t > @tmax
+    @tmin=t if t < @tmin
+    @cnt+=1
+  end
+end
+
+def set_counts(ini_nodes, range, key_prefix, value)
+  puts "\s\s#{__method__} #{range} #{value}"
+  rc=Roma::Client::RomaClient.new(ini_nodes)
+  @range_cnt = 0
+
+  range.each do |i|
+    ts = DateTime.now
+    @range_cnt = i
+    res=rc.set("#{key_prefix}_#{i}","#{value}")
+    puts "set #{key_prefix}_#{i}=#{value} #{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 check_count(ini_nodes, range, key_prefix, value)
+  puts "\s\s#{__method__} #{range} #{value}"
+  rc=Roma::Client::RomaClient.new(ini_nodes)
+
+  range.each do |i|
+    ts = DateTime.now
+    res = rc.get("#{key_prefix}_#{i}")
+    if res != value.to_s
+      puts "error k=#{key_prefix}_#{i} #{res}" 
+    end
+
+    t=(DateTime.now - ts).to_f * 86400.0
+    @tmax=t if t > @tmax
+    @tmin=t if t < @tmin
+    @cnt+=1
+  end
+end
+
+def send_cmd(nid, cmd)
+  conn = Roma::Client::ConPool.instance.get_connection(nid)
+  conn.write "#{cmd}\r\n"
+  ret = conn.gets
+  Roma::Client::ConPool.instance.return_connection(nid, conn)
+  ret
+rescue =>e
+  STDERR.puts "#{nid} #{cmd} #{e.inspect}"
+  nil
+end
+
+def stats(nid, regexp=nil)
+  conn = Roma::Client::ConPool.instance.get_connection(nid)
+  if regexp
+    conn.write "stats #{regexp}\r\n"
+  else
+    conn.write "stats\r\n"
+  end
+  ret = ""
+  while(conn.gets != "END\r\n")
+    ret << $_
+  end
+  Roma::Client::ConPool.instance.return_connection(nid, conn)
+  ret
+rescue =>e
+  STDERR.puts "#{nid} #{e.inspect}"
+  nil  
+end
+
+def safecopy_stats(nid)
+  ret = stats(nid, 'storage.safecopy_stats')
+  return eval $1 if ret =~ /^.+\s(\[.+\])/
+  nil
+end
+
+def set_storage_status(nid, fno, stat)
+  send_cmd(ARGV[0], "set_storage_status #{fno} #{stat}")
+end
+
+def wait_status(nid, fno, stat)
+  while safecopy_stats(nid)[fno] != stat
+    sleep 5
+  end
+  stat
+end
+
+def test_change_status
+
+  puts "write (0...10000) = 0"
+  set_counts(ARGV, 0...10000, "default_key",0)
+  Thread.new { random_rquest_sender(ARGV, 10000) }
+
+  set_counts(ARGV, 0...1000, "flushing_key", 0)
+  set_counts(ARGV, 0...1000, "caching_key", 0)
+
+  nid = ARGV[0]
+
+  sleep(5)
+
+  10.times do |n|
+    puts "\n#{n+1}th loop(#{n}.tc)****************************************************************** " 
+
+    #========================================================================================
+    #flushing(normal => safecopy_flushed)
+    flush_loop_count = 0
+    @range_cnt = 0
+    @flag = false
+
+    t = Thread.new {
+      loop{
+        flush_loop_count += 1
+        set_counts(ARGV, 0...1000, "flushing_key", flush_loop_count)
+        @flag = true
+      }
+    }
+    while !@flag do
+      puts "\s\s[debug]sleep flushing start"
+      sleep(1)
+      puts "\s\s[debug]sleep flushing end"
+    end
+    puts "\s\s#{set_storage_status(nid, n, 'safecopy')}"
+    puts "#{wait_status(nid, n, :safecopy_flushed)}"
+
+    #sleep(5)
+    t.kill
+
+    flushing_range_cnt = @range_cnt
+    puts "\s\s#{safecopy_stats(nid)}\n\n"
+
+    #========================================================================================
+    #Caching(safecopy_flushed => normal)
+    #sleep(30)
+    cache_loop_count = 0
+    @range_cnt = 0
+    @flag = false
+    t = Thread.new {
+      loop{
+        cache_loop_count += 1
+        set_counts(ARGV, 0...1000, "caching_key", cache_loop_count)
+        @flag = true
+      }
+    }
+    while !@flag do 
+      puts "\s\s[debug]sleep caching start"
+      sleep(1)
+      puts "\s\s[debug]sleep caching end"
+    end
+
+    puts "\s\s#{set_storage_status(nid, n, 'normal')}"
+    puts "#{wait_status(nid, n, :normal)}"
+    
+    #sleep(5)
+    t.kill   
+
+    caching_range_cnt = @range_cnt
+    puts "\s\s#{safecopy_stats(nid)}"
+
+    #========================================================================================
+    #check
+    puts "\n[Check]"
+    puts "\s\sflushing key"
+    check_count(ARGV, 0..flushing_range_cnt, "flushing_key", flush_loop_count)
+    check_count(ARGV, flushing_range_cnt+1...1000, "flushing_key", flush_loop_count-1)
+
+    puts "\n\s\scaching key"
+    check_count(ARGV, 0..caching_range_cnt, "caching_key", cache_loop_count)
+    check_count(ARGV, caching_range_cnt+1...1000, "caching_key", cache_loop_count-1) if cache_loop_count != 1
+  end
+end
+
+def test_round
+  n = 0
+  1000.times do |i|
+    set_counts(ARGV, 0...10000, i)
+    check_count(ARGV, 0...10000, i)
+  end
+end
+
+param = { :num=>10000, :th=>1 }
+
+opts = OptionParser.new
+
+opts.on("-r", "--round", "round request"){|v| param[:round] = v }
+opts.on("-c", "--count [x]", "counts of the test times"){|v| param[:count] = v.to_i }
+
+opts.banner = "usage:#{File.basename($0)} [options] addr:port"
+opts.parse!(ARGV)
+
+if ARGV.length == 0
+  STDERR.puts opts.help
+  exit
+end
+
+if param.key?(:round)
+  test_round
+else
+  param[:count] = 1 if !param.key?(:count)
+
+  param[:count].times do |count|
+    puts "#{count+1}th test========================================================================================="
+    test_change_status
+  end
+end
+
+puts "#{File.basename($0)} has done."