bayserver-core 2.3.2 → 3.0.0

data/lib/baykit/bayserver/agent/non_blocking_handler.rb

@@ -15,63 +15,11 @@ module Baykit
           include Baykit::BayServer::Agent
           include Baykit::BayServer::Util
 
-          class ChannelState
-            attr_accessor :accepted
-            attr :channel
-            attr :listener
-            attr_accessor :connecting
-            attr_accessor :closing
-
-            attr :last_access_time
-
-            def initialize(ch, lis)
-              @channel = ch
-              @listener = lis
-              @accepted = false
-              @connecting = false
-              @closing = false
-            end
-
-            def access
-              @last_access_time = DateTime.now
-            end
-
-            def to_s
-             if @listener != nil
-                str = @listener.to_s
-              else
-                str = super.to_s
-             end
-             if @closing
-               str += " closing";
-             end
-             return str
-            end
-          end
-
-          class ChannelOperation
-
-            attr :ch
-            attr_accessor :op
-            attr_accessor :to_connect
-            attr_accessor :to_close
-
-
-            def initialize(ch, op, to_connect, to_close)
-              @ch = ch
-              @op = op
-              @to_connect = to_connect
-              @to_close = to_close
-            end
 
 
-          end
-
           attr :agent
           attr :ch_map
           attr :ch_count
-          attr :operations
-          attr :operations_lock
 
           def initialize(ship_agent)
             @agent = ship_agent
@@ -100,197 +48,9 @@ module Baykit
           # Custom methods
           ######################################################
 
-          def handle_channel(ch, op)
-
-            ch_state = find_channel_state(ch)
-            if ch_state == nil
-              BayLog.error("Cannot find fd state (Maybe file is closed)")
-              @agent.selector.unregister(ch)
-              return
-            end
-
-            next_action = nil
-            begin
-
-              if ch_state.closing
-                next_action = NextSocketAction::CLOSE
-
-              elsif ch_state.connecting
-                ch_state.connecting = false
-                # connectable
-                next_action = ch_state.listener.on_connectable(ch)
-                if next_action == nil
-                  raise Sink.new("unknown next action")
-                elsif next_action == NextSocketAction::READ
-                  # "Write-OP Off"
-                  op = @agent.selector.get_op(ch)
-                  op = op & ~Selector::OP_WRITE
-                  if op == 0
-                    @agent.selector.unregister(ch)
-                  else
-                    @agent.selector.modify(ch, op)
-                  end
-                end
-
-              else
-                if op & Selector::OP_READ != 0
-                  # readable
-                  next_action = ch_state.listener.on_readable(ch)
-                  if next_action == nil
-                    raise Sink.new("unknown next action")
-                  elsif next_action == NextSocketAction::WRITE
-                    op = @agent.selector.get_op(ch)
-                    op = op | Selector::OP_WRITE
-                    @agent.selector.modify(ch, op)
-                  end
-                end
-
-                if (next_action != NextSocketAction::CLOSE) && (op & Selector::OP_WRITE != 0)
-                  # writable
-                  next_action = ch_state.listener.on_writable(ch)
-                  if next_action == nil
-                    raise Sink.new("unknown next action")
-                  elsif next_action == NextSocketAction::READ
-                    # Handle as "Write Off"
-                    op = @agent.selector.get_op(ch)
-                    op = op & ~Selector::OP_WRITE
-                    if op == 0
-                      @agent.selector.unregister(ch)
-                    else
-                      @agent.selector.modify(ch, op)
-                    end
-                  end
-                end
-              end
-
-
-              if next_action == nil
-                raise Sink.new("unknown next action")
-              end
-
-            rescue Sink => e
-              raise e
-
-            rescue => e
-              if e.kind_of? EOFError
-                BayLog.debug("%s Socket closed by peer: skt=%s", @agent, ch.inspect)
-              elsif e.kind_of? SystemCallError
-                BayLog.debug("%s O/S error: %s (skt=%s)", @agent, e.message, ch.inspect)
-              elsif e.kind_of? IOError
-                BayLog.debug("%s IO error: %s (skt=%s)", @agent, e.message, ch.inspect)
-              elsif e.kind_of? OpenSSL::SSL::SSLError
-                BayLog.debug("%s SSL error: %s (skt=%s)", @agent, e.message, ch.inspect)
-              else
-                BayLog.error("%s Unhandled error error: %s (skt=%s)", @agent, e, ch.inspect)
-                throw e
-              end
-              # Cannot handle Exception any more
-              ch_state.listener.on_error(ch, e)
-              next_action = NextSocketAction::CLOSE
-            end
-
-            cancel = false
-            ch_state.access()
-            BayLog.trace("%s next=%d", ch_state, next_action)
-            case next_action
-            when NextSocketAction::CLOSE
-              close_channel(ch, ch_state)
-              cancel = false   # already canceled in close_channel method
-
-            when NextSocketAction::SUSPEND
-              cancel = true
-
-            when NextSocketAction::CONTINUE, NextSocketAction::READ, NextSocketAction::WRITE
-              # do nothing
-
-            else
-              raise RuntimeError.new("IllegalState:: #{next_action}")
-            end
-
-            if cancel
-              BayLog.trace("%s cancel key chState=%s", @agent, ch_state)
-              @agent.selector.unregister(ch)
-            end
-          end
-
-          def register_channel_ops()
-            if @operations.empty?
-              return 0
-            end
-
-            @operations_lock.synchronize do
-              nch = @operations.length
-              @operations.each do |ch_op|
-                st = self.find_channel_state(ch_op.ch)
-                if ch_op.ch.closed?
-                  # Channel is closed before register operation
-                  BayLog.debug("%s Try to register closed socket (Ignore)", @agent)
-                  next
-                end
-
-                begin
-                  BayLog.trace("%s register op=%s chState=%s", @agent, self.class.op_mode(ch_op.op), st)
-                  op = @agent.selector.get_op(ch_op.ch)
-                  if op == nil
-                    @agent.selector.register(ch_op.ch, ch_op.op)
-                  else
-                    new_op = op | ch_op.op
-                    BayLog.debug("%s Already registered ch=%s op=%s update to %s", @agent, ch_op.ch, self.class.op_mode(op), self.class.op_mode(new_op))
-                    @agent.selector.modify(ch_op.ch, new_op)
-                  end
-
-                  if ch_op.to_connect
-                    if st == nil
-                      BayLog.warn("%s register connect but ChannelState is null", @agent);
-                    else
-                      st.connecting = true
-                    end
-
-                  elsif ch_op.to_close
-                    if st == nil
-                      BayLog.warn("%s chState=%s register close but ChannelState", self.agent);
-                    else
-                      st.closing = true
-                    end
-                  end
-
-                rescue => e
-                  cst = find_channel_state(ch_op.ch)
-                  BayLog.error_e(e, "%s Cannot register operation: %s", self.agent, cst != nil ? cst.listener : nil)
-                end
-              end
-
-              @operations.clear()
-              return nch
-
-            end
-          end
 
           def close_timeout_sockets()
-            if @ch_map.empty?
-              return
-            end
 
-            close_list = []
-            now = DateTime.now
-            @ch_map.values.each do |ch_state|
-              if ch_state.listener != nil
-                begin
-                  duration =  ((now - ch_state.last_access_time) * 86400).to_i
-                  if ch_state.listener.check_timeout(ch_state.channel, duration)
-                    BayLog.debug("%s timeout: ch=%s", @agent, ch_state.channel)
-                    close_list << ch_state
-                  end
-                rescue IOError => e
-                  BayLog.error_e(e)
-                  close_list << ch_state
-                end
-              end
-            end
-
-            close_list.each do |ch_state|
-              close_channel ch_state.channel, ch_state
-            end
           end
 
           def add_channel_listener(ch, lis)
@@ -309,66 +69,19 @@ module Baykit
           end
 
           def ask_to_connect(ch, addr)
-            ch_state = find_channel_state(ch)
-            BayLog.debug("%s askToConnect addr=%s skt=%s chState=%s", @agent, addr.ip_address, ch, ch_state)
 
-            begin
-              ch.connect_nonblock(addr)
-            rescue IO::WaitWritable => e
-              #BayLog.error_e(e)
-            end
-
-            ch_state.connecting = true
-            add_operation(ch, Selector::OP_WRITE, true)
           end
 
           def ask_to_read(ch)
-            ch_state = find_channel_state(ch)
-            BayLog.debug("%s askToRead chState=%s", @agent, ch_state);
-
-            if ch.closed?
-              raise IOError.new("Channel is closed")
-            end
-
-            add_operation(ch, Selector::OP_READ)
 
-            if ch_state != nil
-              ch_state.access()
-            end
           end
 
           def ask_to_write(ch)
-            ch_state = find_channel_state(ch)
-            BayLog.debug("%s askToWrite chState=%s", @agent, ch_state);
 
-            if ch.closed?
-              BayLog.warn("%s Channel is closed: %s", @agent, ch)
-              return
-            end
-
-            add_operation(ch, Selector::OP_WRITE)
-
-            if ch_state == nil
-              BayLog.error("Unknown socket (or closed)")
-              return
-            end
-
-            ch_state.access()
           end
 
           def ask_to_close(ch)
-            ch_state = find_channel_state(ch)
-            BayLog.debug("%s askToClose chState=%s", @agent, ch_state);
 
-            if ch_state == nil
-              BayLog.warn("%s channel state not found: %s", @agent, ch)
-              return
-            end
-
-            ch_state.closing = true
-            add_operation(ch, Selector::OP_WRITE, false, true)
-
-            ch_state.access
           end
 
           def close_all()
@@ -381,27 +94,7 @@ module Baykit
 
           private
 
-          def add_operation(ch, op, to_connect=false, to_close=false)
-            @operations_lock.synchronize do
-              found = false
-              @operations.each do |ch_op|
-                if ch_op.ch == ch
-                  ch_op.op |= op
-                  ch_op.to_close = (ch_op.to_close or to_close)
-                  ch_op.to_connect = (ch_op.to_connect or to_connect)
-                  found = true
-                  BayLog.trace("%s Update operation: %s con=%s close=%s ch=%s", @agent, self.class.op_mode(ch_op.op), ch_op.to_connect, ch_op.to_close, ch_op.ch.inspect())
-                end
-              end
-
-              if not found
-                BayLog.trace("%s New operation: %s con=%s close=%s ch=%s", @agent, self.class.op_mode(op), to_connect, to_close, ch.inspect());
-                @operations << ChannelOperation.new(ch, op, to_connect, to_close)
-              end
-            end
 
-            @agent.wakeup
-          end
 
           def close_channel(ch, ch_state)
             BayLog.debug("%s Close chState=%s", @agent, ch_state)
@@ -449,19 +142,7 @@ module Baykit
           end
 
           def NonBlockingHandler.op_mode(mode)
-            mode_str = ""
-            if (mode & Selector::OP_READ) != 0
-              mode_str = "OP_READ"
-            end
-
-            if (mode & Selector::OP_WRITE) != 0
-              if mode_str != ""
-                mode_str += "|"
-              end
-              mode_str += "OP_WRITE"
-            end
 
-            return mode_str
           end
         end
     end

data/lib/baykit/bayserver/agent/signal/signal_agent.rb

@@ -1,7 +1,7 @@
 require 'baykit/bayserver/mem_usage'
 require 'baykit/bayserver/bcf/package'
 
-require 'baykit/bayserver/agent/grand_agent_monitor'
+require 'baykit/bayserver/agent/monitor/grand_agent_monitor'
 require 'baykit/bayserver/agent/signal/signal_proxy'
 require 'baykit/bayserver/util/sys_util'
 
@@ -14,6 +14,7 @@ module Baykit
           include Baykit::BayServer::Bcf
           include Baykit::BayServer::Util
           include Baykit::BayServer::Agent
+          include Baykit::BayServer::Agent::Monitor
           include Baykit::BayServer::Agent::Signal
 
           COMMAND_RELOAD_CERT = "reloadcert"

data/lib/baykit/bayserver/agent/timer_handler.rb

@@ -5,7 +5,7 @@ module Baykit
       module TimerHandler # interface
 
         def on_timer()
-          raise NotImplementedError()
+          raise NotImplementedError.new
         end
 
       end

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

@@ -5,31 +5,31 @@ module Baykit
         module DataListener  # interface
 
           def notify_connect()
-            raise NotImplementedError()
+            raise NotImplementedError.new
           end
 
           def notify_handshake_done(protocol)
-            raise NotImplementedError()
+            raise NotImplementedError.new
           end
 
           def notify_read(buf)
-            raise NotImplementedError()
+            raise NotImplementedError.new
           end
 
           def notify_eof()
-            raise NotImplementedError()
+            raise NotImplementedError.new
           end
 
           def notify_protocol_error(err)
-            raise NotImplementedError()
+            raise NotImplementedError.new
           end
 
           def notify_close()
-            raise NotImplementedError()
+            raise NotImplementedError.new
           end
 
           def check_timeout(duration_sec)
-            raise NotImplementedError()
+            raise NotImplementedError.new
           end
         end
       end

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

@@ -1,3 +0,0 @@
-require 'baykit/bayserver/agent/transporter/plain_transporter'
-require 'baykit/bayserver/agent/transporter/secure_transporter'
-require 'baykit/bayserver/agent/transporter/transporter'

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

@@ -16,53 +16,22 @@ module Baykit
             include Baykit::BayServer::Protocol
             include Baykit::BayServer::Util
 
-            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
-
             #
             # Abstract methods
             #
             def secure()
-              raise NotImplementedError()
+              raise NotImplementedError.new
             end
 
             def handshake_nonblock()
-              raise NotImplementedError()
+              raise NotImplementedError.new
             end
 
             def handshake_finished()
-              raise NotImplementedError()
-            end
-
-            def read_nonblock()
-              raise NotImplementedError()
+              raise NotImplementedError.new
             end
 
-            def write_nonblock(buf, adr)
-              raise NotImplementedError()
-            end
-
-
             attr :data_listener
-            attr :server_mode
-            attr :trace_ssl
             attr :infile
             attr :write_queue
             attr :finale
@@ -79,7 +48,7 @@ module Baykit
             def initialize(server_mode, bufsiz, trace_ssl, write_only = false)
               @server_mode = server_mode
               @write_queue = []
-              @lock = Monitor.new()
+              @lock = ::Monitor.new()
               @capacity = bufsiz
               @read_buf = StringUtil.alloc(bufsiz)
               @trace_ssl = trace_ssl
@@ -91,31 +60,6 @@ module Baykit
               return "tpt[#{@data_listener.to_s}]"
             end
 
-            def init(nb_hnd, ch, lis)
-              if ch == nil
-                raise ArgumentError.new("Channel is nil")
-              end
-              if lis == nil
-                raise ArgumentError.new("Data listener is nil")
-              end
-
-              if @initialized
-                BayLog.error("%s This transporter is already in use by channel: %s", self, @ch)
-                raise Sink.new("IllegalState")
-              end
-
-              if !@write_queue.empty?
-                raise Sink.new()
-              end
-
-              @channel_handler = nb_hnd
-              @data_listener = lis
-              @ch = ch
-              @initialized = true
-              set_valid(true)
-              @handshaked = false
-              @channel_handler.add_channel_listener(ch, self)
-            end
 
             ######################################################
             # Implements Reusable
@@ -146,19 +90,7 @@ module Baykit
 
               BayLog.debug("%s post: %s len=%d", self, tag, buf.length)
 
-              @lock.synchronize do
-
-                if !@ch_valid
-                  raise IOError.new("#{self} channel is invalid, Ignore")
-                else
-                  unt = WriteUnit.new(buf, adr, tag, lisnr)
-                  @write_queue << unt
-
-                  BayLog.trace("%s sendBytes->askToWrite", self)
-                  @channel_handler.ask_to_write(@ch)
-                end
 
-              end
             end
 
             ######################################################
@@ -186,71 +118,6 @@ module Baykit
 
             def on_readable(chk_ch)
               check_channel(chk_ch)
-              BayLog.trace("%s on_readable", self)
-
-              if !@handshaked
-                begin
-                  handshake_nonblock()
-                  @handshaked = true
-                rescue IO::WaitReadable => e
-                  BayLog.debug("%s Handshake status: read more", @data_listener)
-                  return NextSocketAction::CONTINUE
-                rescue IO::WaitWritable => e
-                  BayLog.debug("%s Handshake status: write more", @data_listener)
-                  @channel_handler.ask_to_write(@ch)
-                  return NextSocketAction::CONTINUE
-                end
-              end
-
-              # read data
-              # If closed, EOFError is raised
-              if @read_buf.length == 0
-                eof = false
-                begin
-                  adr = read_nonblock()
-                rescue IO::WaitReadable => e
-                  BayLog.debug("%s Read status: read more", self)
-                  return NextSocketAction::CONTINUE
-                rescue IO::WaitWritable => e
-                  BayLog.debug("%s Read status: write more", self)
-                  @channel_handler.ask_to_write(@ch)
-                  return NextSocketAction::CONTINUE
-                rescue EOFError => e
-                  BayLog.debug("%s EOF", self)
-                  eof = true
-                rescue SystemCallError => e
-                  BayLog.debug_e(e, "SystemCall Error")
-                  eof = true
-                end
-
-                if eof
-                  return @data_listener.notify_eof()
-                end
-              end
-
-              BayLog.debug("%s read %d bytes", self, @read_buf.length)
-
-              begin
-                begin
-                  next_action = @data_listener.notify_read(@read_buf, adr)
-                  BayLog.trace("%s returned from notify_read(). next action=%d", @ship, next_action)
-                  return next_action
-                rescue UpgradeException => e
-                  BayLog.debug("%s Protocol upgrade", @ship)
-                  return @data_listener.notify_read(@read_buf, adr)
-                ensure
-                  @read_buf.clear()
-                end
-
-
-              rescue ProtocolException => e
-                close = @data_listener.notify_protocol_error(e)
-                if !close && @server_mode
-                  return NextSocketAction::CONTINUE
-                else
-                  return NextSocketAction::CLOSE
-                end
-              end
             end
 
             def on_writable(chk_ch)
@@ -397,9 +264,8 @@ module Baykit
                   write_unit.done()
                 end
                 @write_queue.clear()
-
-                @data_listener.notify_close()
               end
+              @data_listener.notify_close()
             end
 
             def flush()

data/lib/baykit/bayserver/bay_log.rb

@@ -16,6 +16,7 @@ module Baykit
       # class instance variables
       class << self
         attr :log_level
+        attr :full_path
       end
       @log_level = LOG_LEVEL_INFO
       @full_path = SysUtil.run_on_rubymine()