bayserver-core 2.3.2 → 3.0.1

data/lib/baykit/bayserver/agent/multiplexer/spin_multiplexer.rb

@@ -0,0 +1,311 @@
+require 'baykit/bayserver/common/recipient'
+require 'baykit/bayserver/rudders/rudder'
+require 'baykit/bayserver/rudders/io_rudder'
+
+require 'baykit/bayserver/agent/multiplexer/multiplexer_base'
+require 'baykit/bayserver/agent/timer_handler'
+
+module Baykit
+  module BayServer
+    module Agent
+      module Multiplexer
+        class SpinMultiplexer < Baykit::BayServer::Agent::Multiplexer::MultiplexerBase
+          include Baykit::BayServer::Agent::TimerHandler #implements
+
+          include Baykit::BayServer::Rudders
+          include Baykit::BayServer::Util
+
+          class Lapper  # abstract class
+
+            attr :state
+            attr :last_access
+
+            def initialize(state)
+              @state = state
+              access
+            end
+
+            def access
+              @last_access = Time.now.tv_sec
+            end
+
+            def lap()
+              raise NotImplementedError
+            end
+
+            def next
+              raise NotImplementedError
+            end
+
+            def ==(other)
+              other.state == @state
+            end
+          end
+
+          class ReadIOLapper < Lapper
+
+            attr :agent
+
+            def initialize(agt, st)
+              super(st)
+              @agent = agt
+              st.rudder.set_non_blocking
+            end
+
+            def lap
+              spun = false
+
+              begin
+                infile = @state.rudder.io
+                eof = false
+
+                begin
+                  n = @state.rudder.read(@state.read_buf, @state.buf_size)
+                  #infile.sysread(@state.buf_size, @state.read_buf)
+                rescue EOFError => e
+                  @state.read_buf.clear
+                  eof = true
+                rescue Errno::EAGAIN => e
+                  BayLog.debug("%s %s", @agent, e)
+                  return true
+                end
+
+                if @state.read_buf.length == 0
+                  if !eof
+                    return true
+                  else
+                    BayLog.debug("%s Spin read: EOF\\(^o^)/ rd=%s", @agent, infile)
+                  end
+                end
+
+                @agent.send_read_letter(@state, @state.read_buf.length, nil, nil, false)
+                return false
+
+              rescue Exception => e
+                BayLog.error_e(e, "%s Error", @agent)
+                @agent.send_close_req_letter(@state, false)
+                return false
+              end
+            end
+
+            def next
+
+            end
+
+          end
+
+          attr :spin_count
+          attr :running_list
+          attr :running_list_lock
+
+          def initialize(agt)
+            super(agt)
+            @spin_count = 0
+            @running_list = []
+            @running_list_lock = Mutex.new
+            @agent.add_timer_handler(self)
+          end
+          def to_s
+            return "SpnMpx[#{@agent}]"
+          end
+
+          #########################################
+          # Implements Multiplexer
+          #########################################
+
+          def req_accept(rd)
+            raise NotImplementedError.new
+          end
+
+          def req_connect(rd, adr)
+            raise NotImplementedError.new
+          end
+
+          def req_read(rd)
+            st = get_rudder_state(rd)
+            if st == nil
+              BayLog.error("%s Invalid rudder", self)
+              return
+            end
+
+            need_read = false
+            st.reading_lock.synchronize do
+              if not st.reading
+                need_read = true
+                st.reading = true
+              end
+            end
+
+            if need_read
+              next_read(st)
+            end
+          end
+
+          def req_write(rd, buf, len, adr, tag, lis)
+            st = get_rudder_state(rd)
+            if st == nil
+              raise IOError("Invalid rudder")
+            end
+
+            unt = WriteUnit.new(buf, adr, tag, lis)
+            st.write_queue_lock.synchronize do
+              st.write_queue << unt
+            end
+            st.access
+
+            need_write = false
+            st.writing_lock.synchronize do
+              if not st.writing
+                need_write = true
+                st.writing = true
+              end
+            end
+
+            if need_write
+              next_write(st)
+            end
+          end
+
+          def req_end(rd)
+            st = get_rudder_state(rd)
+            st.finale = true
+          end
+
+          def req_close(rd)
+            st = get_rudder_state(rd)
+            st.closing = true
+            @agent.send_close_req_letter(st, false)
+          end
+
+
+          def shutdown
+            wakeup
+          end
+
+          def is_non_blocking
+            return false
+          end
+
+          def use_async_api
+            return false
+          end
+
+
+          def cancel_read(st)
+            st.reading_lock.synchronize do
+              BayLog.debug("%s Reading off %s", agent, st.rudder)
+              st.reading = false
+            end
+            remove_from_running_list(st)
+          end
+
+          def cancel_write(st)
+          end
+
+          def next_accept(st)
+          end
+
+          def next_read(st)
+            lpr = ReadIOLapper.new(@agent, st)
+            lpr.next
+
+            add_to_running_list(lpr)
+          end
+
+          def next_write(st)
+          end
+
+          def on_busy
+            BayLog.debug("%s onBusy", agent)
+            BayServer::anchorable_port_map.keys.each do |rd|
+
+            end
+          end
+
+          def on_free
+            BayLog.debug("%s onFree aborted=%s", agent, agent.aborted);
+            if agent.aborted
+              return
+            end
+
+            BayServer.anchorable_port_map.keys.each do |rd|
+
+            end
+          end
+
+          def close_rudder(st)
+            remove_from_running_list(st)
+            super
+          end
+
+          #########################################
+          # Implements TimerHandler
+          #########################################
+
+          def on_timer
+            #stop_timeout_spins
+          end
+
+          #########################################
+          # Custom methods
+          #########################################
+          def is_empty
+            return @running_list.empty?
+          end
+
+          def process_data
+            if is_empty
+              return false
+            end
+
+            all_spun = true
+            remove_list = []
+            @running_list.length.downto(1) do |i|
+              lpr = @running_list[i-1]
+              st = lpr.state
+              spun = lpr.lap
+              st.access
+
+              all_spun = all_spun & spun
+            end
+
+            if all_spun
+              @spin_count += 1
+              if @spin_count > 10
+                sleep(0.01)
+              else
+                @spin_count = 0
+              end
+            end
+
+            return true
+
+          end
+
+          #########################################
+          # Private methods
+          #########################################
+          private
+
+          def remove_from_running_list(st)
+            BayLog.debug("remove: %s", st.rudder)
+            @running_list_lock.synchronize do
+              @running_list.delete_if do |lpr |
+                lpr.state == st
+              end
+            end
+          end
+
+          def add_to_running_list(lpr)
+            BayLog.debug("add: %s", lpr.state.rudder)
+            @running_list_lock.synchronize do
+              if !@running_list.include?(lpr)
+                @running_list << lpr
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/agent/multiplexer/taxi_multiplexer.rb

@@ -0,0 +1,194 @@
+require 'baykit/bayserver/sink'
+require 'baykit/bayserver/rudders/io_rudder'
+
+require 'baykit/bayserver/agent/multiplexer/multiplexer_base'
+require 'baykit/bayserver/taxi/taxi'
+require 'baykit/bayserver/taxi/taxi_runner'
+
+
+module Baykit
+  module BayServer
+    module Agent
+      module Multiplexer
+        class TaxiMultiplexer < MultiplexerBase
+
+          class TaxiForMpx < Baykit::BayServer::Taxi::Taxi
+            attr :rudder_state
+            attr :for_read
+            def initialize(st, for_read)
+              @rudder_state = st
+              @for_read = for_read
+            end
+            def depart
+              if @for_read
+                @rudder_state.multiplexer.do_next_read(@rudder_state)
+              else
+                @rudder_state.multiplexer.do_next_write(@rudder_state)
+              end
+            end
+
+            def on_timer
+              if @rudder_state.transporter != nil
+                @rudder_state.transporter.check_timeout(@rudder_state.rudder, -1)
+              end
+            end
+          end
+
+          include Baykit::BayServer::Agent::Multiplexer
+
+          include Baykit::BayServer
+          include Baykit::BayServer::Rudders
+          include Baykit::BayServer::Util
+          include Baykit::BayServer::Taxi
+
+          def initialize(agt)
+            super
+          end
+          def to_s
+            return "TaxiMpx[#{@agent}]"
+          end
+
+
+          #########################################
+          # Implements Multiplexer
+          #########################################
+
+          def req_accept(rd)
+            raise Sink.new
+          end
+
+          def req_connect(rd, adr)
+            raise Sink.new
+          end
+
+          def req_read(rd)
+            st = get_rudder_state(rd)
+            if st == nil
+              return
+            end
+
+            BayLog.debug("%s reqRead rd=%s state=%s", @agent, st.rudder, st);
+            need_read = false
+            st.reading_lock.synchronize do
+              if !st.reading
+                need_read = true
+                st.reading = true
+              end
+            end
+
+            if need_read
+              next_run(st, true)
+            end
+
+            st.access
+          end
+
+          def req_write(rd, buf, adr, tag, lis)
+            st = get_rudder_state(rd)
+            BayLog.debug("%s reqWrite st=%s", @agent, st)
+
+            if st == nil || st.closed
+              BayLog.warn("%s Channel is closed: %s", @agent, rd)
+              return
+            end
+
+            unt = WriteUnit.new(buf, adr, tag, lis)
+            st.writing_lock.synchronize do
+              st.write_queue << unt
+            end
+
+            need_write = false
+            st.writing_lock.synchronize do
+              if !st.writing
+                need_write = true
+                st.writing = true
+              end
+            end
+
+            if need_write
+              next_run(st, false)
+            end
+
+            st.access
+          end
+
+          def req_close(rd)
+            st = get_rudder_state(rd)
+            BayLog.debug("%s reqClose st=%s", @agent, st);
+            close_rudder(st)
+            st.access
+          end
+
+          def cancel_read(st)
+
+          end
+
+          def cancel_write(st)
+
+          end
+
+          def next_accept(st)
+            raise Sink.new
+          end
+
+          def next_read(st)
+            next_run(st, true)
+          end
+
+          def next_write(st)
+            next_run(st, false)
+          end
+
+          def is_non_blocking()
+            return false
+          end
+
+          def use_async_api()
+            return false
+          end
+
+          def next_run(st, for_read)
+            BayLog.debug("%s Post next run: %s", self, st)
+
+            TaxiRunner.post(@agent.agent_id, TaxiForMpx.new(st, for_read))
+          end
+
+          def do_next_read(st)
+            st.access
+            begin
+              len = st.rudder.read(st.read_buf, st.buf_size)
+              if len <= 0
+                len = 0
+              end
+              @agent.send_read_letter(st, len, nil, nil, true)
+
+            rescue Exception => e
+              @agent.send_read_letter(st, -1, nil, e, true)
+            end
+          end
+
+          def do_next_write(st)
+            st.access
+            begin
+              if st.write_queue.empty?
+                raise Sink("%s write queue is empty", self)
+              end
+
+              u = st.write_queue[0]
+              if u.buf.length == 0
+                len = 0
+              else
+                len = st.rudder.write(u.buf)
+                u.buf.slice!(0, len)
+              end
+              @agent.send_wrote_letter(st, len, nil, true)
+
+            rescue Exception => e
+              @agent.send_wrote_letter(st, -1, e, true)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/agent/multiplexer/transporter.rb

@@ -0,0 +1,61 @@
+require 'baykit/bayserver/util/reusable'
+
+module Baykit
+  module BayServer
+    module Agent
+      module Multiplexer
+        module Transporter # interface
+          include Baykit::BayServer::Util::Reusable # implements
+
+          def init()
+            raise NotImplementedError.new
+          end
+
+          def on_connect(rd)
+            raise NotImplementedError.new
+          end
+
+          def on_read(rd, data, adr)
+            raise NotImplementedError.new
+          end
+
+          def on_error(rd, e)
+            raise NotImplementedError.new
+          end
+
+          def on_closed(rd)
+            raise NotImplementedError.new
+          end
+
+          def req_connect(rd, adr)
+            raise NotImplementedError.new
+          end
+
+          def req_read(rd)
+            raise NotImplementedError.new
+          end
+
+          def req_write(rd, buf, adr, tag, &lis)
+            raise NotImplementedError.new
+          end
+
+          def req_close(rd)
+            raise NotImplementedError.new
+          end
+
+          def check_timeout(rd, duretion_sec)
+            raise NotImplementedError.new
+          end
+
+          def get_read_buffer_size
+            raise NotImplementedError.new
+          end
+
+          def print_usage(indent)
+            raise NotImplementedError.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/agent/multiplexer/write_unit.rb

@@ -0,0 +1,30 @@
+require 'baykit/bayserver/util/reusable'
+
+module Baykit
+  module BayServer
+    module Agent
+      module Multiplexer
+        class WriteUnit
+
+          attr :buf
+          attr :adr
+          attr :tag
+          attr :listener
+
+          def initialize(buf, adr, tag, lis)
+            @buf = buf
+            @adr = adr
+            @tag = tag
+            @listener = lis
+          end
+
+          def done()
+            if @listener != nil
+              @listener.call()
+            end
+          end
+        end
+      end
+    end
+  end
+end