roma 0.8.2 → 0.8.10

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

@@ -0,0 +1,64 @@
+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/util_command_receiver'
+require 'roma/command/mh_command_receiver'
+require 'roma/command/sys_command_receiver'
+
+module Roma
+  module Command
+
+    class Receiver < Roma::Event::Handler
+
+      include BackgroundCommandReceiver
+      include RoutingCommandReceiver
+      include UtilCommandReceiver
+      include MultiHashCommandReceiver
+      include SystemCommandReceiver
+
+      def initialize(storages, rttable)
+        super(storages, rttable)
+        @stats = Roma::Stats.instance
+        @nid = @stats.ap_str
+        @defhash = 'roma'
+      end
+
+      def self.mk_starting_evlist
+        Event::Handler.ev_list.clear
+        each_system_commands{|m|
+          Event::Handler.ev_list[m.to_s[3..-1]] = m
+          Event::Handler.system_commands[m.to_s[3..-1]] = nil
+        }
+      end
+
+      def self.each_system_commands
+        methods = RoutingCommandReceiver::public_instance_methods
+        methods << BackgroundCommandReceiver::public_instance_methods
+        methods << SystemCommandReceiver::public_instance_methods
+
+        if Receiver::public_instance_methods.include?(:ev_eval)
+          methods << :ev_eval
+        end
+        methods.flatten.each{|m|
+           yield m if m.to_s.start_with?('ev_')
+        }
+      end
+
+      def self.mk_evlist
+        each_system_commands{|m|
+          Event::Handler.system_commands[m.to_s[3..-1]] = nil
+        }
+        Receiver::public_instance_methods.each{|m|
+          if m.to_s.start_with?('ev_')
+            Event::Handler.ev_list[m.to_s[3..-1]] = m
+          end
+        }
+      end
+
+    end # class Receiver < Roma::Event::Handler
+
+  end # module Command
+end # module Roma

data/{lib → ruby/server/lib}/roma/command/rt_command_receiver.rb

@@ -34,7 +34,7 @@ module Roma
         send_data("CREATED\r\n")
       end
 
-      # routingdump [yaml|json|yamlbytes]\r\n
+      # routingdump [yaml|json|yamlbytes|bin]\r\n
       def ev_routingdump(s)
         if s.length == 1
           dmp = @rttable.dump
@@ -48,6 +48,11 @@ module Roma
         elsif s[1] == 'yamlbytes'
           dmp = @rttable.dump_yaml
           send_data("#{dmp.length + 7}\r\nEND\r\n")
+        elsif s[1] == 'bin'
+          dmp = @rttable.dump_binary
+          send_data("#{dmp.length}\r\n#{dmp}\r\nEND\r\n")
+        else
+          send_data("CLIENT_ERROR\r\n")
         end
       end
 

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

@@ -0,0 +1,609 @@
+
+module Roma
+  module Command
+
+    module SystemCommandReceiver
+
+      # 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
+
+      # shutdown_instance [node-id]
+      def ev_shutdown_instance(s)
+        if s.length != 2
+          send_data("usage:shutdown_instance [node-id]\r\n")
+        else
+          if s[1] == @stats.ap_str
+            @rttable.enabled_failover = false
+            send_data("BYE\r\n")
+            @stop_event_loop = true
+            close_connection_after_writing
+          else
+            send_data("invalid [node-id]\r\n")
+          end
+        end
+      end
+
+      # version
+      def ev_version(s)
+        send_data("VERSION ROMA-#{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,get_config_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_stat_result(nil,conn_get_stat,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
+        @rttable.enabled_failover = false
+        Messaging::ConPool.instance.close_all
+        Event::EMConPool::instance.close_all
+        EventMachine::stop_event_loop
+        res[@stats.ap_str] = "RESTARTED"
+        send_data("#{res}\r\n")
+      end
+
+      def ev_rrestart(s)
+        $roma.eventloop = true
+        @rttable.enabled_failover = false
+        Messaging::ConPool.instance.close_all
+        Event::EMConPool::instance.close_all
+        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
+
+      # out <key> <vn>
+      def ev_out(s)
+        key,hname = s[1].split("\e")
+        hname ||= @defhash
+        if s.length >= 3
+          vn = s[2].to_i
+        else
+          d = Digest::SHA1.hexdigest(key).hex % @rttable.hbits
+          vn = @rttable.get_vnode_id(d)
+        end
+        res = @storages[hname].out(vn, key, 0)
+        @stats.out_message_count += 1
+        unless res
+          return send_data("NOT_DELETED\r\n")
+        end
+        send_data("DELETED\r\n")
+      end
+
+      # rset <key> <hash value> <timelimit> <length>
+      # "set" means "store this data".
+      # <command name> <key> <digest> <exptime> <bytes> [noreply]\r\n
+      # <data block>\r\n
+      def ev_rset(s)
+        key,hname = s[1].split("\e")
+        hname ||= @defhash
+        d = s[2].to_i
+        d = Digest::SHA1.hexdigest(key).hex % @rttable.hbits if d == 0
+        data = read_bytes(s[5].to_i)
+        read_bytes(2)
+        vn = @rttable.get_vnode_id(d)
+        unless @storages.key?(hname)
+          send_data("SERVER_ERROR #{hname} dose not exists.\r\n")
+          return
+        end
+        if @storages[hname].rset(vn, key, d, s[3].to_i, s[4].to_i, data)
+          send_data("STORED\r\n")
+        else
+          @log.error("rset NOT_STORED:#{@storages[hname].error_message} #{vn} #{s[1]} #{d} #{s[3]} #{s[4]}")
+          send_data("NOT_STORED\r\n")
+        end
+        @stats.redundant_count += 1
+      end
+
+      # <command name> <key> <digest> <exptime> <bytes> [noreply]\r\n
+      # <compressed data block>\r\n
+      def ev_rzset(s)
+        key,hname = s[1].split("\e")
+        hname ||= @defhash
+        d = s[2].to_i
+        d = Digest::SHA1.hexdigest(key).hex % @rttable.hbits if d == 0
+        zdata = read_bytes(s[5].to_i)
+        read_bytes(2)
+        vn = @rttable.get_vnode_id(d)
+        unless @storages.key?(hname)
+          send_data("SERVER_ERROR #{hname} dose not exists.\r\n")
+          return
+        end
+
+        data = Zlib::Inflate.inflate(zdata)
+# @log.debug("data = #{data}")
+        if @storages[hname].rset(vn, key, d, s[3].to_i, s[4].to_i, data)
+          send_data("STORED\r\n")
+        else
+          @log.error("rzset NOT_STORED:#{@storages[hname].error_message} #{vn} #{s[1]} #{d} #{s[3]} #{s[4]}")
+          send_data("NOT_STORED\r\n")
+        end
+        @stats.redundant_count += 1
+      rescue Zlib::DataError => e
+        @log.error("rzset NOT_STORED:#{e} #{vn} #{s[1]} #{d} #{s[3]} #{s[4]}")
+        send_data("NOT_STORED\r\n")
+      end
+
+      def ev_forcedly_start(s)
+        @log.info("ROMA forcedly start.")
+        AsyncProcess::queue.clear
+        @rttable.enabled_failover = true
+        Command::Receiver::mk_evlist
+        $roma.startup = false
+        send_data("STARTED\r\n")
+      end
+
+      # switch_failover <on|off>
+      def ev_switch_failover(s)
+        if s.length != 2
+          return send_data("CLIENT_ERROR number of arguments\r\n")
+        end
+        res = broadcast_cmd("rswitch_failover #{s[1]}\r\n")
+        if s[1] == 'on'
+          Messaging::ConPool.instance.close_all
+          Event::EMConPool::instance.close_all
+          @rttable.enabled_failover = true
+          @log.info("failover enabled")
+          res[@stats.ap_str] = "ENABLED"
+        elsif s[1] == 'off'
+          @rttable.enabled_failover = false
+          @log.info("failover disabled")
+          res[@stats.ap_str] = "DISABLED"
+        else
+          res[@stats.ap_str] = "NOTSWITCHED"
+        end
+        send_data("#{res}\r\n")
+      end
+
+      # rswitch_failover <on|off>
+      def ev_rswitch_failover(s)
+        if s.length != 2
+          return send_data("CLIENT_ERROR number of arguments\r\n")
+        end
+        if s[1] == 'on'
+          Messaging::ConPool.instance.close_all
+          Event::EMConPool::instance.close_all
+          @rttable.enabled_failover = true
+          @log.info("failover enabled")
+          return send_data("ENABLED\r\n")
+        elsif s[1] == 'off'
+          @rttable.enabled_failover = false
+          @log.info("failover disabled")
+          return send_data("DISABLED\r\n")
+        else
+          send_data("NOTSWITCHED\r\n")
+        end
+      end
+
+      def ev_set_continuous_limit(s)
+        if s.length < 2
+          return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
+        end
+
+        res = broadcast_cmd("rset_continuous_limit #{s[1]}\r\n")
+
+        if Event::Handler.set_ccl(s[1])
+          res[@stats.ap_str] = "STORED"
+        else
+          res[@stats.ap_str] = "NOT_STORED"
+        end
+        send_data("#{res}\r\n")
+      end
+
+      def ev_rset_continuous_limit(s)
+        if s.length < 2
+          return send_data("CLIENT_ERROR number of arguments (0 for 1)\r\n")
+        end
+        if Event::Handler.set_ccl(s[1])
+          send_data("STORED\r\n")
+        else
+          send_data("NOT_STORED\r\n")
+        end
+      end
+
+      # set_connection_pool_maxlength <length>
+      # set to max length of the connection pool
+      def ev_set_connection_pool_maxlength(s)
+        if s.length != 2
+          return send_data("CLIENT_ERROR number of arguments\r\n")
+        end
+        if s[1].to_i < 1
+          return send_data("CLIENT_ERROR length must be greater than zero\r\n")
+        end
+
+        res = broadcast_cmd("rset_connection_pool_maxlength #{s[1]}\r\n")
+        Messaging::ConPool.instance.maxlength = s[1].to_i
+        res[@stats.ap_str] = "STORED"
+        send_data("#{res}\r\n")
+      end
+
+      # rset_connection_pool_maxlength <length>
+      def ev_rset_connection_pool_maxlength(s)
+        if s.length != 2
+          return send_data("CLIENT_ERROR number of arguments\r\n")
+        end
+        if s[1].to_i < 1
+          return send_data("CLIENT_ERROR length must be greater than zero\r\n")
+        end
+
+        Messaging::ConPool.instance.maxlength = s[1].to_i
+        send_data("STORED\r\n")
+      end
+
+      # set_connection_pool_maxlength <length>
+      # set to max length of the connection pool
+      def ev_set_emconnection_pool_maxlength(s)
+        if s.length != 2
+          return send_data("CLIENT_ERROR number of arguments\r\n")
+        end
+        if s[1].to_i < 1
+          return send_data("CLIENT_ERROR length must be greater than zero\r\n")
+        end
+
+        res = broadcast_cmd("rset_emconnection_pool_maxlength #{s[1]}\r\n")
+        Event::EMConPool.instance.maxlength = s[1].to_i
+        res[@stats.ap_str] = "STORED"
+        send_data("#{res}\r\n")
+      end
+
+      # rset_connection_pool_maxlength <length>
+      def ev_rset_emconnection_pool_maxlength(s)
+        if s.length != 2
+          return send_data("CLIENT_ERROR number of arguments\r\n")
+        end
+        if s[1].to_i < 1
+          return send_data("CLIENT_ERROR length must be greater than zero\r\n")
+        end
+
+        Event::EMConPool.instance.maxlength = s[1].to_i
+        send_data("STORED\r\n")
+      end
+
+      # set_accepted_connection_expire_time <sec>
+      # set to expired time(sec) for accepted connections
+      def ev_set_accepted_connection_expire_time(s)
+        if s.length != 2
+          return send_data("CLIENT_ERROR number of arguments\r\n")
+        end
+
+        res = broadcast_cmd("rset_accepted_connection_expire_time #{s[1]}\r\n")
+        Event::Handler::connection_expire_time = s[1].to_i
+        res[@stats.ap_str] = "STORED"
+        send_data("#{res}\r\n")
+      end
+
+      # rset_accepted_connection_expire_time <sec>
+      def ev_rset_accepted_connection_expire_time(s)
+        if s.length != 2
+          return send_data("CLIENT_ERROR number of arguments\r\n")
+        end
+        Event::Handler::connection_expire_time = s[1].to_i
+        send_data("STORED\r\n")
+      end
+
+      # set_hilatency_warn_time <sec>
+      # set to threshold of warn message into a log when hilatency occured in a command.
+      def ev_set_hilatency_warn_time(s)
+        if s.length != 2
+          return send_data("CLIENT_ERROR number of arguments\r\n")
+        end
+        if s[1].to_f <= 0
+          return send_data("CLIENT_ERROR time value must be lager than 0\r\n")
+        end
+
+        res = broadcast_cmd("rset_hilatency_warn_time #{s[1]}\r\n")
+        @stats.hilatency_warn_time = s[1].to_f
+        res[@stats.ap_str] = "STORED"
+        send_data("#{res}\r\n")
+      end
+
+      # rset_hilatency_warn_time <sec>
+      def ev_rset_hilatency_warn_time(s)
+        if s.length != 2
+          return send_data("CLIENT_ERROR number of arguments\r\n")
+        end
+        if s[1].to_f <= 0
+          return send_data("CLIENT_ERROR time value must be lager than 0\r\n")
+        end
+        @stats.hilatency_warn_time = s[1].to_f
+        send_data("STORED\r\n")
+      end
+
+      # wb_command_map <hash string>
+      # ex.
+      # {:set=>1,:append=>2,:delete=>3}
+      def ev_wb_command_map(s)
+        if s.length < 2
+          return send_data("CLIENT_ERROR number of arguments\r\n")
+        end
+        map = {}
+        cmd = s[1..-1].join
+        if cmd =~ /^\{(.+)\}$/
+          $1.split(',').each do |kv|
+            k, v = kv.split('=>')
+            map[k[1..-1].to_sym] = v.to_i if v && k[0]==':'
+          end
+
+          res = broadcast_cmd("rwb_command_map #{s[1..-1].join}\r\n")
+          @stats.wb_command_map = map
+          res[@stats.ap_str] = map.inspect
+          send_data("#{res}\r\n")
+        else
+          send_data("CLIENT_ERROR hash string parse error\r\n")
+        end
+      end
+
+      def ev_rwb_command_map(s)
+        if s.length < 2
+          return send_data("CLIENT_ERROR number of arguments\r\n")
+        end
+        map = {}
+        cmd = s[1..-1].join
+        if cmd =~ /^\{(.+)\}$/
+          $1.split(',').each do |kv|
+            k, v = kv.split('=>')
+            map[k[1..-1].to_sym] = v.to_i if v && k[0]==':'
+          end
+          @stats.wb_command_map = map
+          send_data("#{map}\r\n")
+        else
+          send_data("CLIENT_ERROR hash string parse error\r\n")
+        end        
+      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
+        @stats.dcnice = p
+        "STORED"
+      end
+
+      def get_config_stat
+        ret = {}
+        ret['config.DEFAULT_LOST_ACTION'] = Config::DEFAULT_LOST_ACTION
+        ret['config.LOG_SHIFT_AGE'] = Config::LOG_SHIFT_AGE
+        ret['config.LOG_SHIFT_SIZE'] = Config::LOG_SHIFT_SIZE
+        ret['config.LOG_PATH'] = File.expand_path(Config::LOG_PATH)
+        ret['config.RTTABLE_PATH'] = File.expand_path(Config::RTTABLE_PATH)
+        ret['config.STORAGE_DELMARK_EXPTIME'] = Config::STORAGE_DELMARK_EXPTIME
+        if Config.const_defined?(:STORAGE_EXCEPTION_ACTION)
+          ret['config.STORAGE_EXCEPTION_ACTION'] = Config::STORAGE_EXCEPTION_ACTION
+        end
+        ret['config.DATACOPY_STREAM_COPY_WAIT_PARAM'] = Config::DATACOPY_STREAM_COPY_WAIT_PARAM
+        ret['config.PLUGIN_FILES'] = Config::PLUGIN_FILES.inspect
+        ret['config.WRITEBEHIND_PATH'] = File.expand_path(Config::WRITEBEHIND_PATH)
+        ret['config.WRITEBEHIND_SHIFT_SIZE'] = Config::WRITEBEHIND_SHIFT_SIZE
+        if Config.const_defined?(:CONNECTION_DESCRIPTOR_TABLE_SIZE)
+          ret['config.CONNECTION_DESCRIPTOR_TABLE_SIZE'] = Config::CONNECTION_DESCRIPTOR_TABLE_SIZE
+        end
+        ret
+      end
+
+    end # module SystemCommandReceiver
+  end # module Command
+end # module Roma