roma 0.8.2

data/lib/roma/command/bg_command_receiver.rb

@@ -0,0 +1,188 @@
+# -*- coding: utf-8 -*-
+require 'roma/async_process'
+require 'roma/messaging/con_pool'
+require 'roma/command/vn_command_receiver'
+
+module Roma
+  module Command
+
+    module BackgroundCommandReceiver
+      include VnodeCommandReceiver
+
+      def ev_balance(s)
+        res = broadcast_cmd("rbalance\r\n")
+        if @stats.run_recover==false && 
+            @stats.run_acquire_vnodes == false &&
+            @rttable.vnode_balance(@stats.ap_str)==:less
+          Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_acquire_vnodes_process'))
+          res[@stats.ap_str] = 'STARTED'
+        else
+          res[@stats.ap_str] = 'SERVER_ERROR Not unbalance or Balance/Recover/Sync 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 &&
+            @rttable.vnode_balance(@stats.ap_str)==:less
+          Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('start_acquire_vnodes_process'))
+          send_data("STARTED\r\n")
+        else
+          send_data("SERVER_ERROR Not unbalance or Balance/Recover/Sync process is already running.\r\n")
+        end
+      end
+
+      def ev_release(s)
+        if @stats.run_recover==false && 
+            @stats.run_acquire_vnodes == 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")
+        end
+      end
+
+      # recover [-r]
+      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]))
+            res[@nid] = "STARTED"
+          else
+            res[@nid] = "SERVER_ERROR Recover/Sync process is already running."
+          end
+          send_data("#{res}\r\n")
+        else
+          send_data("SERVER_ERROR nodes num < redundant num\r\n")
+        end
+      end
+
+      # rrecover [-r|-s]
+      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]))
+            send_data("STARTED\r\n")
+          else
+            send_data("SERVER_ERROR Recover process is already running.\r\n")
+          end
+        else
+          send_data("SERVER_ERROR nodes num < redundant num\r\n")
+        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
+end # module Roma

data/lib/roma/command/mh_command_receiver.rb

@@ -0,0 +1,117 @@
+require 'roma/stats'
+require 'roma/command/util_command_receiver'
+
+module Roma
+  module Command
+
+    module MultiHashCommandReceiver
+
+      # defhash hashname
+      def ev_defhash(s)
+        if s.length!=2
+          send_data("CLIENT_ERROR usage:defhash hashname\r\n")
+          return
+        end
+        @defhash=s[1]
+        send_data("STORED\r\n")
+      end
+
+      # hashlist
+      def ev_hashlist(s)
+        ret=''
+        @storages.each_key{|hn| ret << hn << ' ' }
+        send_data("#{ret[0...-1]}\r\n")
+      end
+      
+      # createhash hashname
+      def ev_createhash(s)
+        if s.length != 2
+          send_data("CLIENT_ERROR usage:createhash hashname\r\n")
+          return
+        end
+        res = broadcast_cmd("rcreatehash #{s[1]}\r\n")
+        res[@stats.ap_str] = createhash(s[1])
+        send_data("#{res.inspect}\r\n")
+      end
+
+      # rcreatehash hashname
+      def ev_rcreatehash(s)
+        if s.length != 2
+          send_data("CLIENT_ERROR usage:createhash hashname\r\n")
+          return
+        end
+        send_data("#{createhash(s[1])}\r\n")
+      end
+      
+      def createhash(hname)
+        if @storages.key?(hname)
+          return "SERVER_ERROR #{hname} already exists."
+        end
+        st = Roma::Config::STORAGE_CLASS.new
+        st.storage_path = "#{@stats.ap_str}/#{hname}"
+        st.vn_list = @rttable.vnodes
+        st.divnum = Roma::Config::STORAGE_DIVNUM
+        st.option = Roma::Config::STORAGE_OPTION
+        @storages[hname] = st
+        @storages[hname].opendb
+        @log.info("createhash #{hname}")
+        return "CREATED"
+      rescue =>e
+        @log.error("#{e}")
+      end
+      private :createhash
+
+      # deletehash hashname
+      def ev_deletehash(s)
+        if s.length != 2
+          send_data("CLIENT_ERROR usage:deletehash hashname\r\n")
+          return
+        end
+        res = broadcast_cmd("rdeletehash #{s[1]}\r\n")
+        res[@stats.ap_str] = deletehash(s[1])
+        send_data("#{res.inspect}\r\n")        
+      end
+
+      # rdeletehash hashname
+      def ev_rdeletehash(s)
+        if s.length != 2
+          send_data("CLIENT_ERROR usage:rdeletehash hashname\r\n")
+          return
+        end
+        send_data("#{deletehash(s[1])}\r\n")        
+      end
+
+      def deletehash(hname)
+        unless @storages.key?(hname)
+          return "SERVER_ERROR #{hname} dose not exists."
+        end
+        if hname == 'roma'
+          return "SERVER_ERROR the hash name of 'roma' can't delete."
+        end
+        st = @storages[hname]
+        @storages.delete(hname)
+        st.closedb
+        rm_rf("#{@stats.ap_str}/#{hname}")
+        @log.info("deletehash #{hname}")
+        return "DELETED"
+      rescue =>e
+        @log.error("#{e}")
+      end
+      private :deletehash
+      
+      # looked like a "rm -rf" command
+      def rm_rf(fname)
+        return unless File.exists?(fname)
+        if File::directory?(fname)
+          Dir["#{fname}/*"].each{|f| rm_rf(f) }
+          Dir.rmdir(fname)
+        else
+          File.delete(fname)
+        end
+      end
+      private :rm_rf
+
+    end # MultiHashCommandReceiver
+
+  end # module Command
+end # module Roma

data/lib/roma/command/receiver.rb

@@ -0,0 +1,287 @@
+require 'roma/stats'
+require 'roma/version'
+require 'roma/event/handler'
+require 'roma/messaging/con_pool'
+require 'roma/command/bg_command_receiver'
+require 'roma/command/rt_command_receiver'
+require 'roma/command/st_command_receiver'
+require 'roma/command/util_command_receiver'
+require 'roma/command/mh_command_receiver'
+
+module Roma
+  module Command
+
+    class Receiver < Roma::Event::Handler
+
+      include BackgroundCommandReceiver
+      include RoutingCommandReceiver
+      include StorageCommandReceiver
+      include UtilCommandReceiver
+      include MultiHashCommandReceiver
+
+      def initialize(storages, rttable)
+        super(storages, rttable)
+        @stats = Roma::Stats.instance
+        @nid = @stats.ap_str
+        @defhash = 'roma'
+      end
+
+      # balse [reason]
+      def ev_balse(s)
+        send_data("Are you sure?(yes/no)\r\n")
+        if gets != "yes\r\n"
+          close_connection_after_writing
+          return
+        end
+
+        if s.length == 2
+          @log.info("Receive a balse #{s[1]}")
+        else
+          @log.info("Receive a balse command.")
+        end
+        @rttable.enabled_failover = false
+        res = broadcast_cmd("rbalse\r\n")
+        send_data("#{res.inspect}\r\n")
+        close_connection_after_writing
+        @stop_event_loop = true
+      end
+
+      # rbalse [reason]
+      def ev_rbalse(s)
+        if s.length == 2
+          @log.info("Receive a rbalse #{s[1]}")
+        else
+          @log.info("Receive a rbalse command.")
+        end
+        @rttable.enabled_failover = false
+        send_data("BYE\r\n")
+        close_connection_after_writing
+        @stop_event_loop = true
+      end
+
+      # version
+      def ev_version(s)
+        send_data("VERSION #{Roma::VERSION}\r\n")
+      end
+
+      # quit
+      def ev_quit(s)
+        close_connection
+      end
+
+      def ev_whoami(s)
+        send_data("#{@stats.name}\r\n")
+      end
+
+      # stats [regexp]
+      def ev_stats(s); ev_stat(s); end
+
+      # stat [regexp]
+      def ev_stat(s)
+        regexp = s[1] if s.length == 2
+        h = {}
+        h['version'] = Roma::VERSION
+        send_stat_result(nil,h,regexp)
+        send_stat_result(nil,Roma::Config.get_stat,regexp)
+        send_stat_result(nil,@stats.get_stat,regexp)
+        @storages.each{|hname,st|
+          send_stat_result("storages[#{hname}].",st.get_stat,regexp)
+        }
+        send_stat_result(nil,$roma.wb_get_stat,regexp)
+        send_stat_result(nil,@rttable.get_stat(@stats.ap_str),regexp)
+        send_data("END\r\n")
+      end
+
+      def send_stat_result(prefix,h,regexp = nil)
+        h.each{|k,v|         
+          if prefix
+            key = "#{prefix}#{k}"
+          else
+            key = "#{k}"
+          end
+          if regexp
+            send_data("#{key} #{v}\r\n") if key =~ /#{regexp}/
+          else
+            send_data("#{key} #{v}\r\n")
+          end
+        }
+      end
+      private :send_stat_result
+
+      # writebehind_rotate [hash_name]
+      def ev_writebehind_rotate(s)
+        if s.length < 2
+          return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
+        end
+        res = broadcast_cmd("rwritebehind_rotate #{s[1]}\r\n")
+
+        if $roma.wb_rotate(s[1])
+          res[@stats.ap_str] = "ROTATED"
+        else
+          res[@stats.ap_str] = "NOT_OPEND"
+        end
+        send_data("#{res}\r\n")
+      end
+
+      # rwritebehind_rotate [hash_name]
+      def ev_rwritebehind_rotate(s)
+        if s.length < 2
+          return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
+        end
+        if $roma.wb_rotate(s[1])
+          send_data("ROTATED\r\n")
+        else
+          send_data("NOT_OPEND\r\n")
+        end
+      end
+
+      # writebehind_get_path [hash_name]
+      def ev_writebehind_get_path(s)
+        if s.length < 2
+          return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
+        end
+        res = broadcast_cmd("rwritebehind_get_path #{s[1]}\r\n")
+        
+        ret = $roma.wb_get_path(s[1])
+        res[@stats.ap_str] = ret
+
+        send_data("#{res}\r\n")
+      end
+
+      # rwritebehind_get_path [hash_name]
+      def ev_rwritebehind_get_path(s)
+        if s.length < 2
+          return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
+        end
+        
+        ret = $roma.wb_get_path(s[1])
+        send_data("#{ret}\r\n")
+      end
+      
+      # writebehind_get_current_file [hash_name]
+      def ev_writebehind_get_current_file(s)
+        if s.length < 2
+          return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
+        end
+        res = broadcast_cmd("rwritebehind_get_current_file #{s[1]}\r\n")
+
+        ret = $roma.wb_get_current_file_path(s[1])
+        if ret
+          res[@stats.ap_str] = ret
+        else
+          res[@stats.ap_str] = "NOT_OPEND"
+        end
+        send_data("#{res}\r\n")
+      end
+
+      # rwritebehind_get_current_file [hash_name]
+      def ev_rwritebehind_get_current_file(s)
+        if s.length < 2
+          return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
+        end
+        ret = $roma.wb_get_current_file_path(s[1])
+        if ret
+          send_data("#{ret}\r\n")
+        else
+          send_data("NOT_OPEND\r\n")
+        end
+      end
+
+      # dcnice command is setting priority for a data-copy thread.
+      # a niceness of 1 is the highest priority and 5 is the lowest priority.
+      # dcnice <priority:1 to 5>
+      def ev_dcnice(s)
+        if s.length < 2
+          return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
+        end
+        res = broadcast_cmd("rdcnice #{s[1]}\r\n")
+        res[@stats.ap_str] = dcnice(s[1].to_i)
+        send_data("#{res}\r\n")
+      end
+
+      def ev_rdcnice(s)
+        if s.length < 2
+          return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
+        end
+
+        send_data("#{dcnice(s[1].to_i)}\r\n")
+      end
+      
+      def ev_restart(s)
+        res = broadcast_cmd("rrestart\r\n")
+        $roma.eventloop = true
+        EventMachine::stop_event_loop
+        res[@stats.ap_str] = "RESTARTED"
+        send_data("#{res}\r\n")
+      end
+
+      def ev_rrestart(s)
+        $roma.eventloop = true
+        EventMachine::stop_event_loop
+        send_data("RESTARTED\r\n")
+      end
+
+      # set_log_level [ 'debug' | 'info' | 'warn' | 'error' ] 
+      def ev_set_log_level(s)
+        if s.length < 2
+          return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
+        end
+
+        case s[1].downcase
+        when 'debug'
+          @log.level = Roma::Logging::RLogger::Severity::DEBUG
+        when 'info'
+          @log.level = Roma::Logging::RLogger::Severity::INFO
+        when 'warn'
+          @log.level = Roma::Logging::RLogger::Severity::WARN
+        when 'error'
+          @log.level = Roma::Logging::RLogger::Severity::ERROR
+        else
+          return send_data("CLIENT_ERROR no match log-level string\r\n")
+        end
+        send_data("STORED\r\n")
+      end
+
+      private 
+
+      def dcnice(p)
+        case(p)
+        when 1 # highest priority
+          @stats.stream_copy_wait_param = 0.001
+          @storages.each_value{|st|
+            st.each_vn_dump_sleep = 0.001
+            st.each_vn_dump_sleep_count = 1000
+          }
+        when 2
+          @stats.stream_copy_wait_param = 0.005
+          @storages.each_value{|st|
+            st.each_vn_dump_sleep = 0.005
+            st.each_vn_dump_sleep_count = 100
+          }
+        when 3 # default priority
+          @stats.stream_copy_wait_param = 0.01
+          @storages.each_value{|st|
+            st.each_vn_dump_sleep = 0.001
+            st.each_vn_dump_sleep_count = 10
+          }
+        when 4
+          @stats.stream_copy_wait_param = 0.01
+          @storages.each_value{|st|
+            st.each_vn_dump_sleep = 0.005
+            st.each_vn_dump_sleep_count = 10
+          }
+        when 5 # lowest priority
+          @stats.stream_copy_wait_param = 0.01
+          @storages.each_value{|st|
+            st.each_vn_dump_sleep = 0.01
+            st.each_vn_dump_sleep_count = 10
+          }
+        else
+          return "CLIENT_ERROR You sholud input a priority from 1 to 5."
+        end
+        "STORED"
+      end
+    end # class Receiver < Roma::Event::Handler
+
+  end # module Command
+end # module Roma