roma 0.8.2 → 0.8.10

data/bin/recoverlost_alist

@@ -1,8 +0,0 @@
-#!/usr/bin/env ruby
-
-path =  File.dirname(File.expand_path($PROGRAM_NAME))
-$LOAD_PATH << path + "/../lib"
-$LOAD_PATH << path  + "/../../commons/lib"
-$LOAD_PATH << path  + "/../../client/lib"
-
-require 'roma/tools/recoverlost_alist'

data/bin/romad

@@ -1,7 +0,0 @@
-#!/usr/bin/env ruby
-
-path =  File.dirname(File.expand_path($PROGRAM_NAME))
-$LOAD_PATH << path + "/../lib"
-$LOAD_PATH << path  + "/../../commons/lib"
-
-require 'roma/romad'

data/lib/roma/command/mh_command_receiver.rb

@@ -1,117 +0,0 @@
-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

@@ -1,287 +0,0 @@
-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

data/lib/roma/event/handler.rb

@@ -1,159 +0,0 @@
-# 
-# File: handler.rb
-#
-require 'eventmachine'
-require 'roma/event/con_pool'
-require 'roma/logging/rlogger'
-require 'socket'
-
-module Roma
-  module Event
-
-    class Handler < EventMachine::Connection
-      @@ev_list={}
-
-      attr :stop_event_loop
-      attr :connected
-      attr :fiber
-      attr :rbuf
-
-      attr :storages
-      attr :rttable
-      attr_accessor :timeout
-      attr_reader :lastcmd
-
-      def initialize(storages, rttable)
-        @rbuf=''
-        unless has_event?
-          public_methods.each{|m|
-            if m.to_s.start_with?('ev_')
-              add_event(m.to_s[3..-1],m)
-            end
-          }
-        end
-
-        @storages = storages
-        @rttable = rttable
-        @timeout = 10
-        @log = Roma::Logging::RLogger.instance
-      end
-
-      def post_init
-        @addr = Socket.unpack_sockaddr_in(get_peername)
-        @log.info("Connected from #{@addr[1]}:#{@addr[0]}")
-        @connected = true
-        @fiber = Fiber.new { dispatcher }
-      end
-
-      def receive_data(data)
-        @rbuf << data
-        @fiber.resume
-      rescue =>e
-        @log.error("#{__FILE__}:#{__LINE__}:#{@addr[1]}:#{@addr[0]} #{e.inspect} #{$@}")
-      end
-
-      def unbind
-        @connected=false
-        @fiber.resume
-        EventMachine::stop_event_loop if @stop_event_loop
-        @log.info("Disconnected from #{@addr[1]}:#{@addr[0]}")
-      rescue =>e
-        @log.warn("#{__FILE__}:#{__LINE__}:#{@addr[1]}:#{@addr[0]} #{e.inspect} #{$@}")
-      end
-
-      protected
-
-      def has_event?
-        @@ev_list.length!=0
-      end
-
-      def add_event(c,m)
-        @@ev_list[c]=m
-      end
-
-      def exit
-        EventMachine::stop_event_loop
-      end
-
-      private
-
-      def get_connection(ap)
-        con=Roma::Event::EMConPool::instance.get_connection(ap)
-        con.fiber=@fiber
-        con
-      end
-
-      def return_connection(ap,con)
-        Roma::Event::EMConPool.instance.return_connection(ap,con)
-      end
-
-      def dispatcher
-        while(@connected) do
-          next unless s=gets
-          s=s.chomp.split(/ /)
-          if s[0] && @@ev_list.key?(s[0].downcase)
-            send(@@ev_list[s[0].downcase],s)
-            @lastcmd=s
-          elsif s.length==0
-            next
-          elsif s[0]=='!!'
-            send(@@ev_list[@lastcmd[0].downcase],@lastcmd)
-          else
-            @log.warn("command error:#{s}")
-            send_data("ERROR\r\n")
-            close_connection_after_writing
-          end
-        end
-      rescue =>e
-        @log.warn("#{__FILE__}:#{__LINE__}:#{@addr[1]}:#{@addr[0]} #{e} #{$@}")
-        close_connection
-      end
-
-      def pop(size)
-        if @rbuf.size >= size
-          r = @rbuf[0..size-1]
-          @rbuf = @rbuf[size..-1]
-          r
-        else
-          nil
-        end
-      end
-
-      def read_bytes(size, mult = 1)
-        t=Time.now.to_i
-        while(@connected) do
-          d = pop(size)
-          if d
-            return d
-          else
-            remain = size - @rbuf.size
-            Fiber.yield(remain)
-            if Time.now.to_i - t > @timeout * mult
-              @log.warn("#{__FILE__}:#{__LINE__}:#{@addr[1]}:#{@addr[0]} read_bytes time out");
-              close_connection
-              return nil
-            end
-          end
-        end
-        nil
-      end
-
-      def gets
-        while(@connected) do
-          if idx=@rbuf.index("\n")
-            return pop(idx+1)
-          else
-            Fiber.yield(@rbuf.size)
-          end
-        end
-        nil
-      end
-
-      def detach_socket
-        @connected = false
-        Socket::for_fd(detach)
-      end
-    end
-
-  end
-end