roma 0.8.2 → 0.8.10

data/{lib → ruby/server/lib}/roma/routing/cb_rttable.rb

@@ -40,9 +40,7 @@ module Roma
       
       def set_version(nid,ver)
         @version_of_nodes[nid] = ver
-        if @min_version == nil || @min_version > ver
-          @min_version = ver
-        end
+        @min_version = find_min_version
       end
 
       def find_min_version
@@ -176,8 +174,8 @@ module Roma
       end
 
       def enabled_failover=(b)
-        @enabled_failover=b
         @fail_cnt.clear
+        @enabled_failover=b
       end
 
       def enabled_failover
@@ -312,9 +310,9 @@ module Roma
 
         @log.debug("#{__FILE__}:#{__LINE__}:n=#{n} pcount=#{pcount} scount=#{scount}")
 
-        if pcount > n*1.1
+        if pcount > n
           return :over
-        elsif pcount < n*0.9
+        elsif pcount < n
           return :less
         end
         :even

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

@@ -0,0 +1,307 @@
+require 'yaml'
+
+module Roma
+  module Routing
+
+    class RoutingData
+      attr_accessor :dgst_bits
+      attr_accessor :div_bits
+      attr_accessor :rn
+      attr_accessor :nodes
+      attr_accessor :v_idx
+      attr_accessor :v_clk
+
+      def initialize(dgst_bits,div_bits,rn)
+        @dgst_bits=dgst_bits
+        @div_bits=div_bits
+        @rn=rn
+        @nodes=[]
+        @v_idx={}
+        @v_clk={}
+      end
+
+      def save(fname)
+        @nodes.sort!
+        open(fname,'wb'){|io|
+          io.write(YAML.dump(self))
+        }
+      end
+
+      def self.load(fname)
+        rd=load_snapshot(fname)
+        rd.load_log_all(fname)
+        rd
+      end
+
+      def self.load_snapshot(fname)
+        rd=nil
+        open(fname,'rb'){|io|
+          rd = YAML.load(io.read)
+        }
+        rd
+      end
+
+      def self.snapshot(fname)
+        rd=load_snapshot(fname)
+        loglist=rd.get_file_list(fname)
+        if loglist.length<2
+          return false
+        end
+        loglist.delete(loglist.last)
+        loglist.each{|i,f|
+          rd.load_log_one(f)
+          File.rename(f,"#{f}~")
+        }
+        File.rename(fname,"#{fname}~")
+        rd.save(fname)
+        true
+      end
+
+      def self.decode_binary(bin)
+        magic, ver, dgst_bits, div_bits, rn, nodeslen = bin.unpack('a2nCCCn')
+        raise 'Illegal format error' if magic != 'RT'
+        raise 'Unsupported version error' if ver != 1
+
+        rd = RoutingData.new(dgst_bits, div_bits, rn)
+        
+        bin = bin[9..-1]
+        nodeslen.times{|i|
+          len, = bin.unpack('n')
+          bin = bin[2..-1]
+          nid, = bin.unpack("a#{len}")
+          bin = bin[len..-1]
+          rd.nodes << nid 
+        }
+        (2**div_bits).times{|i|
+          vn=i<<(dgst_bits-div_bits)
+          v_clk,len = bin.unpack('Nc')
+          rd.v_clk[vn] = v_clk
+          bin = bin[5..-1]
+          len.times{|i|
+            idx, = bin.unpack('n')
+            rd.v_idx[vn] = [] unless rd.v_idx[vn]
+            rd.v_idx[vn] << rd.nodes[idx]
+            bin = bin[2..-1]
+          }
+        }
+        rd
+      end
+
+      # 2 bytes('RT'):magic code
+      # unsigned short:format version
+      # unsigned char:dgst_bits
+      # unsigned char:div_bits
+      # unsigned char:rn
+      # unsigned short:number of nodes
+      # while number of nodes
+      #  unsigned short:length of node-id string
+      #  node-id string
+      # while umber of vnodes
+      #  unsigned int32:v_clk
+      #  unsigned char:number of nodes
+      #  while umber of nodes
+      #   unsigned short:index of nodes
+      def dump_binary
+        format_version = 1
+        # 9 bytes
+        ret = ['RT',format_version,dgst_bits,div_bits,rn,nodes.length].pack('a2nCCCn')
+        rev_hash = {}
+        nodes.each_with_index{|nid,idx|
+          rev_hash[nid] = idx
+          # 2 + nid.length bytes
+          ret += [nid.length,nid].pack('na*')
+        }
+        (2**div_bits).times{|i|
+          vn=i<<(dgst_bits-div_bits)
+          # 5 bytes
+          ret += [v_clk[vn],v_idx[vn].length].pack('Nc')
+          v_idx[vn].each{|nid|
+            # 2 bytes
+            ret += [rev_hash[nid]].pack('n')
+          }
+        }
+        ret
+      end
+
+      def each_log_all(fname)
+        loglist=get_file_list(fname)
+        loglist.each{|i,f|
+          each_log_one(f){|t,l| yield t,l}
+        }
+      end
+
+      def each_log_one(fname)
+        File.open(fname,"r"){|f|
+          while((line=f.gets)!=nil)
+            line.chomp!
+            next if line[0]=="#" || line.length==0
+            if line =~ /(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\.\d+\s(.+)/
+              yield Time.mktime($1, $2, $3, $4, $5, $6), $7 
+            end
+          end
+        }
+      end
+
+      def load_log_all(fname)
+        each_log_all(fname){|t,line|
+          parse_log(t,line)
+        }
+        @nodes.sort!
+      end
+
+      def load_log_one(fname)
+        each_log_one(fname){|t,line|
+          parse_log(t,line)
+        }
+        @nodes.sort!
+      end
+
+      def parse_log(t,line)
+        s=line.split(' ')
+        case s[0]
+        when 'setroute'
+          # setroute <vnode-id> <clock> <node-id> ...
+          nids=[]
+          s[3..-1].each{ |nid| nids << nid }
+          @v_idx[s[1].to_i]=nids
+          @v_clk[s[1].to_i]=s[2].to_i
+        when 'join'
+          # join <node-id>
+          @nodes << s[1] unless @nodes.include?(s[1])
+        when 'leave'
+          # leave <node-id>
+          @nodes.delete(s[1])
+        else
+          raise "RoutingData.parse_log:parse error #{line}"
+        end
+      end
+
+      def search_mask
+        2**@div_bits-1<<(@dgst_bits-@div_bits)
+      end
+
+      def next_vnode(vn)
+        n = (vn >> (@dgst_bits-@div_bits)) + 1
+        n = 0 if n == (2**@div_bits)
+        n << (@dgst_bits-@div_bits)
+      end
+
+      def create_nodes_from_v_idx
+        buf_nodes={}
+        v_idx.each_value{|nids|
+          nids.each{|nid| buf_nodes[nid]=nid }
+        }
+        @nodes=buf_nodes.values.sort
+      end
+
+      # Returns the losted vnode-id list.
+      def get_lost_vnodes
+        ret=[]
+        v_idx.each_pair{|vn,nids|
+          ret << vn if nids.length == 0
+        }
+        ret
+      end
+
+      def self.create(dgst_bits,div_bits,rn,nodes,repethost=false)
+        ret=RoutingData.new(dgst_bits,div_bits,rn)
+        ret.nodes=nodes.clone
+
+        rnlm=RandomNodeListMaker.new(nodes,repethost)
+
+        (2**div_bits).times{|i|
+          vn=i<<(dgst_bits-div_bits)
+          ret.v_clk[vn]=0
+          ret.v_idx[vn]=rnlm.list(rn)
+        }
+        ret
+      end
+
+      # Returns the log file list by old ordered.
+      # +fname+:: Prefix of a log file.(ex.roma0_3300.route)
+      # One of the following example:
+      #   [[1, "roma0_3300.route.1"], [2, "roma0_3300.route.2"]]
+      def get_file_list(fname)
+        l={}
+        files=Dir.glob("#{fname}*")
+        files.each{ |file|
+          if /#{fname}\.(\d+)$/=~file
+            l[$1.to_i]=$&
+          end
+        }
+        # sorted by old order
+        l.to_a.sort{|a,b| a[0]<=>b[0]}
+      end
+
+      def get_histgram
+        ret = {}
+        nodes.each{|nid|
+          ret[nid] = Array.new(rn,0)
+        }
+        v_idx.each_pair{|vn,nids|
+          nids.each_with_index{|nid,i|
+            ret[nid][i] += 1
+          }
+        }
+        ret
+      end
+
+      private
+
+      class RandomNodeListMaker
+        def initialize(nodes,repethost)
+          @repethost=repethost
+          @nodes=nodes
+          @host_idx={}
+          nodes.each{|nid|
+            h,p=nid.split('_')
+            if @host_idx.key?(h)
+              @host_idx[h] << nid
+            else
+              @host_idx[h]=[nid]
+            end
+          }          
+        end
+
+        # Returns the random node-list without repetition.
+        # +n+:: list length
+        def list(n)
+          ret=[]
+          hosts=[]
+          proc_other_one = :get_other_one
+          proc_other_one = :get_other_one_repethost if @repethost
+          n.times{
+            nid=nil
+            nid=send(proc_other_one,hosts,ret)
+            break unless nid
+            hosts << nid.split('_')[0]
+            ret << nid
+          }
+          ret
+        end
+        
+        # +exp_hosts+:: ignore
+        # +exp_nodes+:: exceptional nodes(ex.['roma0_11211'])
+        def get_other_one_repethost(exp_hosts,exp_nodes)
+          buf=@nodes.clone
+          buf.delete_if{|nid| exp_nodes.include?(nid)}
+          buf[rand(buf.length)]
+        end
+
+        # +exp_hosts+:: exceptional hosts(ex.['roma0','roma1'])
+        # +exp_nodes+:: ignore
+        def get_other_one(exp_hosts,exp_nodes)
+          hidx=@host_idx.clone
+          exp_hosts.each{|h| hidx.delete(h) }
+          return nil if hidx.length == 0
+          
+          rh=hidx.keys[rand(hidx.keys.length)]
+          nodes=hidx[rh]
+          nodes[rand(nodes.length)]
+        end
+      end # class RandomNodeListMaker
+
+    end # class RoutingData
+
+  end # module Routing
+end # module Roma

data/{lib → ruby/server/lib}/roma/routing/rttable.rb

@@ -122,6 +122,10 @@ module Roma
                        @rd.nodes,@rd.v_idx])
       end
 
+      def dump_binary
+        @rd.dump_binary
+      end
+
       def proc_failed(nid)
         t = Time.now
         if t - @fail_time > @fail_cnt_gap

data/{lib → ruby/server/lib}/roma/stats.rb

@@ -1,11 +1,13 @@
 require 'singleton'
-require 'roma/config'
 
 module Roma
 
   class Stats
     include Singleton
 
+    # environment options
+    attr_accessor :config_path
+
     # command options
     attr_accessor :address, :port
     attr_accessor :daemon
@@ -14,6 +16,7 @@ module Roma
     attr_accessor :name
     attr_accessor :verbose
     attr_accessor :enabled_repetition_host_in_routing
+    attr_accessor :disabled_cmd_protect
 
     # proc mode
     attr_accessor :enabled_vnodes_balance
@@ -29,6 +32,7 @@ module Roma
 
     # proc param
     attr_accessor :stream_copy_wait_param
+    attr_accessor :dcnice
 
     # compressed redundant param
     attr_accessor :size_of_zredundant
@@ -41,7 +45,13 @@ module Roma
     attr_accessor :out_message_count
     attr_accessor :redundant_count
 
+    attr_accessor :hilatency_warn_time
+
+    # for write behind
+    attr_accessor :wb_command_map
+
     def initialize
+      @config_path = nil
       @run_acquire_vnodes = false
       @run_recover = false
       @run_sync_routing = false
@@ -49,8 +59,8 @@ module Roma
       @run_storage_clean_up = false
       @run_receive_a_vnode = false
       @run_release = false
-      @stream_copy_wait_param = 
-        Roma::Config::DATACOPY_STREAM_COPY_WAIT_PARAM
+      @stream_copy_wait_param = 0.0001
+      @dcnice = 3
       @enabled_vnodes_balance = nil
       @write_count = 0
       @read_count = 0
@@ -59,6 +69,8 @@ module Roma
       @out_message_count = 0
       @redundant_count = 0
       @size_of_zredundant = 0
+      @hilatency_warn_time = 5
+      @wb_command_map = {}
     end
 
     def ap_str
@@ -67,6 +79,7 @@ module Roma
 
     def get_stat
       ret = {}
+      ret['stats.config_path'] = @config_path
       ret['stats.address'] = @address
       ret['stats.port'] = @port
       ret['stats.daemon'] = @daemon
@@ -80,6 +93,7 @@ module Roma
       ret['stats.run_storage_clean_up'] = @run_storage_clean_up
       ret['stats.run_release'] = @run_release
       ret['stats.stream_copy_wait_param'] = @stream_copy_wait_param
+      ret['stats.dcnice'] = @dcnice
       ret['stats.size_of_zredundant'] = @size_of_zredundant
       ret['stats.write_count'] = @write_count
       ret['stats.read_count'] = @read_count
@@ -87,6 +101,8 @@ module Roma
       ret['stats.out_count'] = @out_count
       ret['stats.out_message_count'] = @out_message_count
       ret['stats.redundant_count'] = @redundant_count
+      ret['stats.hilatency_warn_time'] = @hilatency_warn_time
+      ret['stats.wb_command_map'] = @wb_command_map.inspect
       ret
     end
 

data/{lib → ruby/server/lib}/roma/storage/basic_storage.rb

@@ -3,6 +3,8 @@ require 'digest/sha1'
 module Roma
   module Storage
 
+    class StorageException < Exception; end
+
     class BasicStorage
 
       attr :hdb
@@ -13,9 +15,9 @@ module Roma
 
       attr_writer :vn_list
       attr_writer :storage_path
-      attr_writer :divnum
       attr_writer :option
 
+      attr_accessor :divnum
       attr_accessor :each_vn_dump_sleep
       attr_accessor :each_vn_dump_sleep_count
       attr_accessor :each_clean_up_sleep
@@ -87,6 +89,7 @@ module Roma
       end
 
       def closedb
+        stop_clean_up
         buf = @hdb; @hdb = []
         buf.each{ |hdb| close_db(hdb) }
       end
@@ -237,6 +240,14 @@ module Roma
         unpack_data(buf)
       end
 
+      def get_raw2(k)
+        @hdb.each{|hdb|
+          buf = hdb.get(k)
+          return unpack_data(buf) if buf
+        }
+        nil
+      end
+
       def rdelete(vn, k, d, clk)
         buf = @hdb[@hdiv[vn]].get(k)
         t = Time.now.to_i
@@ -323,6 +334,19 @@ module Roma
         nil
       end
 
+      # set expire time
+      def set_expt(vn, k, d, expt)
+        buf = @hdb[@hdiv[vn]].get(k)
+        if buf
+          vn, t, clk, expt2, v = unpack_data(buf)
+          return nil if Time.now.to_i > expt2
+          clk = (clk + 1) & 0xffffffff
+          ret = [vn, Time.now.to_i, clk, expt, v]
+          return ret if @hdb[@hdiv[vn]].put(k, pack_data(*ret))
+        end
+        nil
+      end
+
       def true_length
         res = 0
         @hdb.each{ |hdb| res += hdb.rnum }
@@ -337,30 +361,6 @@ module Roma
         buf.each_key{ |k| @hdb[@hdiv[vn]].out(k) }
       end
 
-      def clean_up(t,unit_test_flg=nil)
-        n = 0
-        nt = Time.now.to_i
-        @hdb.each_index{ |i|
-          delkey = []
-          @hdb[i].each{ |k, v|
-            vn, last, clk, expt = unpack_header(v)
-            if nt > expt && t > last
-              n += 1
-              #delkey << k
-              @hdb[i].out(k)
-            end
-            if unit_test_flg
-              closedb
-            end
-            sleep @each_clean_up_sleep
-          }
-          #delkey.each{ |k| @hdb[i].out(k) }
-        }
-        n
-      rescue => e
-        raise NoMethodError(e.message)
-      end
-
       def each_clean_up(t, vnhash)
         @do_clean_up = true
         nt = Time.now.to_i
@@ -488,7 +488,6 @@ module Roma
           end
         }
       end
-      private :each_hdb_dump
 
       # Create vnode dump.
       def get_vnode_hash(vn)