roma 0.8.11 → 0.8.12

data/ruby/server/lib/roma/command/bg_command_receiver.rb

@@ -11,52 +11,53 @@ module Roma
 
       def ev_balance(s)
         res = broadcast_cmd("rbalance\r\n")
-        if @stats.run_recover==false && 
-            @stats.run_acquire_vnodes == false &&
+        if @stats.run_join == false &&
+            @stats.run_recover == false && 
+            @stats.run_balance == false &&
             @rttable.vnode_balance(@stats.ap_str)==:less
-          Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_acquire_vnodes_process'))
+          Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_balance_process'))
           res[@stats.ap_str] = 'STARTED'
         else
-          res[@stats.ap_str] = 'SERVER_ERROR Not unbalance or Balance/Recover/Sync process is already running.'
+          res[@stats.ap_str] = 'SERVER_ERROR Not unbalance or othre process is already running.'
         end
         send_data("#{res}\r\n")
       end
 
       def ev_rbalance(s)
-        if @stats.run_recover==false && 
-            @stats.run_acquire_vnodes == false &&
+        if @stats.run_join == false &&
+            @stats.run_recover == false && 
+            @stats.run_balance == false &&
             @rttable.vnode_balance(@stats.ap_str)==:less
-          Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_acquire_vnodes_process'))
+          Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_balance_process'))
           send_data("STARTED\r\n")
         else
-          send_data("SERVER_ERROR Not unbalance or Balance/Recover/Sync process is already running.\r\n")
+          send_data("SERVER_ERROR Not unbalance or other process is already running.\r\n")
         end
       end
 
       def ev_release(s)
-        if @stats.run_recover==false && 
-            @stats.run_acquire_vnodes == false &&
+        if @stats.run_join == false &&
+            @stats.run_recover == false && 
+            @stats.run_balance == false &&
             @stats.run_release == false &&
             @stats.run_iterate_storage == false
           Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_release_process'))
           send_data("STARTED\r\n")
         else
-          send_data("SERVER_ERROR Release/Balance/Recover/Sync process is already running.\r\n")
+          send_data("SERVER_ERROR Other process is already running.\r\n")
         end
       end
 
-      # recover [-r|-s]
+      # recover
       def ev_recover(s)
-        option = s[1] if s.length == 2
         if @rttable.can_i_recover?
           cmd = "rrecover"
-          cmd << " #{option}" if option
           res = broadcast_cmd("#{cmd}\r\n")
           unless @stats.run_recover
-            Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_recover_process',[option]))
+            Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_recover_process'))
             res[@nid] = "STARTED"
           else
-            res[@nid] = "SERVER_ERROR Recover/Sync process is already running."
+            res[@nid] = "SERVER_ERROR Recover process is already running."
           end
           send_data("#{res}\r\n")
         else
@@ -64,12 +65,11 @@ module Roma
         end
       end
 
-      # rrecover [-r|-s]
+      # rrecover
       def ev_rrecover(s)
-        option = s[1] if s.length == 2
         if @rttable.can_i_recover?
           unless @stats.run_recover
-            Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_recover_process',[option]))
+            Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_recover_process'))
             send_data("STARTED\r\n")
           else
             send_data("SERVER_ERROR Recover process is already running.\r\n")
@@ -79,109 +79,6 @@ module Roma
         end
       end
 
-      # sync <hname>
-      def ev_sync(s)
-        res = nil
-        if s.length==1
-          res = broadcast_cmd("rsync\r\n")
-        else
-          res = broadcast_cmd("rsync #{s[1]}\r\n")
-        end
-        unless @stats.run_recover
-          if s.length==1
-            Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_sync_process',@storages.keys))
-          else
-            Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_sync_process',[s[1]]))
-          end
-          res[@nid] = "STARTED"
-        else
-          res[@nid] = "SERVER_ERROR Recover/Sync process is already running."
-        end
-        send_data("#{res}\r\n")
-      rescue => e
-        @log.error("#{e}\n#{$@}")
-      end
-
-      # rsync <hname>
-      def ev_rsync(s)
-        unless @stats.run_recover
-          if s.length==1
-            Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_sync_process',@storages.keys))
-          else
-            Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_sync_process',[s[1]]))
-          end
-          send_data("STARTED\r\n")
-        else
-          send_data("SERVER_ERROR Recover/Sync process is already running.\r\n")
-        end
-      rescue => e
-        @log.error("#{e}\n#{$@}")
-      end
-
-      # dumpfile <key> <path>
-      def ev_dumpfile(s)
-        if s.length != 3
-          send_data("CLIENT_ERROR usage:dumpfile <key> <path>\r\n")
-          return
-        end
-
-        res = broadcast_cmd("rdumpfile #{s[1]} #{s[2]}\r\n")
-        Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_dumpfile_process',[s[1],s[2],:dumpfile]))
-        path = Roma::Config::STORAGE_DUMP_PATH + '/' + s[2]
-        res[@nid] = "STARTED #{path}/#{@nid}"
-        send_data("#{res}\r\n")
-      rescue => e
-        @log.error("#{e}\n#{$@}")
-      end
-
-      # rdumpfile <key> <path>
-      def ev_rdumpfile(s)
-        if s.length != 3
-          send_data("CLIENT_ERROR usage:rdumpfile <key> <path>\r\n")
-          return
-        end
-        Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_dumpfile_process',[s[1],s[2],:rdumpfile]))
-        path = Roma::Config::STORAGE_DUMP_PATH + '/' + s[2]
-        send_data("STARTED #{path}/#{@nid}\r\n")
-      rescue => e
-        @log.error("#{e}\n#{$@}")
-      end
-
-      def acquire_vnodes
-        count = 0
-        nv = @rttable.v_idx.length
-        while (@rttable.vnode_balance(@nid) == :less && count < nv) do
-          count += 1
-          break unless acquire_vnode
-        end
-        @log.info("acquire_vnodes has done.")
-      rescue => e
-        @log.error("#{e}\n#{$@}")
-      end
-
-      def acquire_vnode
-        widthout_nodes = @rttable.nodes
-
-        unless @stats.enabled_repetition_host_in_routing
-          myhost = @stats.ap_str.split(/[:_]/)[0]
-          widthout_nodes.delete_if{|nid| nid.split(/[:_]/)[0] != myhost }
-        else
-          widthout_nodes = [@stats.ap_str]
-        end
-
-        vn, nodes = @rttable.sample_vnode(widthout_nodes)
-        unless vn
-          @log.warn("acquire_vnode:sample_vnode dose not found")
-          return false
-        end
-        #
-        # tunning point
-        # sleep 0.1
-        #
-        req_push_a_vnode(vn, nodes[0], rand(@rttable.rn) == 0)
-        true
-      end
-
     end # module BackgroundCommandReceiver
 
   end # module Command

data/ruby/server/lib/roma/command/vn_command_receiver.rb

@@ -6,25 +6,16 @@ module Roma
 
     module VnodeCommandReceiver
 
-      # pushv <hash-name> <vnode-id>
-      # src                             dst
-      #  |   ['pushv' <hname> <vn>\r\n]->|
-      #  |<-['READY'\r\n]                |
-      #  |               [<length>\r\n]->|
-      #  |                 [<dump>\r\n]->|
-      #  |                  ['END'\r\n]->|
-      #  |<-['STORED'\r\n]               |
-      def ev_pushv(s)
-        send_data("READY\r\n")
-        len = gets
-        res = em_receive_dump(s[1], len.to_i)
-        if res == true
-          send_data("STORED\r\n")
+      # spushv <true/false>
+      def ev_spushv_protection(s)
+        if s.length == 1
+          send_data("#{@stats.spushv_protection}\r\n")
+        elsif s.length == 2
+          @stats.spushv_protection = (s[1] == 'true')
+          send_data("#{@stats.spushv_protection}\r\n")
         else
-          send_data("SERVER_ERROR #{res}\r\n")
+          send_data("COMMAND ERROR\r\n")
         end
-      rescue => e
-        @log.error("#{e}\n#{$@}")
       end
 
       # spushv <hash-name> <vnode-id>
@@ -37,8 +28,20 @@ module Roma
       #  |              [<end of dump>]->|
       #  |<-['STORED'\r\n]               |
       def ev_spushv(s)
+        if s.length != 3
+          @log.error("#{__method__}:wrong number of arguments(#{s})")
+          return send_data("CLIENT_ERROR Wrong number of arguments.\r\n")
+        end
+        if @stats.spushv_protection
+          @log.info("#{__method__}:In spushv_protection")
+          return send_data("SERVER_ERROR In spushv_protection.\r\n")          
+        end
+        @stats.run_receive_a_vnode["#{s[1]}_#{s[2]}"] = true
+
+        $roma.stop_clean_up
+
         send_data("READY\r\n")
-        @stats.run_receive_a_vnode = true
+
         count = rcount = 0
         @log.debug("#{__method__}:#{s.inspect} received.")
         loop {
@@ -70,20 +73,27 @@ module Roma
             end
           end
         }
-        send_data("STORED\r\n")
-        @log.debug("#{__method__}:#{s[2]} #{count} keys loaded. #{rcount} keys rejected.")
+        if @stats.spushv_protection
+          @log.info("#{__method__}:Canceled because of spushv_protection")
+          send_data("CANCELED\r\n")
+        else
+          send_data("STORED\r\n")
+        end
+        @log.debug("#{__method__}:#{s[1]}_#{s[2]} #{count} keys loaded.")
+        @log.debug("#{__method__}:#{s[1]}_#{s[2]} #{rcount} keys rejected.") if rcount > 0
       rescue Storage::StorageException => e
         @log.error("#{e.inspect} #{$@}")
         close_connection
         if Config.const_defined?(:STORAGE_EXCEPTION_ACTION) &&
             Config::STORAGE_EXCEPTION_ACTION == :shutdown
-          @log.error("Romad will stop")
+          @log.error("#{__method__}:Romad will be stop.")
           @stop_event_loop = true
         end
       rescue => e
         @log.error("#{e} #{$@}")
       ensure
-        @stats.run_receive_a_vnode = false
+        @stats.run_receive_a_vnode.delete("#{s[1]}_#{s[2]}") if s.length == 3
+        @stats.last_clean_up = Time.now
       end      
 
       # reqpushv <vnode-id> <node-id> <is primary?>
@@ -95,7 +105,7 @@ module Roma
           send_data("CLIENT_ERROR usage:reqpushv vnode-id node-id primary-flag(true/false)\r\n")
           return
         end
-        if @stats.run_iterate_storage == true
+        if(@stats.run_iterate_storage || @stats.run_join || @stats.run_balance)
           @log.warn("reqpushv rejected:#{s}")
           send_data("REJECTED\r\n")
           return
@@ -123,28 +133,6 @@ module Roma
         false
       end
 
-      def em_receive_dump(hname, len)
-        dmp = read_bytes(len)
-        read_bytes(2)
-        if gets == "END\r\n"
-          if @storages.key?(hname)
-            n = @storages[hname].load(dmp)
-            @log.debug("#{dmp.length} bytes received.(#{n} keys loaded.)")
-            return true
-          else
-            @log.error("receive_dump:@storages[#{hname}] dose not found.")
-            return "@storages[#{hname}] dose not found."
-          end
-        else
-          @log.error("receive_dump:END was not able to be received.")
-          return "END was not able to be received."
-        end
-      rescue =>e
-        @log.error("#{e}\n#{$@}")
-        "#{e}"
-      end
-      private :em_receive_dump
-
     end # module VnodeCommandReceiver
 
   end # module Command

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

@@ -63,6 +63,8 @@ module Roma
     # typical value is 5 days
     STORAGE_DELMARK_EXPTIME = 60 * 60 * 24 * 5
 
+    STORAGE_CLEAN_UP_INTERVAL = 60 * 5
+
     # data copy setting
     DATACOPY_STREAM_COPY_WAIT_PARAM = 0.001
 

data/ruby/server/lib/roma/event/handler.rb

@@ -192,7 +192,12 @@ module Roma
       end
 
       def pop(size)
-        return '' if size == 0
+        if size == 0
+          return ''
+        elsif size < 0
+          return nil
+        end
+
         if @rbuf.size >= size
           r = @rbuf[0..size-1]
           @rbuf = @rbuf[size..-1]

data/ruby/server/lib/roma/plugin/plugin_alist.rb

@@ -25,6 +25,7 @@ module Roma
           v = Marshal.load(ddata)[0]
           return send_data("END\r\n") if v.length <= s[2].to_i
           ret = v.at(s[2].to_i)
+          ret = "" unless ret
           return send_data("VALUE #{s[1]} 0 #{ret.length}\r\n#{ret}\r\nEND\r\n")
         else
           return send_data("END\r\n")
@@ -1248,8 +1249,20 @@ module Roma
       #  |                    [<end of dump>]->|
       #  |<-['STORED'\r\n]                     |
       def ev_alist_spushv(s)
+        if s.length != 3
+          @log.error("#{__method__}:wrong number of arguments(#{s})")
+          return send_data("CLIENT_ERROR Wrong number of arguments.\r\n")
+        end
+        if @stats.spushv_protection
+          @log.info("#{__method__}:In spushv_protection")
+          return send_data("SERVER_ERROR In spushv_protection.\r\n")          
+        end
+        @stats.run_receive_a_vnode["#{s[1]}_#{s[2]}"] = true
+
+        $roma.stop_clean_up
+
         send_data("READY\r\n")
-        @stats.run_receive_a_vnode = true
+
         count = 0
         loop {
           context_bin = read_bytes(20, 100)
@@ -1268,12 +1281,25 @@ module Roma
             count += 1 if @storages[s[1]].load_stream_dump(vn, last, clk, expt, k, v)
           end
         }
-        send_data("STORED\r\n")
+        if @stats.spushv_protection
+          @log.info("#{__method__}:Canceled because of spushv_protection")
+          send_data("CANCELED\r\n")
+        else
+          send_data("STORED\r\n")
+        end
         @log.debug("alist #{count} keys loaded.")
+      rescue Storage::StorageException => e
+        @log.error("#{e.inspect} #{$@}")
+        close_connection
+        if Config.const_defined?(:STORAGE_EXCEPTION_ACTION) &&
+            Config::STORAGE_EXCEPTION_ACTION == :shutdown
+          @log.error("#{__method__}:Romad will stop")
+          @stop_event_loop = true
+        end
       rescue => e
         @log.error("#{e}\n#{$@}")
       ensure
-        @stats.run_receive_a_vnode = false
+        @stats.run_receive_a_vnode.delete("#{s[1]}_#{s[2]}") if s.length == 3
       end      
 
       private

data/ruby/server/lib/roma/plugin/plugin_storage.rb

@@ -16,6 +16,11 @@ module Roma
 
       # get <key>*\r\n
       def ev_get(s)
+        if s.length < 2
+          @log.error("get:wrong number of arguments(#{s})")
+          return send_data("CLIENT_ERROR Wrong number of arguments.\r\n")
+        end
+
         return ev_gets(s) if s.length > 2
 
         key,hname = s[1].split("\e")
@@ -111,6 +116,11 @@ module Roma
 
       # delete <key> [<time>] [noreply]\r\n
       def ev_delete(s)
+        if s.length < 2
+          @log.error("delete:wrong number of arguments(#{s})")
+          return send_data("CLIENT_ERROR Wrong number of arguments.\r\n")
+        end
+
         key,hname = s[1].split("\e")
         hname ||= @defhash
         d = Digest::SHA1.hexdigest(key).hex % @rttable.hbits
@@ -490,16 +500,27 @@ module Roma
       end
 
       def set(fnc,s)
+        if s.length != 5
+          @log.error("set:wrong number of arguments(#{s})")
+          return send_data("CLIENT_ERROR Wrong number of arguments.\r\n")
+        end
+
+        bytes = s[4].to_i
+        if bytes < 0
+          @log.error("set:wrong key size(#{s})")
+          return send_data("CLIENT_ERROR Wrong key size.\r\n")
+        end
+
         key,hname = s[1].split("\e")
         hname ||= @defhash
         d = Digest::SHA1.hexdigest(key).hex % @rttable.hbits
-        v = read_bytes(s[4].to_i)
+        v = read_bytes(bytes)
         read_bytes(2)
         vn = @rttable.get_vnode_id(d)
         nodes = @rttable.search_nodes_for_write(vn)
         if nodes[0] != @nid
           @log.warn("forward #{fnc} key=#{key} vn=#{vn} to #{nodes[0]}")
-          res = send_cmd(nodes[0],"f#{fnc} #{s[1]} #{d} #{s[3]} #{v.length}\r\n#{v}\r\n")
+          res = send_cmd(nodes[0],"f#{fnc} #{s[1]} #{d} #{s[3]} #{s[4]}\r\n#{v}\r\n")
           if res == nil || res.start_with?("ERROR")
             return send_data("SERVER_ERROR Message forward failed.\r\n")
           end

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

@@ -53,6 +53,10 @@ module Roma
       start_wb_process
       timer
 
+      if @stats.join_ap
+        AsyncProcess::queue.push(AsyncMessage.new('start_join_process'))
+      end
+
       # select a kind of system call
       if Config.const_defined?(:CONNECTION_USE_EPOLL) && Config::CONNECTION_USE_EPOLL
         @log.info("use an epoll")
@@ -133,6 +137,15 @@ module Roma
 
     def daemon?; @stats.daemon; end
 
+    def stop_clean_up
+      @stats.last_clean_up = Time.now
+      while(@stats.run_storage_clean_up)
+        @log.info("Storage clean up process will be stop.")
+        @storages.each_value{|st| st.stop_clean_up}
+        sleep 0.005
+      end
+    end
+
     private
 
     def initialize_stats
@@ -144,7 +157,10 @@ module Roma
       end
       if Config.const_defined?(:WB_COMMAND_MAP)
         @stats.wb_command_map = Config::WB_COMMAND_MAP
-      end      
+      end
+      if Config.const_defined?(:STORAGE_CLEAN_UP_INTERVAL)
+        @stats.clean_up_interval = Config::STORAGE_CLEAN_UP_INTERVAL
+      end
     end
 
     def initialize_connection
@@ -463,14 +479,6 @@ module Roma
       nil      
     end
 
-    def acquire_vnodes
-      return if @stats.run_acquire_vnodes || @rttable.nodes.length < 2
-
-      if @rttable.vnode_balance(@stats.ap_str)==:less
-        Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_acquire_vnodes_process'))
-      end
-    end
-
     def timer
       t = Thread.new do
         loop do
@@ -495,10 +503,9 @@ module Roma
         nodes_check(nodes)
       end
 
-      if (@stats.run_acquire_vnodes || @stats.run_recover) &&
+      if (@stats.run_join || @stats.run_recover || @stats.run_balance) &&
           @stats.run_storage_clean_up
-        @storages.each_value{|st| st.stop_clean_up}
-        @log.info("stop a storage clean up process")
+        stop_clean_up
       end
     end
 
@@ -522,15 +529,14 @@ module Roma
         start_sync_routing_process
       end
 
-      if @stats.join_ap || @stats.enabled_vnodes_balance
-        acquire_vnodes
-      end
-
       if (@rttable.enabled_failover &&
           @stats.run_storage_clean_up == false &&
-          @stats.run_acquire_vnodes == false &&
+          @stats.run_balance == false &&
           @stats.run_recover == false &&
-          @stats.run_iterate_storage == false)
+          @stats.run_iterate_storage == false &&
+          @stats.run_join == false &&
+          @stats.run_receive_a_vnode.empty? &&
+          @stats.do_clean_up?)
         Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_storage_clean_up_process'))
       end
 
@@ -570,7 +576,7 @@ module Roma
     end
 
     def start_sync_routing_process
-      return if @stats.run_acquire_vnodes || @stats.run_recover || @stats.run_sync_routing
+      return if @stats.run_join || @stats.run_recover || @stats.run_balance || @stats.run_sync_routing
 
       nodes = @rttable.nodes
       return if nodes.length == 1 && nodes[0] == @stats.ap_str
@@ -612,7 +618,7 @@ module Roma
     end    
 
     def routing_hash_comparison(nid,id='0')
-      return :skip if @stats.run_acquire_vnodes || @stats.run_recover
+      return :skip if @stats.run_join || @stats.run_recover || @stats.run_balance
       
       h = async_send_cmd(nid,"mklhash #{id}\r\n")
       if h && h.start_with?("ERROR") == false && @rttable.mtree.get(id) != h

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

@@ -1,10 +1,13 @@
 require 'roma/routing/rttable'
+require 'roma/routing/random_partitioner'
 
 module Roma
   module Routing
 
     class ChurnbasedRoutingTable < RoutingTable
 
+      include Routing::RandomPartitioner
+
       attr :fname
       attr :log_fd
       attr :log_name
@@ -97,6 +100,23 @@ module Roma
         @rd.nodes.length >= @rd.rn
       end
 
+      def can_i_release?(ap_str, rep_host)
+        buf = self.nodes
+        buf.delete(ap_str)
+        hosts = []
+        
+        unless rep_host
+          buf.each{ |node|
+            host = node.split(/[:_]/)[0]
+            hosts << host unless hosts.include?(host)
+          }
+        else
+          hosts = buf
+        end
+        
+        hosts.length < @rd.rn
+      end
+
       # Retuens the list of losted-data vnode newer than argument time.
       def search_lost_vnodes(t)
         ret = []
@@ -308,7 +328,7 @@ module Roma
           end
         }
 
-        @log.debug("#{__FILE__}:#{__LINE__}:n=#{n} pcount=#{pcount} scount=#{scount}")
+        @log.debug("#{__method__}:n=#{n} pcount=#{pcount} scount=#{scount}")
 
         if pcount > n
           return :over
@@ -318,6 +338,13 @@ module Roma
         :even
       end
 
+      def has_node?(ap_str)
+        self.each_vnode do |vn, nids|
+          return true if nids.include?(ap_str)
+        end
+        false
+      end
+
     end # class ChurnbasedRoutingTable
 
   end # module Routing