bayserver-core 3.0.2 → 3.3.1

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

@@ -1,11 +1,13 @@
 require 'baykit/bayserver/common/recipient'
+require 'baykit/bayserver/common/write_unit'
 require 'baykit/bayserver/rudders/rudder'
+
 require 'baykit/bayserver/rudders/io_rudder'
 
 require 'baykit/bayserver/agent/multiplexer/multiplexer_base'
-require 'baykit/bayserver/agent/multiplexer/write_unit'
 require 'baykit/bayserver/agent/timer_handler'
 
+
 module Baykit
   module BayServer
     module Agent
@@ -17,20 +19,19 @@ module Baykit
 
           include Baykit::BayServer::Rudders
           include Baykit::BayServer::Util
+          include Baykit::BayServer::Common
 
           class ChannelOperation
 
             attr :rudder
             attr_accessor :op
             attr_accessor :to_connect
-            attr_accessor :to_close
 
 
-            def initialize(rd, op, to_connect, to_close)
+            def initialize(rd, op, to_connect)
               @rudder = rd
               @op = op
               @to_connect = to_connect
-              @to_close = to_close
             end
           end
 
@@ -46,7 +47,18 @@ module Baykit
             @anchorable = anchorable
             @operations = []
             @operations_lock = Mutex.new
-            @selector = Selector.new
+
+            begin
+              require "nio4r"  # gem: nio4r
+              require 'baykit/bayserver/util/nio_selector'
+              @selector = NioSelector.new
+            rescue LoadError => e
+              BayLog.debug_e(e, "nio4r gem is not installed. Use Selector instead.")
+              require 'baykit/bayserver/util/rb_selector'
+              @selector = RbSelector.new
+            end
+
+
             @select_wakeup_pipe = IO.pipe
             @selector.register(@select_wakeup_pipe[0], Selector::OP_READ)
 
@@ -75,9 +87,15 @@ module Baykit
             rd.set_non_blocking
 
             begin
-              rd.io.connect(adr)
+              rd.io.connect_nonblock(adr)
             rescue IO::WaitWritable => e
-              #BayLog.error_e(e)
+              # In non-blocking mode, connect_nonblock raises IO::WaitWritable by design
+              # to signal an in-progress connection (this is expected and not an error).
+            rescue Errno::EISCONN
+              # Connection has been successfully established
+            rescue SystemCallError => e
+              @agent.send_error_letter(st.id, rd, self, e, false)
+              return
             end
 
             st.connecting = true
@@ -95,17 +113,18 @@ module Baykit
             end
           end
 
-          def req_write(rd, buf,adr, tag, lis)
+          def req_write(rd, buf,adr, tag, &lis)
             st = get_rudder_state(rd)
-            BayLog.debug("%s req write st=%s tag=%s", @agent, st, tag)
+            BayLog.debug("%s reqWrite st=%s tag=%s", @agent, st, tag)
 
-            if st == nil || st.closed
+            if st == nil
               BayLog.warn("%s Channel is closed: %s", @agent, rd)
+              lis.call()
               return
             end
 
-            unt = WriteUnit.new(buf, adr, tag, lis)
-            st.writing_lock.synchronize do
+            unt = WriteUnit.new(buf, adr, tag, &lis)
+            st.write_queue_lock.synchronize do
               st.write_queue << unt
             end
 
@@ -133,8 +152,8 @@ module Baykit
               return
             end
 
-            st.closing = true
-            add_operation(rd, Selector::OP_WRITE, false, true)
+            close_rudder(rd)
+            @agent.send_closed_letter(st.id, rd, self, false)
 
             st.access
           end
@@ -158,6 +177,10 @@ module Baykit
           end
 
           def cancel_write(st)
+            if st.rudder.closed?
+              return
+            end
+
             op = @selector.get_op(st.rudder.io) & ~Selector::OP_WRITE
             # Write OP off
             if op != Selector::OP_READ
@@ -176,8 +199,8 @@ module Baykit
           def next_write(st)
           end
 
-          def close_rudder(st)
-            @selector.unregister(st.rudder.io)
+          def close_rudder(rd)
+            @selector.unregister(rd.io)
             super
           end
 
@@ -246,23 +269,22 @@ module Baykit
           end
 
           private
-          def add_operation(rd, op, to_connect=false, to_close=false)
+          def add_operation(rd, op, to_connect=false)
             @operations_lock.synchronize do
               found = false
               @operations.each do |ch_op|
                 if ch_op.rudder == rd
                   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.rudder.inspect())
+                  BayLog.trace("%s Update operation: %s con=%s ch=%s",
+                               @agent, self.class.op_mode(ch_op.op), ch_op.to_connect, ch_op.rudder.inspect())
                 end
               end
 
               if not found
-                BayLog.trace("%s New operation: %d con=%s close=%s ch=%s", @agent, op, to_connect, to_close, rd.inspect)
-                @operations << ChannelOperation.new(rd, op, to_connect, to_close)
+                BayLog.trace("%s New operation: %d con=%s close=%s ch=%s", @agent, op, to_connect, rd.inspect)
+                @operations << ChannelOperation.new(rd, op, to_connect)
               end
             end
 
@@ -303,12 +325,6 @@ module Baykit
                       st.connecting = true
                     end
 
-                  elsif rd_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
@@ -327,17 +343,14 @@ module Baykit
             #BayLog.info("%s handle_channel io=%s op=%d", self, io, op)
             st = find_rudder_state_by_key(io)
             if st == nil
-              BayLog.error("Cannot find fd state (Maybe file is closed)")
+              BayLog.debug("Cannot find fd state (Maybe file is closed)")
               @selector.unregister(io)
               return
             end
 
             begin
 
-              if st.closing
-                on_close_req(st)
-
-              elsif st.connecting
+              if st.connecting
                 on_connectable(st)
 
                 st.connecting = false
@@ -394,9 +407,7 @@ module Baykit
               raise e
 
             rescue => e
-              if e.kind_of? EOFError
-                BayLog.debug("%s Socket closed by peer: skt=%s", @agent, st.rudder.inspect)
-              elsif e.kind_of? SystemCallError
+              if e.kind_of? SystemCallError
                 BayLog.debug("%s O/S error: %s (skt=%s)", @agent, e.message, st.rudder.inspect)
               elsif e.kind_of? IOError
                 BayLog.debug("%s IO error: %s (skt=%s)", @agent, e.message, st.rudder.inspect)
@@ -408,7 +419,7 @@ module Baykit
               end
               # Cannot handle Exception any more
               BayLog.error_e(e)
-              next_action = NextSocketAction::CLOSE
+              @agent.send_error_letter(st.id, st.rudder, self, e, false)
             end
 
             st.access()
@@ -429,7 +440,7 @@ module Baykit
             client_rd.set_non_blocking
             #client_skt.fcntl(Fcntl::F_SETFL, Fcntl::O_NONBLOCK)
 
-            @agent.send_accepted_letter(st, client_rd, nil, false)
+            @agent.send_accepted_letter(st.id, st.rudder, self, client_rd, false)
 
           end
 
@@ -437,16 +448,18 @@ module Baykit
             BayLog.trace("%s onConnectable", self)
 
             # check connected
-            begin
-              buf = ""
-              st.rudder.io.syswrite(buf)
-            rescue => e
-              BayLog.error("Connect failed: %s", e)
-              @agent.send_connected_letter(st, e, false)
-              return
+            err = st.rudder.io.getsockopt(Socket::SOL_SOCKET, Socket::SO_ERROR).int
+            if err != 0
+              BayLog.error("Connect failed: errno=%d", err)
+              begin
+                raise SystemCallError.new("connect", err)
+              rescue SystemCallError => e
+                @agent.send_error_letter(st.id, st.rudder, self, e, false)
+              end
+            else
+              @agent.send_connected_letter(st.id, st.rudder, self, false)
             end
 
-            @agent.send_connected_letter(st, nil, false)
           end
 
           def on_readable(st)
@@ -456,28 +469,9 @@ module Baykit
 
             begin
               if st.handshaking
-                begin
-                  # Calls accept API for client socket
-                  st.rudder.io.accept_nonblock
+                if handshake(st)
                   st.handshaking = false
-
-                  BayLog.debug("%s Handshake done (rd=%s)", self, st.rudder)
-                  app_protocols = st.rudder.io.context.alpn_protocols
-
-                  # HELP ME
-                  #   This code does not work!
-                  #   We cannot get application protocol name
-                  proto = nil
-                  if app_protocols != nil && app_protocols.length > 0
-                    proto = app_protocols[0]
-                  end
-
-                rescue IO::WaitReadable => e
-                  BayLog.debug("%s Handshake status: read more st=%s", self, st)
-                  return NextSocketAction::CONTINUE
-                rescue IO::WaitWritable => e
-                  BayLog.debug("%s Handshake status: write more st=%s", self, st)
-                  req_write(st.rudder, "", nil, nil, nil)
+                else
                   return NextSocketAction::CONTINUE
                 end
               end
@@ -491,49 +485,66 @@ module Baykit
                 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)
-                len = 0
               end
 
               BayLog.debug("%s read %d bytes", self, len)
-              @agent.send_read_letter(st, len, nil, nil, false)
+              @agent.send_read_letter(st.id, st.rudder, self, len, nil, false)
 
             rescue Exception => e
               BayLog.debug_e(e, "%s Unhandled error", self)
-              @agent.send_read_letter(st, -1, nil, e, false)
+              @agent.send_error_letter(st.id, st.rudder, self, e, false)
               return
             end
           end
 
           def on_writable(st)
             begin
+              if st.handshaking
+                if handshake(st)
+                  st.handshaking = false
+                else
+                  return NextSocketAction::CONTINUE
+                end
+              end
+
               if st.write_queue.empty?
-                raise IOError.new(@agent.to_s + " No data to write: " + st.rudder.to_s)
+                #raise IOError.new(@agent.to_s + " No data to write: " + st.rudder.to_s)
+                BayLog.debug("%s No data to write: tp=%s rd=%s", self, st.transporter, st.rudder)
+                return
               end
 
-              wunit = st.write_queue[0]
+              st.write_queue.length.times do |i|
+                wunit = st.write_queue[i]
+
+                BayLog.debug("%s Try to write: rd=%s pkt=%s len=%d adr=%s",
+                             self, st.rudder, wunit.tag, wunit.buf.length, wunit.adr)
+                #BayLog.debug(this + " " + new String(wUnit.buf.array(), 0, wUnit.buf.limit()));
+
+                begin
+                  n = st.rudder.write(wunit.buf)
+                rescue OpenSSL::SSL::SSLErrorWaitWritable, IO::WaitWritable => e
+                  BayLog.debug_e(e, "%s Cannot write data", self)
+                  n = 0
+                end
+
+                #BayLog.debug("%s Wrote: rd=%s len=%d",self, st.rudder, n);
+                @agent.send_wrote_letter(st.id, st.rudder, self, n, false)
 
-              BayLog.debug("%s Try to write: rd=%s pkt=%s len=%d closed=%s adr=%s",
-                           self, st.rudder, wunit.tag, wunit.buf.length, st.closed, wunit.adr);
-              #BayLog.debug(this + " " + new String(wUnit.buf.array(), 0, wUnit.buf.limit()));
+                len = wunit.buf.length
+                wunit.buf.slice!(0, n)
 
-              n = st.rudder.write(wunit.buf)
-              #BayLog.debug("%s Wrote: rd=%s len=%d",self, st.rudder, n);
-              wunit.buf.slice!(0, n)
-              @agent.send_wrote_letter(st, n, nil, false)
+                if n < len
+                  BayLog.debug("%s Wrote %d bytes (Data remains)", self, n)
+                  break
+                end
+              end
 
             rescue SystemCallError, IOError => e
               BayLog.debug_e(e, "%s IO error", self)
-              @agent.send_wrote_letter(st, -1, e, false)
+              @agent.send_error_letter(st.id, st.rudder, self, e, false)
             end
           end
 
-          def on_close_req(st)
-            BayLog.debug("%s onCloseReq: rd=%s", self, st.rudder)
-            @agent.send_close_req_letter(st, false)
-          end
-
           def on_waked_up
             #BayLog.debug("%s waked up", self)
             val = IOUtil.read_int32(@select_wakeup_pipe[0])
@@ -554,6 +565,33 @@ module Baykit
 
             return mode_str
           end
+
+          def handshake(st)
+            begin
+              # Calls accept API for client socket
+              st.rudder.io.accept_nonblock
+
+              BayLog.debug("%s Handshake done (rd=%s)", self, st.rudder)
+              app_protocols = st.rudder.io.context.alpn_protocols
+
+              # HELP ME
+              #   This code does not work!
+              #   We cannot get application protocol name
+              proto = nil
+              if app_protocols != nil && app_protocols.length > 0
+                proto = app_protocols[0]
+              end
+
+              return true
+            rescue IO::WaitReadable => e
+              BayLog.debug("%s Handshake status: read more st=%s", self, st)
+              return false
+            rescue IO::WaitWritable => e
+              BayLog.debug("%s Handshake status: write more st=%s", self, st)
+              req_write(st.rudder, "", nil, nil)
+              return false
+            end
+          end
         end
       end
     end

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

@@ -14,14 +14,19 @@ module Baykit
 
           include Baykit::BayServer::Rudders
           include Baykit::BayServer::Util
+          include Baykit::BayServer::Common
 
           class Lapper  # abstract class
 
+            attr :multiplexer
+            attr :state_id
             attr :state
             attr :last_access
 
-            def initialize(state)
+            def initialize(mpx, state)
+              @multiplexer = mpx
               @state = state
+              @state_id = state.id
               access
             end
 
@@ -46,8 +51,8 @@ module Baykit
 
             attr :agent
 
-            def initialize(agt, st)
-              super(st)
+            def initialize(mpx, agt, st)
+              super(mpx, st)
               @agent = agt
               st.rudder.set_non_blocking
             end
@@ -61,10 +66,9 @@ module Baykit
 
                 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
+                  if n == 0
+                    eof = true
+                  end
                 rescue Errno::EAGAIN => e
                   BayLog.debug("%s %s", @agent, e)
                   return true
@@ -78,12 +82,11 @@ module Baykit
                   end
                 end
 
-                @agent.send_read_letter(@state, @state.read_buf.length, nil, nil, false)
+                @agent.send_read_letter(@state_id, @state.rudder, @multiplexer, @state.read_buf.length, nil, false)
                 return false
 
               rescue Exception => e
-                BayLog.error_e(e, "%s Error", @agent)
-                @agent.send_close_req_letter(@state, false)
+                @agent.send_error_letter(@state_id, @state.rudder, @multiplexer, e, false)
                 return false
               end
             end
@@ -141,13 +144,14 @@ module Baykit
             end
           end
 
-          def req_write(rd, buf, len, adr, tag, lis)
+          def req_write(rd, buf, adr, tag, &lis)
             st = get_rudder_state(rd)
             if st == nil
-              raise IOError("Invalid rudder")
+              BayLog.warn("Invalid rudder")
+              lis.call()
             end
 
-            unt = WriteUnit.new(buf, adr, tag, lis)
+            unt = WriteUnit.new(buf, adr, tag, &lis)
             st.write_queue_lock.synchronize do
               st.write_queue << unt
             end
@@ -174,7 +178,8 @@ module Baykit
           def req_close(rd)
             st = get_rudder_state(rd)
             st.closing = true
-            @agent.send_close_req_letter(st, false)
+            close_rudder(rd)
+            @agent.send_closed_letter(st.id, st.rudder, self, false)
           end
 
 
@@ -206,7 +211,7 @@ module Baykit
           end
 
           def next_read(st)
-            lpr = ReadIOLapper.new(@agent, st)
+            lpr = ReadIOLapper.new(self, @agent, st)
             lpr.next
 
             add_to_running_list(lpr)
@@ -266,7 +271,7 @@ module Baykit
               spun = lpr.lap
               st.access
 
-              all_spun = all_spun & spun
+              all_spun = all_spun && spun
             end
 
             if all_spun
@@ -287,11 +292,11 @@ module Baykit
           #########################################
           private
 
-          def remove_from_running_list(st)
-            BayLog.debug("remove: %s", st.rudder)
+          def remove_from_running_list(rd)
+            BayLog.debug("remove: %s", rd)
             @running_list_lock.synchronize do
               @running_list.delete_if do |lpr |
-                lpr.state == st
+                lpr.state.rudder == rd
               end
             end
           end

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

@@ -21,9 +21,9 @@ module Baykit
             end
             def depart
               if @for_read
-                @rudder_state.multiplexer.do_next_read(@rudder_state)
+                @rudder_state.multiplexer.do_next_read(@rudder_state.rudder)
               else
-                @rudder_state.multiplexer.do_next_write(@rudder_state)
+                @rudder_state.multiplexer.do_next_write(@rudder_state.rudder)
               end
             end
 
@@ -40,6 +40,7 @@ module Baykit
           include Baykit::BayServer::Rudders
           include Baykit::BayServer::Util
           include Baykit::BayServer::Taxi
+          include Baykit::BayServer::Common
 
           def initialize(agt)
             super
@@ -83,17 +84,18 @@ module Baykit
             st.access
           end
 
-          def req_write(rd, buf, adr, tag, lis)
+          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
+            if st == nil
               BayLog.warn("%s Channel is closed: %s", @agent, rd)
+              lis.call
               return
             end
 
-            unt = WriteUnit.new(buf, adr, tag, lis)
-            st.writing_lock.synchronize do
+            unt = WriteUnit.new(buf, adr, tag, &lis)
+            st.write_queue_lock.synchronize do
               st.write_queue << unt
             end
 
@@ -113,9 +115,10 @@ module Baykit
           end
 
           def req_close(rd)
+            BayLog.debug("%s reqClose rd=%s", @agent, rd);
+            close_rudder(rd)
             st = get_rudder_state(rd)
-            BayLog.debug("%s reqClose st=%s", @agent, st);
-            close_rudder(st)
+            @agent.send_closed_letter(st.id, rd, self, true)
             st.access
           end
 
@@ -153,22 +156,25 @@ module Baykit
             TaxiRunner.post(@agent.agent_id, TaxiForMpx.new(st, for_read))
           end
 
-          def do_next_read(st)
-            st.access
+          def do_next_read(rd)
+            st = get_rudder_state(rd)
+
             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)
+              @agent.send_read_letter(st.id, rd, self, len, nil, true)
 
             rescue Exception => e
-              @agent.send_read_letter(st, -1, nil, e, true)
+              @agent.send_error_letter(st.id, rd, self, e, true)
             end
           end
 
-          def do_next_write(st)
+          def do_next_write(rd)
+            st = get_rudder_state(rd)
             st.access
+
             begin
               if st.write_queue.empty?
                 raise Sink("%s write queue is empty", self)
@@ -181,10 +187,10 @@ module Baykit
                 len = st.rudder.write(u.buf)
                 u.buf.slice!(0, len)
               end
-              @agent.send_wrote_letter(st, len, nil, true)
+              @agent.send_wrote_letter(st.id, rd, self, len, true)
 
             rescue Exception => e
-              @agent.send_wrote_letter(st, -1, e, true)
+              @agent.send_error_letter(st.id, rd, self, e, true)
             end
           end
         end

data/lib/baykit/bayserver/bay_log.rb

@@ -81,6 +81,10 @@ module Baykit
       end
 
       def self.log(lvl, stack_idx, err, fmt, args)
+        if lvl < @log_level
+          return
+        end
+
         #pos = caller[1].split("/")[-1]
         apos = parse_caller(caller[1])
         if(!@full_path)
@@ -90,22 +94,20 @@ module Baykit
         #pos = caller[1]
 
         if fmt != nil
-          if lvl >= @log_level
-            begin
-              if args == nil || args.length == 0
-                msg = sprintf("%s", fmt)
-              else
-                msg = sprintf(fmt, *args)
-              end
-            rescue => e
-              puts(e.class)
-              puts(e.message + " " + pos)
-              print_exception(e)
-              msg = fmt
+          begin
+            if args == nil || args.length == 0
+              msg = sprintf("%s", fmt)
+            else
+              msg = sprintf(fmt, *args)
             end
-
-            print("[#{Time.now}] #{LOG_LEVEL_NAME[lvl]}. #{msg} (at #{pos})\n")
+          rescue => e
+            puts(e.class)
+            puts(e.message + " " + pos)
+            print_exception(e)
+            msg = fmt
           end
+
+          print("[#{Time.now}] #{LOG_LEVEL_NAME[lvl]}. #{msg} (at #{pos})\n")
         end
 
         if err != nil
@@ -129,8 +131,10 @@ module Baykit
       end
 
       def self.print_exception err
-        for s in err.backtrace
-          puts "\t" + s
+        if err.backtrace != nil
+          for s in err.backtrace
+            puts "\t" + s
+          end
         end
         if err.cause
           puts "Caused by:"