roma 0.8.2

data/lib/roma/command/util_command_receiver.rb

@@ -0,0 +1,67 @@
+require 'roma/messaging/con_pool'
+
+module Roma
+  module Command
+
+    module UtilCommandReceiver
+
+      def send_cmd(nid, cmd)
+        con = get_connection(nid)
+        con.send(cmd)
+        res = con.gets
+        if res
+          res.chomp!
+          @rttable.proc_succeed(nid)
+          return_connection(nid, con)
+        else
+          @rttable.proc_failed(nid)
+        end
+        res
+      rescue => e
+        @rttable.proc_failed(nid)
+        @log.error("#{e}\n#{$@}")
+        nil
+      end
+
+      def broadcast_cmd(cmd)
+        res={}
+        @rttable.nodes.each{|nid|
+          res[nid] = send_cmd(nid,cmd) if nid != @stats.ap_str
+        }
+        res
+      end
+
+      def async_send_cmd(nid, cmd)
+        con = Roma::Messaging::ConPool.instance.get_connection(nid)
+        con.write(cmd)
+        res = con.gets
+        Roma::Messaging::ConPool.instance.return_connection(nid, con)
+        if res
+          res.chomp!
+          @rttable.proc_succeed(nid)
+        else
+          @rttable.proc_failed(nid)
+        end
+        res
+      rescue => e
+        @rttable.proc_failed(nid)
+        @log.error("#{e}\n#{$@}")
+        nil
+      end
+
+      def async_broadcast_cmd(cmd,without_nids=nil)
+        without_nids=[@stats.ap_str] unless without_nids
+        res = {}
+        @rttable.nodes.each{ |nid|
+          res[nid] = async_send_cmd(nid,cmd) unless without_nids.include?(nid)
+        }
+        res
+      rescue => e
+        @log.error("#{e}\n#{$@}")
+        nil
+      end
+
+    end # module UtilCommandReceiver
+
+  end # module Command
+end # module Roma

data/lib/roma/command/vn_command_receiver.rb

@@ -0,0 +1,143 @@
+require 'roma/messaging/con_pool'
+require 'roma/async_process'
+
+module Roma
+  module Command
+
+    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")
+        else
+          send_data("SERVER_ERROR #{res}\r\n")
+        end
+      rescue => e
+        @log.error("#{e}\n#{$@}")
+      end
+
+      # spushv <hash-name> <vnode-id>
+      # src                             dst
+      #  |  ['spushv' <hname> <vn>\r\n]->|
+      #  |<-['READY'\r\n]                |
+      #  |                 [<dumpdata>]->|
+      #  |                       :       |
+      #  |                       :       |
+      #  |              [<end of dump>]->|
+      #  |<-['STORED'\r\n]               |
+      def ev_spushv(s)
+        send_data("READY\r\n")
+        @stats.run_receive_a_vnode = true
+        count = rcount = 0
+        @log.debug("#{__method__}:#{s.inspect} received.")
+        loop {
+          context_bin = read_bytes(20, 100)
+          vn, last, clk, expt, klen = context_bin.unpack('NNNNN')
+          break if klen == 0 # end of dump ?
+          k = read_bytes(klen)
+          vlen_bin = read_bytes(4, 100)
+          vlen, =  vlen_bin.unpack('N')
+          if vlen != 0
+            v = read_bytes(vlen, 100)
+            
+            if @storages[s[1]].load_stream_dump(vn, last, clk, expt, k, v)
+              count += 1
+#              @log.debug("#{__method__}:[#{vn} #{last} #{clk} #{expt} #{k}] was stored.")
+            else
+              rcount += 1
+#              @log.warn("#{__method__}:[#{vn} #{last} #{clk} #{expt} #{k}] was rejected.")
+            end
+          else
+            if @storages[s[1]].load_stream_dump(vn, last, clk, expt, k, nil)
+#              @log.debug("#{__method__}:[#{vn} #{last} #{clk} #{expt} #{k}] was stored.")
+              count += 1
+            else
+              rcount += 1
+#              @log.warn("#{__method__}:[#{vn} #{last} #{clk} #{expt} #{k}] was rejected.")
+            end
+          end
+        }
+        send_data("STORED\r\n")
+        @log.debug("#{__method__}:#{s[2]} #{count} keys loaded. #{rcount} keys rejected.")
+      rescue => e
+        @log.error("#{e}\n#{$@}")
+      ensure
+        @stats.run_receive_a_vnode = false
+      end      
+
+      # reqpushv <vnode-id> <node-id> <is primary?>
+      # src                                       dst
+      #  |<-['reqpushv <vn> <nid> <p?>\r\n']         |
+      #  |                           ['PUSHED'\r\n]->|
+      def ev_reqpushv(s)
+        if s.length!=4
+          send_data("CLIENT_ERROR usage:reqpushv vnode-id node-id primary-flag(true/false)\r\n")
+          return
+        end
+
+        if @stats.run_iterate_storage == true
+          @log.warn("reqpushv rejected:#{s}")
+          send_data("REJECTED\r\n")
+          return
+        end
+
+        Roma::AsyncProcess::queue.push(Roma::AsyncMessage.new('reqpushv',[s[1],s[2],s[3]]))
+        send_data("PUSHED\r\n")
+      rescue =>e
+        @log.error("#{e}\n#{$@}")
+      end
+
+      def req_push_a_vnode(vn, src_nid, is_primary)
+        con = Roma::Messaging::ConPool.instance.get_connection(src_nid)
+        con.write("reqpushv #{vn} #{@nid} #{is_primary}\r\n")
+        res = con.gets # receive 'PUSHED\r\n' | 'REJECTED\r\n'
+        Roma::Messaging::ConPool.instance.return_connection(src_nid,con)
+        # waiting for pushv
+        count = 0
+        while @rttable.search_nodes(vn).include?(@nid)==false && count < 300
+          sleep 0.1
+          count += 1
+        end
+      rescue =>e
+        @log.error("#{e}\n#{$@}")
+        @rttable.proc_failed(src_nid)
+        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
+end # module Roma

data/lib/roma/command_plugin.rb

@@ -0,0 +1,11 @@
+module Roma
+  module CommandPlugin
+    @@plugins=[]
+    def self.plugins
+      @@plugins.dup
+    end
+    def self.included(mod)
+      @@plugins << mod
+    end
+  end
+end

data/lib/roma/config.rb

@@ -0,0 +1,64 @@
+require 'roma/routing/rttable'
+require 'roma/routing/cb_rttable'
+require 'roma/storage/rh_storage'
+
+module Roma
+  
+  module Config
+    DEFAULT_PORT = 12000
+    DEFAULT_NAME = 'ROMA'
+
+    # :no_action | :auto_assign | :shutdown
+    DEFAULT_LOST_ACTION = :auto_assign
+
+    # log setting
+    LOG_SHIFT_AGE = 10
+    LOG_SHIFT_SIZE = 1024 * 1024 * 10
+    LOG_PATH = '.'
+    # :debug | :info | :warn | :error
+    LOG_LEVEL = :debug
+
+    # routing setting
+    RTTABLE_PATH = '.'
+
+    # storage setting
+    STORAGE_CLASS = Roma::Storage::RubyHashStorage
+    STORAGE_DIVNUM = 10
+    STORAGE_PATH = '.'
+    STORAGE_DUMP_PATH = '/tmp'
+    STORAGE_OPTION = ''
+
+    # 5 days ago
+    STORAGE_DELMARK_EXPTIME = 60 * 60 * 24 * 5
+
+    # data copy setting
+    DATACOPY_STREAM_COPY_WAIT_PARAM = 0.0001
+
+    # plugin setting
+    PLUGIN_FILES = []
+
+    # write-behind setting
+    WRITEBEHIND_PATH = './wb'
+    WRITEBEHIND_SHIFT_SIZE = 1024 * 1024 * 10
+
+    # redundant setting
+    REDUNDANT_ZREDUNDANT_SIZE = 0
+
+    def self.get_stat
+      ret = {}
+      ret['config.DEFAULT_LOST_ACTION'] = DEFAULT_LOST_ACTION
+      ret['config.LOG_SHIFT_AGE'] = LOG_SHIFT_AGE
+      ret['config.LOG_SHIFT_SIZE'] = LOG_SHIFT_SIZE
+      ret['config.LOG_PATH'] = File.expand_path(LOG_PATH)
+      ret['config.RTTABLE_PATH'] = File.expand_path(RTTABLE_PATH)
+      ret['config.STORAGE_DELMARK_EXPTIME'] = STORAGE_DELMARK_EXPTIME
+      ret['config.DATACOPY_STREAM_COPY_WAIT_PARAM'] = DATACOPY_STREAM_COPY_WAIT_PARAM
+      ret['config.PLUGIN_FILES'] = PLUGIN_FILES.inspect
+      ret['config.WRITEBEHIND_PATH'] = File.expand_path(WRITEBEHIND_PATH)
+      ret['config.WRITEBEHIND_SHIFT_SIZE'] = WRITEBEHIND_SHIFT_SIZE
+      ret
+    end
+
+  end
+
+end

data/lib/roma/event/con_pool.rb

@@ -0,0 +1,140 @@
+#
+# File: con_pool.rb
+#
+require 'singleton'
+require 'eventmachine'
+require 'roma/logging/rlogger'
+
+module Roma
+  module Event
+    module EMConnection
+      attr_writer :fiber
+      attr_reader :connected
+      attr_accessor :ap
+
+      def post_init
+        @rbuf = ''
+        @connected = true
+      end
+      
+      def receive_data(data)
+        @rbuf << data
+        @fiber.resume
+      rescue =>e
+        Roma::Logging::RLogger.instance.error("#{__FILE__}:#{__LINE__}:#{e.inspect} #{$@}")
+      end
+
+      def unbind
+        @connected = nil
+        @fiber.resume
+      rescue FiberError
+      rescue =>e
+        Roma::Logging::RLogger.instance.warn("#{__FILE__}:#{__LINE__}:#{e.inspect} #{$@}")
+      end
+
+      def send(data)
+        send_data(data)
+      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)
+        while(@connected) do
+          d = pop(size)
+          if d
+            return d
+          else
+            remain = size - @rbuf.size
+            Fiber.yield(remain)
+          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
+
+    end # module EMConnection
+
+    class EMConPool
+      include Singleton
+      attr :pool
+      attr_accessor :maxlength
+
+      def initialize
+        @pool = {}
+        @maxlength = 10
+        @lock = Mutex.new
+      end
+
+      def get_connection(ap)
+        ret = @pool[ap].shift if @pool.key?(ap) && @pool[ap].length > 0
+        ret = create_connection(ap) if ret == nil || ret.connected != true
+        ret
+      end
+
+      def return_connection(ap, con)
+        return if con.connected == false
+        if @pool.key?(ap) && @pool[ap].length > 0
+          if @pool[ap].length > @maxlength
+            con.close_connection
+          else
+            @pool[ap] << con
+          end
+        else
+          @pool[ap] = [con]
+        end
+      end
+
+      def create_connection(ap)
+        addr,port = ap.split(/[:_]/)
+        con = EventMachine::connect(addr, port, Roma::Event::EMConnection)
+        con.ap = ap
+        con
+      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.close_connection
+            rescue =>e
+              Roma::Logging::RLogger.instance.error("#{__FILE__}:#{__LINE__}:#{e.inspect}")
+            end
+          end
+          @pool.delete(ap)
+        }
+      end
+
+    end # class EMConPool
+
+  end # module Event
+end # module Roma

data/lib/roma/event/handler.rb

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