roma 0.8.14 → 1.0.0

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

@@ -13,27 +13,53 @@ module Roma
         exclude_nodes
       end
       
-      alias :exclude_nodes_for_join :exclude_nodes
+      def exclude_nodes_for_join(ap_str, rep_host)
+        [ap_str]
+      end
+
+      #alias :exclude_nodes_for_join :exclude_nodes
       alias :exclude_nodes_for_recover :exclude_nodes
       alias :exclude_nodes_for_balance :exclude_nodes
 
+      def myhost_include?(nodes, myhost)
+        nodes.each do |nid|
+          return true if nid.split(/[:_]/)[0] == myhost
+        end
+        false
+      end
+      private :myhost_include?
+
       # vnode sampling exclude +exclude_nodes+
       def select_vn_for_join(exclude_nodes)
         short_idx = {}
+        myhost_idx = {}
         idx = {}
+        myhost = exclude_nodes[0].split(/[:_]/)[0]
         @rd.v_idx.each_pair do |vn, nids|
           unless list_include?(nids, exclude_nodes)
-            idx[vn] = nids
+            if myhost_include?(nids, myhost)
+              myhost_idx[vn] = nids
+            else
+              idx[vn] = nids # other nodes
+            end
             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]
+        if ks.length == 0
+          idx = myhost_idx
+          ks = idx.keys
+          return nil if ks.length == 0
+          vn = ks[rand(ks.length)]
+          nids = idx[vn]
+          [vn, nids, nids[0].split(/[:_]/)[0] == myhost]
+        else
+          vn = ks[rand(ks.length)]
+          nids = idx[vn]
+          [vn, nids, rand(@rd.rn) == 0]
+        end
       end
 
       # select a vnodes where short of redundancy.
@@ -66,7 +92,8 @@ module Roma
           nids.each{|nid| buf.delete(nid) }
         end
         
-        to_nid = buf[rand(buf.length)]
+        buf.delete_if{|instance| instance == ap_str}
+        to_nid = buf.sample
         new_nids = nids.map{|n| n == ap_str ? to_nid : n }
         [to_nid, new_nids]
       end

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

@@ -35,10 +35,9 @@ module Roma
         init_mtree
       end
 
-      def get_stat(ap)
-
+      def num_of_vn(ap)
         pn = sn = short = lost = 0
-        @rd.v_idx.each_pair{|vn, nids|
+        @rd.v_idx.each_pair do |vn, nids|
           if nids == nil || nids.length == 0
             lost += 1
             next
@@ -48,8 +47,12 @@ module Roma
             sn += 1
           end
           short += 1 if nids.length < @rd.rn
-        }
+        end
+        [pn, sn, short, lost]
+      end
 
+      def get_stat(ap)
+        pn, sn, short, lost = num_of_vn(ap)
         ret = {}
         ret['routing.redundant'] = @rn
         ret['routing.nodes.length'] = nodes.length
@@ -128,6 +131,20 @@ module Roma
         @rd.dump_binary
       end
 
+      def check_repetition_in_routing
+        @rd.v_idx.each_value{|value|
+          host = []
+          value.each{|instance|
+            host << instance.split("_")[0]
+          }
+          if host.uniq!
+            return true
+          end
+        }
+
+        false
+      end
+
       def proc_failed(nid)
         t = Time.now
         if t - @fail_time > @fail_cnt_gap
@@ -162,7 +179,7 @@ module Roma
 
       def get_replaced_rd(regxp, replace)
         rd = Marshal.load(dump)
-        
+
         rd.nodes.map! do |nid|
           nid.sub(regxp, replace)
         end
@@ -174,7 +191,7 @@ module Roma
         end
         rd
       end
-      
+
       def check_netmask?(addr, mask)
         if addr =~ /(\d+)\.(\d+)\.(\d+)\.(\d+)/
           iaddr = ($1.to_i  << 24) + ($2.to_i << 16) + ($3.to_i << 8) + $4.to_i
@@ -192,7 +209,7 @@ module Roma
         end
         (iaddr & imask) == (imask_addr & imask)
       end
-      
+
     end # class RoutingTable
 
   end # module Routing

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

@@ -71,6 +71,11 @@ module Roma
 
     attr_accessor :routing_trans_timeout
 
+    # for GUI tool
+    attr_accessor :gui_run_snapshot
+    attr_accessor :gui_run_gather_logs
+    attr_accessor :gui_last_snapshot
+
     def initialize
       @config_path = nil
       @run_recover = false
@@ -81,7 +86,10 @@ module Roma
       @run_release = false
       @run_join = false
       @run_balance = false
+      @gui_run_snapshot = false
+      @gui_run_gather_logs = false
       @last_clean_up = Time.now
+      @gui_last_snapshot = []
       @spushv_protection = false
       @stream_copy_wait_param = 0.0001
       @dcnice = 3
@@ -94,7 +102,7 @@ module Roma
       @out_message_count = 0
       @redundant_count = 0
       @size_of_zredundant = 0
-      @hilatency_warn_time = 5
+      @hilatency_warn_time = 5.0
       @wb_command_map = {}
       @latency_log = false
       @latency_check_cmd =["get", "set", "delete"]
@@ -128,7 +136,9 @@ module Roma
       ret['stats.run_release'] = @run_release
       ret['stats.run_join'] = @run_join
       ret['stats.run_balance'] = @run_balance
+      ret['stats.gui_run_snapshot'] = @gui_run_snapshot
       ret['stats.last_clean_up'] = @last_clean_up
+      ret['stats.gui_last_snapshot'] = @gui_last_snapshot
       ret['stats.spushv_protection'] = @spushv_protection
       ret['stats.stream_copy_wait_param'] = @stream_copy_wait_param
       ret['stats.dcnice'] = @dcnice

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

@@ -22,6 +22,7 @@ module Roma
       attr_accessor :each_vn_dump_sleep
       attr_accessor :each_vn_dump_sleep_count
       attr_accessor :each_clean_up_sleep
+      attr_accessor :cleanup_regexp
       attr_accessor :logic_clock_expire
 
       attr_accessor :do_each_vn_dump
@@ -34,6 +35,8 @@ module Roma
         # status of a database
         @dbs = []
         @log_fd = nil
+        # file number list of a each_vn_dump while
+        @each_vn_dump_vnodes = []
 
         @hdiv = Hash.new(0)
 
@@ -44,6 +47,7 @@ module Roma
         @each_vn_dump_sleep = 0.001
         @each_vn_dump_sleep_count = 100
         @each_clean_up_sleep = 0.01
+        @cleanup_regexp = nil
         @logic_clock_expire = 300
 
         @each_cache_lock = Mutex::new
@@ -58,7 +62,9 @@ module Roma
         ret['storage.option'] = @option
         ret['storage.each_vn_dump_sleep'] = @each_vn_dump_sleep
         ret['storage.each_vn_dump_sleep_count'] = @each_vn_dump_sleep_count
+        ret['storage.each_vn_dump_files'] = @each_vn_dump_files.inspect
         ret['storage.each_clean_up_sleep'] = @each_clean_up_sleep
+        ret['storage.cleanup_regexp'] = @cleanup_regexp
         ret['storage.logic_clock_expire'] = @logic_clock_expire
         ret['storage.safecopy_stats'] = @dbs.inspect
         ret
@@ -414,6 +420,12 @@ module Roma
 
       def each_clean_up(t, vnhash)
         @do_clean_up = true
+
+        f = nil;
+        if @cleanup_regexp && File.exist?(@storage_path)
+          f = open(@storage_path + '/klist.txt','w')
+        end
+
         return unless @each_clean_up_lock.try_lock
         nt = Time.now.to_i
         @divnum.times do |i|
@@ -423,6 +435,10 @@ module Roma
             return unless @do_clean_up # 1st check
             vn, last, clk, expt = unpack_header(v)
             vn_stat = vnhash[vn]
+            if f && @cleanup_regexp && k =~ /#{@cleanup_regexp}/
+              # write klist
+              f.puts("#{k},#{last},#{clk}") if hdb.get(k) == v
+            end
             if vn_stat == :primary && ( (expt != 0 && nt > expt) || (expt == 0 && t > last) )
               if yield k, vn
                 hdb.out(k) if hdb.get(k) == v
@@ -437,7 +453,11 @@ module Roma
           end
         end
       ensure
-        @each_clean_up_lock.unlock if @each_clean_up_lock.locked?  
+        @each_clean_up_lock.unlock if @each_clean_up_lock.locked?
+        if f
+          @cleanup_regexp = nil
+          f.close
+        end
       end
 
       def stop_clean_up(&block)
@@ -524,42 +544,24 @@ module Roma
       end
 
       def each_vn_dump(target_vn)
-        @do_each_vn_dump = true
         n = @hdiv[target_vn]
-        if @dbs[n] == :normal
-          # in case of :normal status
+        @stat_lock.synchronize do
+          return false if @dbs[n] != :normal
+          return false if @each_vn_dump_vnodes.include?(target_vn)
+          @each_vn_dump_vnodes << target_vn
+        end
+
+        begin
+          @do_each_vn_dump = true
           each_unpacked_db(target_vn, @hdb) do |vn, last, clk, expt, k, val|
             return unless @do_each_vn_dump
             yield vn_dump_pack(vn, last, clk, expt, k, val)
           end
-        else
-          # in case of out of :normal status
-          @each_cache_lock.synchronize do
-            each_unpacked_db(target_vn, @hdbc) do |cvn, clast, cclk, cexpt, k, cval|
-              return unless @do_each_vn_dump
-              data = @hdb[n].get(k)
-              if data
-                vn, last, clk, expt, val = unpack_data(data)
-                #puts "#{k} #{clk} #{cclk} #{cmp_clk(clk, cclk)} #{val}"
-                if cmp_clk(clk, cclk) > 0
-                  yield vn_dump_pack(vn, last, clk, expt, k, val)
-                else
-                  yield vn_dump_pack(cvn, clast, cclk, cexpt, k, cval)
-                end
-              else
-                yield vn_dump_pack(cvn, clast, cclk, cexpt, k, cval)
-              end
-            end
-          end
-          each_unpacked_db(target_vn, @hdb) do |vn, last, clk, expt, k, val|
-            return unless @do_each_vn_dump
-            unless @hdbc[n].get(k)
-              yield vn_dump_pack(vn, last, clk, expt, k, val)
-            end
-          end
+        ensure
+          @each_vn_dump_vnodes.delete(target_vn)
         end
-      ensure
-        @do_each_vn_dump = false
+
+        true
       end
 
       def vn_dump_pack(vn, last, clk, expt, k, val)
@@ -674,6 +676,9 @@ module Roma
         @stat_lock.synchronize do
           case @dbs[dn]
           when :normal
+            @each_vn_dump_vnodes.each do |vn|
+              return false if dn == @hdiv[vn]
+            end
             if stat == :safecopy_flushing
               # open cache
               @hdbc[dn] = open_db(cache_file_name(dn))

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

@@ -9,6 +9,7 @@ module Roma
 
     def initialize(addr, port)
       @con = TCPSocket.open(addr, port)
+      set_gui_run_snapshot_status('true')
       get_storage_info
     end
 
@@ -81,12 +82,24 @@ module Roma
       @con.gets
     end
 
+    def set_gui_run_snapshot_status(status)
+      @con.puts "set_gui_run_snapshot #{status}\r\n"
+      @con.gets
+    end
+
+    def set_gui_last_snapshot
+      t = Time.now.strftime('%Y/%m/%dT%H:%M:%S')
+      @con.puts "set_gui_last_snapshot #{t}\r\n"
+      @con.gets
+    end
+
     def stats
       @con.puts "stat storage\r\n"
       yield $_ while @con.gets != "END\r\n"
     end
 
     def close
+      set_gui_run_snapshot_status('false')
       @con.close if @con
     end
 
@@ -99,5 +112,10 @@ if ARGV.length < 1
 end
 
 sc = Roma::SafeCopy.new("localhost", ARGV[0].to_i)
-sc.backup_all
-sc.close
+
+begin
+  sc.backup_all
+  sc.set_gui_last_snapshot
+ensure
+  sc.close
+end

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

@@ -53,8 +53,16 @@ def set_counts(ini_nodes, range, key_prefix, value)
   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'
+    res = nil
+    begin
+      res=rc.set("#{key_prefix}_#{i}","#{value}")
+      raise "set #{key_prefix}_#{i}=#{value} #{res}" if res==nil || res.chomp != 'STORED'
+    rescue => e
+      puts "error:s#{__method__}: #{e}"
+      puts "retry"
+      sleep 0.1
+      retry
+    end
     t=(DateTime.now - ts).to_f * 86400.0
     @tmax=t if t > @tmax
     @tmin=t if t < @tmin
@@ -68,7 +76,14 @@ def check_count(ini_nodes, range, key_prefix, value)
 
   range.each do |i|
     ts = DateTime.now
-    res = rc.get("#{key_prefix}_#{i}")
+    res = nil
+    begin
+      res = rc.get("#{key_prefix}_#{i}")
+    rescue => e
+      puts "error: #{e}"
+      sleep 1
+      retry
+    end
     if res != value.to_s
       puts "error k=#{key_prefix}_#{i} #{res}" 
     end
@@ -116,7 +131,15 @@ def safecopy_stats(nid)
 end
 
 def set_storage_status(nid, fno, stat)
-  send_cmd(ARGV[0], "set_storage_status #{fno} #{stat}")
+  cnt = 0
+  begin
+    res = send_cmd(ARGV[0], "set_storage_status #{fno} #{stat}")
+    res.chomp! if res
+    puts res if cnt > 0
+    sleep 0.5
+    cnt += 1
+  end while res != 'PUSHED'
+  res
 end
 
 def wait_status(nid, fno, stat)
@@ -140,7 +163,7 @@ def test_change_status
   sleep(5)
 
   10.times do |n|
-    puts "\n#{n+1}th loop(#{n}.tc)****************************************************************** " 
+    puts "\n#{n+1}th loop(#{n}.tc) " + "*" * 70 
 
     #========================================================================================
     #flushing(normal => safecopy_flushed)
@@ -155,11 +178,9 @@ def test_change_status
         @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[debug]sleep flushing start"
+    sleep(1) while !@flag
+    puts "\s\s[debug]sleep flushing end"
     puts "\s\s#{set_storage_status(nid, n, 'safecopy')}"
     puts "#{wait_status(nid, n, :safecopy_flushed)}"
 
@@ -167,6 +188,7 @@ def test_change_status
     t.kill
 
     flushing_range_cnt = @range_cnt
+    puts "flushing_range_cnt = #{@range_cnt}"
     puts "\s\s#{safecopy_stats(nid)}\n\n"
 
     #========================================================================================
@@ -182,11 +204,9 @@ def test_change_status
         @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[debug]sleep caching start"
+    sleep(1) while !@flag
+    puts "\s\s[debug]sleep caching end"
 
     puts "\s\s#{set_storage_status(nid, n, 'normal')}"
     puts "#{wait_status(nid, n, :normal)}"
@@ -195,6 +215,7 @@ def test_change_status
     t.kill   
 
     caching_range_cnt = @range_cnt
+    puts "caching_range_cnt = #{@range_cnt}"
     puts "\s\s#{safecopy_stats(nid)}"
 
     #========================================================================================
@@ -239,7 +260,7 @@ else
   param[:count] = 1 if !param.key?(:count)
 
   param[:count].times do |count|
-    puts "#{count+1}th test========================================================================================="
+    puts "#{count+1}th test " + "=" * 70
     test_change_status
   end
 end