roma 0.8.2 → 0.8.10

data/ruby/server/lib/roma/live_patch-20120302-001.rb

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+# eval begin;load('roma/live_patch-20120302-001.rb');rescue Excption=>e;e.inspect;end
+#
+log = Roma::Logging::RLogger.instance
+log.info("live_patch-20120302-001:loading")
+
+Roma::Command::Receiver.class_eval{
+  def forward_get_context(nid, k)
+    con = get_connection(nid)
+    con.send("fget_context #{k}\r\n")
+    res = con.gets
+    if res == nil
+      @rttable.proc_failed(nid)
+      @log.error("forward get_context failed:nid=#{nid} key=#{k}")
+      return nil
+    elsif res == "NOT_EXIST\r\n"
+    elsif res.start_with?("ERROR")
+      @rttable.proc_succeed(nid)
+      con.close_connection
+      return nil
+    else
+      while((buf = con.gets) != "END\r\n")
+        res << buf
+      end
+      res << "END\r\n"
+    end
+    return_connection(nid, con)
+    @rttable.proc_succeed(nid)
+    res
+  rescue => e
+    @rttable.proc_failed(nid) if e.message != "no connection"
+    @log.error("#{e.inspect}/#{$@}")
+    @log.error("forward get_context failed:nid=#{nid} key=#{k}")
+    nil
+  end
+
+  def ev_get_context(s)
+    key,hname = s[1].split("\e")
+    hname ||= @defhash
+    d = Digest::SHA1.hexdigest(key).hex % @rttable.hbits
+    vn = @rttable.get_vnode_id(d)
+    nodes = @rttable.search_nodes_for_write(vn)
+    if nodes[0] != @nid
+      @log.warn("forward #{s[0]} key=#{key} vn=#{vn} to #{nodes[0]}")
+      res = forward_get_context(nodes[0], s[1])
+      if res
+        return send_data("#{res}")
+      end
+      return send_data("SERVER_ERROR Message forward failed.\r\n")
+    end
+    
+    unless @storages.key?(hname)
+      send_data("SERVER_ERROR #{hname} dose not exists.\r\n")
+      return
+    end
+    
+    ret = @storages[hname].get_raw(vn, key, d)
+    if ret
+      send_data("nid = #{@nid}\r\n")
+      send_data("vn = #{ret[0]}\r\n")
+      send_data("t = #{ret[1]}\r\n")
+      send_data("clk = #{ret[2]}\r\n")
+      send_data("expt = #{ret[3]}\r\n")
+      send_data("v.length = #{ret[4].length}\r\n") if ret[4]
+      send_data("END\r\n")
+    else
+      return send_data("NOT_EXIST\r\n")
+    end
+  end
+  
+  def ev_fget_context(s)
+    key,hname = s[1].split("\e")
+    hname ||= @defhash
+    d = Digest::SHA1.hexdigest(key).hex % @rttable.hbits
+    vn = @rttable.get_vnode_id(d)
+    nodes = @rttable.search_nodes_for_write(vn)
+    if nodes.include?(@nid) == false
+      @log.error("#{s[0]} failed key = #{s[1]} vn = #{vn}")
+      return send_data("SERVER_ERROR Routing table is inconsistent.\r\n")
+    end
+    
+    unless @storages.key?(hname)
+      send_data("SERVER_ERROR #{hname} dose not exists.\r\n")
+      return
+    end
+    
+    ret = @storages[hname].get_raw(vn, key, d)
+    if ret
+      send_data("nid = #{@nid}\r\n")
+      send_data("vn = #{ret[0]}\r\n")
+      send_data("t = #{ret[1]}\r\n")
+      send_data("clk = #{ret[2]}\r\n")
+      send_data("expt = #{ret[3]}\r\n")
+      send_data("v.length = #{ret[4].length}\r\n") if ret[4]
+      send_data("END\r\n")
+    else
+      return send_data("NOT_EXIST\r\n")
+    end
+  end
+}
+
+Roma::Event::Handler.class_eval{
+  @@ev_list['get_context'] = :ev_get_context
+  @@ev_list['fget_context'] = :ev_fget_context
+}
+
+log.info("live_patch-20120302-001:has loaded")

data/ruby/server/lib/roma/logging/rlogger.rb

@@ -0,0 +1,163 @@
+# ROMA's logger.  
+#
+# rlogger.rb - it is an extension to a standard logger for ROMA
+#
+require 'logger'
+
+module Roma
+  module Logging
+
+    class RLogger
+      VERSION = '0.0.1'
+      
+      module Severity
+        TRACE = -1
+        DEBUG = 0
+        INFO = 1
+        WARN = 2
+        ERROR = 3
+        FATAL = 4
+        UNKNOWN = 5
+      end
+      include Severity
+
+      module ExtLogDev
+        def extendLogDev()
+          if @logdev 
+            @logdev.extend(ExtShiftAge)
+          end
+        end
+      end
+  
+      module ExtShiftAge
+        private 
+        def shift_log_period(now) 
+          postfix = previous_period_end(now).strftime("%Y%m%d%H%M")
+          age_file = "#{@filename}.#{postfix}"
+          if FileTest.exist?(age_file)
+            raise RuntimeError.new("'#{age_file}' already exists.")
+          end
+          @dev.close
+          File.rename(@filename, age_file)
+          @dev = create_logfile(@filename)
+          return true
+        end
+    
+        def previous_period_end(now)
+          ret = nil
+          case @shift_age
+          when /^min$/
+            t = now - 1 * 60
+            ret = Time.mktime(t.year, t.month, t.mday, t.hour, t.min, 59)
+          when /^hour$/
+            t = now - 1 * 60 * 60
+            ret = Time.mktime(t.year, t.month, t.mday, t.hour, 59, 59)
+          when /^daily$/
+            ret = eod(now - 1 * SiD)
+          when /^weekly$/
+            ret = eod(now - ((now.wday + 1) * SiD))
+          when /^monthly$/
+            ret = eod(now - now.mday * SiD)
+          else 
+            ret = now
+          end
+          return ret
+        end
+      end
+  
+      module ExtTrace
+        private
+        SEV_LABEL = %w{DEBUG INFO WARN ERROR FATAL ANY}
+        
+        def format_severity(severity)
+          if @level <= RLogger::TRACE and severity <= RLogger::TRACE
+            return 'TRACE'
+          else 
+            return SEV_LABEL[severity] || 'ANY'
+          end
+        end
+      end
+
+      @@singleton_instance = nil
+
+      def self.create_singleton_instance(logdev, shift_age = 0, shift_size = 1048576)
+        @@singleton_instance = RLogger.new(logdev, shift_age, shift_size)
+        private_class_method  :new, :allocate
+      end
+
+      def self.instance
+        @@singleton_instance
+      end
+
+      def initialize(logdev, shift_age = 0, shift_size = 1048576)
+        @wrap_logger = Logger.new(logdev, shift_age, shift_size)
+        @wrap_logger.extend(ExtTrace) 
+        @wrap_logger.extend(ExtLogDev)
+        @wrap_logger.extendLogDev()
+      end
+      
+      def level=(severity)
+        @wrap_logger.level = severity
+      end
+      
+      def trace?; @wrap_logger.level <= TRACE; end 
+      
+      def debug?; @wrap_logger.debug?; end 
+      
+      def info?; @wrap_logger.info?; end
+      
+      def warn?; @wrap_logger.warn?; end
+  
+      def error?; @wrap_logger.error?; end
+      
+      def fatal?; @wrap_logger.fatal?; end
+  
+      def trace(progname = nil, &block)
+        @wrap_logger.add(TRACE, nil, progname, &block)
+      end
+    
+      def debug(progname = nil, &block)
+        @wrap_logger.debug(progname, &block)
+      end
+  
+      def info(progname = nil, &block)
+        @wrap_logger.info(progname, &block)
+      end
+  
+      def warn(progname = nil, &block)
+        @wrap_logger.warn(progname, &block)
+      end
+  
+      def error(progname = nil, &block)
+        @wrap_logger.error(progname, &block)
+      end
+  
+      def fatal(progname = nil, &block)
+        @wrap_logger.fatal(progname, &block)
+      end
+  
+      def unknown(progname = nil, &block)
+        @wrap_logger.unknow(progname, &block)
+      end
+  
+      def close; @wrap_logger.close; end
+  
+    end # class RLogger
+
+
+    class StderrWrapper < IO
+
+      def initialize
+        @log = RLogger.instance
+      end
+
+      def write(s)
+        @log.error("STDERR:#{s}")
+      end
+
+      def flush; end
+
+    end # class StderrWrapper < IO
+
+  end # module Logging
+end # module Roma

data/ruby/server/lib/roma/messaging/con_pool.rb

@@ -0,0 +1,92 @@
+require 'thread'
+require 'socket'
+require 'singleton'
+
+module Roma
+  module Messaging
+    
+    class ConPool
+      include Singleton
+
+      attr_accessor :maxlength
+      attr_accessor :expire_time
+
+      def initialize(maxlength = 10, expire_time = 30)
+        @pool = {}
+        @maxlength = maxlength
+        @expire_time = expire_time
+        @lock = Mutex.new
+      end
+
+      def get_connection(ap)
+        ret,last = @pool[ap].shift if @pool.key?(ap) && @pool[ap].length > 0
+        if ret && last < Time.now - @expire_time
+          ret.close
+          ret = nil
+          Logging::RLogger.instance.info("connection expired at #{ap},remains #{@pool[ap].length}")
+        end
+        return create_connection(ap) unless ret
+        ret
+      rescue => e
+        Logging::RLogger.instance.error("#{__FILE__}:#{__LINE__}:#{e}")
+        nil
+      end
+
+      def return_connection(ap, con)
+        if select([con],nil,nil,0.0001)
+          con.gets
+          con.close
+          return
+        end
+
+        if @pool.key?(ap) && @pool[ap].length > 0
+          if @pool[ap].length > @maxlength
+            con.close
+          else
+            @pool[ap] << [con, Time.now]
+          end
+        else
+          @pool[ap] = [[con, Time.now]]
+        end
+      rescue => e
+        Logging::RLogger.instance.error("#{__FILE__}:#{__LINE__}:#{e}")
+      end
+
+      def create_connection(ap)
+        addr, port = ap.split(/[:_]/)
+        TCPSocket.new(addr, port)
+      end
+
+      def delete_connection(ap)
+        @pool.delete(ap)
+      end
+
+      def close_all
+        @pool.each_key{|ap| close_at(ap) }
+      end
+
+      def close_same_host(ap)
+        host,port = ap.split(/[:_]/)
+        @pool.each_key{|eap|
+          close_at(eap) if eap.split(/[:_]/)[0] == host
+        }
+      end
+      
+      def close_at(ap)
+        return unless @pool.key?(ap)
+        @lock.synchronize {
+          while(@pool[ap].length > 0)
+            begin
+              @pool[ap].shift[0].close
+            rescue =>e
+              Roma::Logging::RLogger.instance.error("#{__FILE__}:#{__LINE__}:#{e}")
+            end
+          end
+          @pool.delete(ap)
+        }
+      end
+
+    end # class ConPool
+
+  end # module Messaging
+end # module Roma

data/{lib → ruby/server/lib}/roma/plugin/plugin_alist.rb

@@ -48,9 +48,12 @@ module Roma
         expt = 0x7fffffff
         ret = @storages[hname].set(vn, k, d, expt ,Marshal.dump([[],[]]))
         @stats.delete_count += 1
-        Roma::WriteBehindProcess::push(hname, 3, k, ddata)
+
 
         if ret
+          if @stats.wb_command_map.key?(:alist_clear)
+            Roma::WriteBehindProcess::push(hname, @stats.wb_command_map[:alist_clear], k, ddata)
+          end
           redundant(nodes[1..-1], hname, k, d, ret[2], expt, ret[4])
           send_data("CLEARED\r\n")
         else
@@ -86,9 +89,10 @@ module Roma
         ret = @storages[hname].set(vn, k, d, expt ,Marshal.dump(v))
         @stats.delete_count += 1
 
-        Roma::WriteBehindProcess::push(hname, 2, k, data)
-
         if ret
+          if @stats.wb_command_map.key?(:alist_delete)
+            Roma::WriteBehindProcess::push(hname, @stats.wb_command_map[:alist_delete], k, data)
+          end
           redundant(nodes[1..-1], hname, k, d, ret[2], expt, ret[4])
           send_data("DELETED\r\n")
         else
@@ -119,9 +123,10 @@ module Roma
         ret = @storages[hname].set(vn, k, d, expt ,Marshal.dump(v))
         @stats.delete_count += 1
 
-        Roma::WriteBehindProcess::push(hname, 2, k, dret)
-
         if ret
+          if @stats.wb_command_map.key?(:alist_delete_at)
+            Roma::WriteBehindProcess::push(hname, @stats.wb_command_map[:alist_delete_at], k, dret)
+          end
           redundant(nodes[1..-1], hname, k, d, ret[2], expt, ret[4])
           send_data("DELETED\r\n")
         else
@@ -358,6 +363,9 @@ module Roma
         @stats.write_count += 1
 
         if ret
+          if @stats.wb_command_map.key?(:alist_insert)
+            Roma::WriteBehindProcess::push(hname, @stats.wb_command_map[:alist_insert], k, data)
+          end
           redundant(nodes[1..-1], hname, k, d, ret[2], expt, ret[4])
           send_data("STORED\r\n")
         else
@@ -398,6 +406,9 @@ module Roma
         @stats.write_count += 1
 
         if ret
+          if @stats.wb_command_map.key?(:alist_sized_insert)
+            Roma::WriteBehindProcess::push(hname, @stats.wb_command_map[:alist_sized_insert], k, data)
+          end
           redundant(nodes[1..-1], hname, k, d, ret[2], expt, ret[4])
           send_data("STORED\r\n")
         else
@@ -440,9 +451,10 @@ module Roma
         ret = @storages[hname].set(vn, k, d, expt ,Marshal.dump(v))
         @stats.write_count += 1
 
-        Roma::WriteBehindProcess::push(hname, 1, k, data)
-
         if ret
+          if @stats.wb_command_map.key?(:alist_swap_and_insert)
+            Roma::WriteBehindProcess::push(hname, @stats.wb_command_map[:alist_swap_and_insert], k, data)
+          end
           redundant(nodes[1..-1], hname, k, d, ret[2], expt, ret[4])
           send_data("STORED\r\n")
         else
@@ -487,9 +499,10 @@ module Roma
         ret = @storages[hname].set(vn, k, d, expt ,Marshal.dump(v))
         @stats.write_count += 1
 
-        Roma::WriteBehindProcess::push(hname, 1, k, data)
-
         if ret
+          if @stats.wb_command_map.key?(:alist_swap_and_sized_insert)
+            Roma::WriteBehindProcess::push(hname, @stats.wb_command_map[:alist_swap_and_sized_insert], k, data)
+          end
           redundant(nodes[1..-1], hname, k, d, ret[2], expt, ret[4])
           send_data("STORED\r\n")
         else
@@ -535,9 +548,10 @@ module Roma
         ret = @storages[hname].set(vn, k, d, expt ,Marshal.dump(v))
         @stats.write_count += 1
 
-        Roma::WriteBehindProcess::push(hname, 1, k, data)
-
         if ret
+          if @stats.wb_command_map.key?(:alist_expired_swap_and_insert)
+            Roma::WriteBehindProcess::push(hname, @stats.wb_command_map[:alist_expired_swap_and_insert], k, data)
+          end
           redundant(nodes[1..-1], hname, k, d, ret[2], expt, ret[4])
           send_data("STORED\r\n")
         else
@@ -585,9 +599,10 @@ module Roma
         ret = @storages[hname].set(vn, k, d, expt ,Marshal.dump(v))
         @stats.write_count += 1
 
-        Roma::WriteBehindProcess::push(hname, 1, k, data)
-
         if ret
+          if @stats.wb_command_map.key?(:alist_expired_swap_and_sized_insert)
+            Roma::WriteBehindProcess::push(hname, @stats.wb_command_map[:alist_expired_swap_and_sized_insert], k, data)
+          end
           redundant(nodes[1..-1], hname, k, d, ret[2], expt, ret[4])
           send_data("STORED\r\n")
         else
@@ -831,7 +846,6 @@ module Roma
         data = read_bytes(s[2].to_i)
         read_bytes(2)
         if nodes[0] != @nid
-          @log.debug("forward to #{nodes[0]}");
           return forward2(nodes[0], s, data)
         end
 
@@ -849,6 +863,9 @@ module Roma
         @stats.write_count += 1
 
         if ret
+          if @stats.wb_command_map.key?(:alist_push)
+            Roma::WriteBehindProcess::push(hname, @stats.wb_command_map[:alist_push], k, data)
+          end
           redundant(nodes[1..-1], hname, k, d, ret[2], expt, ret[4])
           send_data("STORED\r\n")
         else
@@ -889,7 +906,11 @@ module Roma
         ret = @storages[hname].set(vn, k, d, expt ,Marshal.dump(v))
         @stats.write_count += 1
 
+
         if ret
+          if @stats.wb_command_map.key?(:alist_sized_push)
+            Roma::WriteBehindProcess::push(hname, @stats.wb_command_map[:alist_sized_push], k, data)
+          end
           redundant(nodes[1..-1], hname, k, d, ret[2], expt, ret[4])
           send_data("STORED\r\n")
         else
@@ -931,6 +952,9 @@ module Roma
         @stats.write_count += 1
 
         if ret
+          if @stats.wb_command_map.key?(:alist_swap_and_push)
+            Roma::WriteBehindProcess::push(hname, @stats.wb_command_map[:alist_swap_and_push], k, data)
+          end
           redundant(nodes[1..-1], hname, k, d, ret[2], expt, ret[4])
           send_data("STORED\r\n")
         else
@@ -978,6 +1002,9 @@ module Roma
         @stats.write_count += 1
 
         if ret
+          if @stats.wb_command_map.key?(:alist_swap_and_sized_push)
+            Roma::WriteBehindProcess::push(hname, @stats.wb_command_map[:alist_swap_and_sized_push], k, data)
+          end
           redundant(nodes[1..-1], hname, k, d, ret[2], expt, ret[4])
           send_data("STORED\r\n")
         else
@@ -1024,6 +1051,9 @@ module Roma
         @stats.write_count += 1
 
         if ret
+          if @stats.wb_command_map.key?(:alist_expired_swap_and_push)
+            Roma::WriteBehindProcess::push(hname, @stats.wb_command_map[:alist_expired_swap_and_push], k, data)
+          end
           redundant(nodes[1..-1], hname, k, d, ret[2], expt, ret[4])
           send_data("STORED\r\n")
         else
@@ -1075,6 +1105,9 @@ module Roma
         @stats.write_count += 1
 
         if ret
+          if @stats.wb_command_map.key?(:alist_expired_swap_and_sized_push)
+            Roma::WriteBehindProcess::push(hname, @stats.wb_command_map[:alist_expired_swap_and_sized_push], k, data)
+          end
           redundant(nodes[1..-1], hname, k, d, ret[2], expt, ret[4])
           send_data("STORED\r\n")
         else
@@ -1086,6 +1119,44 @@ module Roma
         @log.error("#{e} #{$@}")
       end
 
+      # alist_update_at <key> <index> <bytes>[forward]\r\n
+      # <data block>\r\n
+      # 
+      # (STORED|NOT_STORED|NOT_FOUND|SERVER_ERROR <error message>)\r\n
+      def ev_alist_update_at(s)
+        hname, k, d, vn, nodes = calc_hash(s[1])
+        data = read_bytes(s[3].to_i)
+        read_bytes(2)
+        return forward2(nodes[0], s, data) if nodes[0] != @nid
+
+        ddata = @storages[hname].get(vn, k, d)
+        return send_data("NOT_FOUND\r\n") unless ddata
+
+        v = Marshal.load(ddata)
+
+        idx = s[2].to_i
+        return send_data("NOT_FOUND\r\n") if idx < 0 || v[0].length <= idx
+        v[0][idx] = data
+        v[1][idx] = Time.now.to_i
+
+        expt = 0x7fffffff
+        ret = @storages[hname].set(vn, k, d, expt ,Marshal.dump(v))
+        @stats.write_count += 1
+
+        if ret
+          if @stats.wb_command_map.key?(:alist_update_at)
+            Roma::WriteBehindProcess::push(hname, @stats.wb_command_map[:alist_update_at], k, data)
+          end
+          redundant(nodes[1..-1], hname, k, d, ret[2], expt, ret[4])
+          send_data("STORED\r\n")
+        else
+          send_data("NOT_STORED\r\n")
+        end  
+      rescue => e
+        msg = "SERVER_ERROR #{e} #{$@}".tr("\r\n"," ")
+        send_data("#{msg}\r\n")
+        @log.error("#{e} #{$@}")
+      end
 
       # alist_shift <key> [forward]\r\n
       #
@@ -1298,6 +1369,8 @@ module Roma
           return send_data("SERVER_ERROR Routing table is inconsistent.\r\n")
         end
         
+        @log.warn("forward #{rs} to #{nid}");
+
         buf = ''
         rs.each{|ss| buf << "#{ss} " }
         buf << "forward\r\n"
@@ -1309,26 +1382,42 @@ module Roma
         con = get_connection(nid)
         con.send(buf)
 
+        buf = con.gets
+        if buf == nil
+          @rttable.proc_failed(nid)
+          @log.error("forward get failed:nid=#{nid} rs=#{rs} #{$@}")
+          return send_data("SERVER_ERROR Message forward failed.\r\n")
+        elsif buf.start_with?("ERROR")
+          @rttable.proc_succeed(nid)
+          con.close_connection
+          @log.error("forward get failed:nid=#{nid} rs=#{rs} #{$@}")
+          return send_data("SERVER_ERROR Message forward failed.\r\n")
+        elsif buf.start_with?("VALUE") == false
+          return_connection(nid, con)
+          @rttable.proc_succeed(nid)
+          return send_data(buf)
+        end
+        
         res = ''
-        while (buf = con.gets)!="END\r\n"
+        begin
           res << buf
           s = buf.split(/ /)
           if s[0] != 'VALUE'
+            return_connection(nid, con)
+            @rttable.proc_succeed(nid)
             return send_data(buf)
           end
-          res << con.read_bytes(s[3].to_i + 2)
-        end
+          res << con.read_bytes(s[3].to_i + 2)          
+        end while (buf = con.gets)!="END\r\n"
+
         res << "END\r\n"
 
         return_connection(nid, con)
         @rttable.proc_succeed(nid)
-        if res
-          send_data(res)
-        else
-          send_data("SERVER_ERROR Message forward failed.\r\n")
-        end
+
+        send_data(res)
       rescue => e
-        @rttable.proc_failed(nid)
+        @rttable.proc_failed(nid) if e.message != "no connection"
         @log.error("forward get failed:nid=#{nid} rs=#{rs} #{e} #{$@}")
         send_data("SERVER_ERROR Message forward failed.\r\n")
       end
@@ -1339,6 +1428,8 @@ module Roma
           return send_data("SERVER_ERROR Routing table is inconsistent.\r\n")
         end
 
+        @log.warn("forward #{rs} to #{nid}");
+
         buf = ''
         rs.each{|ss| buf << "#{ss} " }
         buf << "forward\r\n"
@@ -1348,225 +1439,12 @@ module Roma
         end
 
         res = send_cmd(nid, buf)
-        return send_data("#{res}\r\n") if res
-        return send_data("SERVER_ERROR Message forward failed.\r\n")
+        if res == nil || res.start_with?("ERROR")
+          return send_data("SERVER_ERROR Message forward failed.\r\n")
+        end
+        send_data("#{res}\r\n")
       end
 
     end #  PluginAshiatoList
   end # CommandPlugin
-
-
-  module ClientPlugin
-
-    module PluginAshiatoList
-      
-      def alist_at(key, index)
-        ret = sender(:value_list_receiver, key, nil, "alist_at %s #{index}")
-        return nil if ret.length == 0
-        ret[0]
-      end
-
-      def alist_clear(key)
-        sender(:oneline_receiver, key, nil, "alist_clear %s")
-      end
-
-      def alist_delete(key, value)
-        value_validator(value)
-        sender(:oneline_receiver, key, value, "alist_delete %s #{value.length}")
-      end
-
-      def alist_delete_at(key, index)
-        sender(:oneline_receiver, key, nil, "alist_delete_at %s #{index}")
-      end
-
-      def alist_empty?(key)
-        sender(:oneline_receiver, key, nil, "alist_empty? %s")
-      end
-
-      def alist_first(key)
-        ret = sender(:value_list_receiver, key, nil, "alist_first %s")
-        return nil if ret.length == 0
-        ret[0]
-      end
-
-      def alist_gets(key, range=nil)
-        if range
-          ret = sender(:value_list_receiver, key, nil, "alist_gets %s #{range}")
-        else
-          ret = sender(:value_list_receiver, key, nil, "alist_gets %s")
-        end
-        return nil if ret.length == 0
-        ret[0] = ret[0].to_i
-        ret
-      end
-
-      def alist_gets_with_time(key, range=nil)
-        if range
-          ret = sender(:value_list_receiver, key, nil, "alist_gets_with_time %s #{range}")
-        else
-          ret = sender(:value_list_receiver, key, nil, "alist_gets_with_time %s")
-        end
-        return nil if ret.length == 0
-        ret[0] = ret[0].to_i
-        ret
-      end
-
-      def alist_include?(key, value)
-        sender(:oneline_receiver, key, value, "alist_include? %s #{value.length}")
-      end
-
-      def alist_index(key, value)
-        value_validator(value)
-        ret = sender(:oneline_receiver, key, value, "alist_index %s #{value.length}")
-        return ret.to_i if ret =~ /\d+/
-        return nil if ret=='nil'
-        ret
-      end
-
-      def alist_insert(key, index, value)
-        value_validator(value)
-        sender(:oneline_receiver, key, value, "alist_insert %s #{index} #{value.length}")
-      end
-
-      def alist_sized_insert(key, array_size, value)
-        sender(:oneline_receiver, key, value, "alist_sized_insert %s #{array_size} #{value.length}")
-      end
-
-      def alist_swap_and_insert(key, value)
-        sender(:oneline_receiver, key, value, "alist_swap_and_insert %s #{value.length}")
-      end
-
-      def alist_swap_and_sized_insert(key, array_size, value)
-        value_validator(value)
-        sender(:oneline_receiver, key, value, "alist_swap_and_sized_insert %s #{array_size} #{value.length}")
-      end
-
-      def alist_expired_swap_and_insert(key, expt, value)
-        value_validator(value)
-        sender(:oneline_receiver, key, value,
-               "alist_expired_swap_and_insert %s #{expt} #{value.length}")
-      end
-
-      def alist_expired_swap_and_sized_insert(key, expt, array_size, value)
-        value_validator(value)
-        sender(:oneline_receiver, key, value,
-               "alist_expired_swap_and_sized_insert %s #{expt} #{array_size} #{value.length}")
-      end
-
-      def alist_join(key, sep, range=nil)
-        if range
-          ret = sender(:value_list_receiver, key, sep, "alist_join %s #{sep.length} #{range}")
-        else
-          ret = sender(:value_list_receiver, key, sep, "alist_join %s #{sep.length}")
-        end
-        return nil if ret.length == 0
-        ret[0] = ret[0].to_i
-        ret
-      end
-
-      def alist_join_with_time(key, sep, range=nil)
-        if range
-          ret = sender(:value_list_receiver, key, sep,
-                       "alist_join_with_time %s #{sep.length} #{range}")
-        else
-          ret = sender(:value_list_receiver, key, sep,
-                       "alist_join_with_time %s #{sep.length}")
-        end
-        return nil if ret.length == 0
-        ret[0] = ret[0].to_i
-        ret
-      end
-
-      def alist_to_json(key, range=nil)
-        if range
-          ret = sender(:value_list_receiver, key, nil, "alist_to_json %s #{range}")
-        else
-          ret = sender(:value_list_receiver, key, nil, "alist_to_json %s")
-        end
-        return nil if ret.length == 0
-        ret[0]
-      end
-
-      def alist_last(key)
-        ret = sender(:value_list_receiver, key, nil, "alist_last %s")
-        return nil if ret.length == 0
-        ret[0]
-      end
-
-      def alist_length(key)
-        ret = sender(:oneline_receiver, key, nil, "alist_length %s")
-        return ret.to_i if ret =~ /\d+/
-        ret
-      end
-
-      def alist_pop(key)
-        ret = sender(:value_list_receiver, key, nil, "alist_pop %s")
-        return nil if ret.length == 0
-        ret[0]
-      end
-
-      def alist_push(key, value)
-        value_validator(value)
-        sender(:oneline_receiver, key, value, "alist_push %s #{value.length}")
-      end
-
-      def alist_sized_push(key, array_size, value)
-        value_validator(value)
-        sender(:oneline_receiver, key, value,
-               "alist_sized_push %s #{array_size} #{value.length}")
-      end
-
-      def alist_swap_and_push(key, value)
-        value_validator(value)
-        sender(:oneline_receiver, key, value, "alist_swap_and_push %s #{value.length}")
-      end
-
-      def alist_swap_and_sized_push(key, array_size, value)
-        value_validator(value)
-        sender(:oneline_receiver, key, value,
-               "alist_swap_and_sized_push %s #{array_size} #{value.length}")
-      end
-
-      def alist_expired_swap_and_push(key, expt, value)
-        value_validator(value)
-        sender(:oneline_receiver, key, value,
-               "alist_expired_swap_and_push %s #{expt} #{value.length}")
-      end
-
-      def alist_expired_swap_and_sized_push(key, expt, array_size, value)
-        value_validator(value)
-        sender(:oneline_receiver, key, value,
-               "alist_expired_swap_and_sized_push %s #{expt} #{array_size} #{value.length}")
-      end
-
-      def alist_shift(key)
-        ret = sender(:value_list_receiver, key, nil, "alist_shift %s")
-        return nil if ret.length == 0
-        ret[0]
-      end
-
-      def alist_to_s(key, range=nil)
-        if range
-          ret = sender(:value_list_receiver, key, nil, "alist_to_s %s #{range}")
-        else
-          ret = sender(:value_list_receiver, key, nil, "alist_to_s %s")
-        end
-        return ret if ret.instance_of?(String)
-        return nil if ret.length == 0
-        ret[0] = ret[0].to_i
-        ret[1] = eval(ret[1])
-        ret
-      end
-
-      private
-
-      def value_validator(value)
-        if value == nil || !value.instance_of?(String)
-          raise "value must be a String object."
-        end
-      end
-
-    end # PluginAshiatoList
-  end # ClientPlugin
-
 end # Roma