bayserver-core 3.0.2 → 3.3.1

data/lib/baykit/bayserver/agent/monitor/grand_agent_monitor.rb

@@ -14,14 +14,12 @@ module Baykit
           class << self
             attr :num_agents
             attr :cur_id
-            attr :anchored_port_map
             attr :monitors
             attr :finale
           end
 
           @num_agents = 0
           @cur_id = 0
-          @anchored_port_map = []
           @monitors = {}
           @finale = false
 
@@ -67,23 +65,12 @@ module Baykit
 
               end
             rescue EOFError, IOError => e
-              BayLog.fatal("Agent terminated")
+              BayLog.fatal("%s Agent terminated", self)
             rescue Exception => e
               BayLog.fatal_e(e)
             end
-          end
 
-          def on_readable()
-            begin
-              res = IOUtil.read_int32(@communication_channel)
-              if res == nil || res == GrandAgent::CMD_CLOSE
-                close()
-              else
-                BayLog.debug("%s read OK: %d", self, res)
-              end
-            rescue IO::WaitReadable
-              #BayLog.debug("%s no data", self)
-            end
+            GrandAgentMonitor.agent_aborted @agent_id, @child_pid, @anchorable
           end
 
           def shutdown()
@@ -124,33 +111,6 @@ module Baykit
 
           end
 
-          def agent_aborted()
-            BayLog.info(BayMessage.get(:MSG_GRAND_AGENT_SHUTDOWN, @agent_id))
-
-            if @child_pid != nil
-              begin
-                Process.kill("TERM", @child_pid)
-              rescue => e
-                BayLog.debug_e(e, "Error on killing process")
-              end
-              Process.wait(@child_pid)
-            end
-            GrandAgentMonitor.monitors.delete(@agent_id)
-
-            if not GrandAgentMonitor.finale
-              if GrandAgentMonitor.monitors.length < GrandAgentMonitor.num_agents
-                begin
-                  if !BayServer.harbor.multi_core
-                    GrandAgent.add(-1, @anchorable)
-                  end
-                  GrandAgentMonitor.add(@anchorable)
-                rescue => e
-                  BayLog.error_e(e)
-                end
-              end
-            end
-          end
-
           def start
             @child_thread = Thread.new do
               run()
@@ -161,9 +121,8 @@ module Baykit
           # Class methods
           ########################################
 
-          def self.init(num_agents, anchored_port_map)
+          def self.init(num_agents)
             @num_agents = num_agents
-            @anchored_port_map = anchored_port_map
             @num_agents.times do
               add(true)
             end
@@ -185,12 +144,12 @@ module Baykit
               ports = ""
 
               no_close_io = {}  # Port list not to close on spawned
-              @anchored_port_map.each_key do |ch|
-                no_close_io[ch] = ch
+              BayServer.anchorable_port_map.each_key do |rd|
+                no_close_io[rd.key()] = rd.key()
                 if ports != ""
                   ports +=","
                 end
-                ports += ch.fileno.to_s
+                ports += rd.key().fileno.to_s
               end
               new_argv << "-ports=" + ports
 
@@ -241,11 +200,52 @@ module Baykit
 
           end
 
+          def self.agent_aborted(agt_id, pid, anchorable)
+            BayLog.info(BayMessage.get(:MSG_GRAND_AGENT_SHUTDOWN, agt_id))
+
+            if pid != nil
+              begin
+                Process.kill("TERM", pid)
+              rescue => e
+                BayLog.debug_e(e, "Error on killing process")
+              end
+              Process.wait(pid)
+            end
+            @monitors.delete(agt_id)
+
+            if not @finale
+              if @monitors.length < @num_agents
+                begin
+                  if !BayServer.harbor.multi_core
+                    GrandAgent.add(-1, @anchorable)
+                  end
+                  self.add(@anchorable)
+                rescue => e
+                  BayLog.error_e(e)
+                end
+              end
+            end
+          end
+
           def self.join
             while !@monitors.empty?
+              err = nil
               @monitors.values.each do |mon|
-                mon.child_thread.join
-                mon.agent_aborted
+                begin
+                  mon.child_thread.join
+                  sleep 5
+                rescue Interrupt => e
+                  err = e
+                  BayLog.error("%s Interrupted! Kill child: %d", mon, mon.child_pid)
+                  begin
+                    Process.kill("INT", mon.child_pid)
+                  rescue SystemCallError => e
+                    BayLog.error("%s Failed to kill child: %s", mon, e)
+                  end
+                end
+              end
+              if err
+                raise err
               end
             end
           end

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

@@ -15,6 +15,7 @@ module Baykit
 
           include Baykit::BayServer::Rudders
           include Baykit::BayServer::Util
+          include Baykit::BayServer::Common
 
           def initialize(agt, anchorable)
             super
@@ -35,6 +36,7 @@ module Baykit
             end
 
             st = get_rudder_state(rd)
+            id = st.id
 
             Thread.new do
               begin
@@ -45,7 +47,7 @@ module Baykit
                 begin
                   client_skt, adr = rd.io.accept
                 rescue Exception => e
-                  @agent.send_accepted_letter(st, nil, e, true)
+                  @agent.send_error_letter(id, rd, self, e, true)
                   next
                 end
 
@@ -54,7 +56,7 @@ module Baykit
                   BayLog.error("%s Agent is not alive (close)", @agent);
                   client_skt.close
                 else
-                  @agent.send_accepted_letter(st, IORudder.new(client_skt), nil, true)
+                  @agent.send_accepted_letter(id, rd, self, IORudder.new(client_skt), true)
                 end
 
               rescue Exception => e
@@ -67,20 +69,28 @@ module Baykit
 
 
           def req_connect(rd, adr)
-            st = get_rudder_state(rd)
-            BayLog.debug("%s reqConnect adr=%s rd=%s chState=%s", @agent, adr.canonname, rd, st)
+            BayLog.debug("%s reqConnect adr=%s rd=%s", @agent, adr.canonname, rd)
 
             Thread.new do
+              st = get_rudder_state(rd)
+              if st == nil
+                # rudder is already closed
+                BayLog.debug("%s Rudder is already closed: rd=%s", @agent, rd)
+                return
+              end
+
               begin
                 rd.io.connect(adr)
                 BayLog.debug("%s Connected rd=%s", @agent, rd)
-                @agent.send_connected_letter(st, nil, false)
+                @agent.send_connected_letter(st.id, rd, self, true)
               rescue Exception => e
-                @agent.send_connected_letter(st, e, false)
+                @agent.send_error_letter(st.id, rd, self, e, true)
                 return
               end
             end
 
+            st = get_rudder_state(rd)
+            st.access
             st.connecting = true
           end
 
@@ -106,17 +116,19 @@ 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
-              BayLog.warn("%s Channel is closed: %s", @agent, rd)
-              return
+            if st == nil
+              raise IOError.new("Invalid rudder")
+              #BayLog.warn("%s Channel is closed(callback immediately): %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
 
@@ -144,7 +156,9 @@ module Baykit
               return
             end
 
-            Thread.new do
+            id = st.id
+
+              Thread.new do
               begin
                 st = get_rudder_state(rd)
                 if st == nil
@@ -152,7 +166,8 @@ module Baykit
                   next
                 end
 
-                close_rudder(st)
+                close_rudder(rd)
+                @agent.send_closed_letter(id, rd, self, true)
               rescue Exception => e
                 BayLog.fatal_e(e)
                 @agent.shutdown
@@ -175,12 +190,9 @@ module Baykit
           end
 
           def next_read(st)
+            id = st.id
+
             Thread.new do
-              if st.closed
-                #channel is already closed
-                BayLog.debug("%s Rudder is already closed: rd=%s", @agent, st.rudder);
-                next
-              end
 
               begin
                 if st.handshaking
@@ -201,45 +213,48 @@ module Baykit
                 end
 
                 BayLog.debug("%s Try to Read (rd=%s)", @agent, st.rudder)
-                begin
-                  n = st.rudder.read(st.read_buf, st.buf_size)
-                rescue EOFError => e
-                  n = 0
-                  st.read_buf.clear
-                end
+                n = st.rudder.read(st.read_buf, st.buf_size)
 
-                @agent.send_read_letter(st, n, nil, nil, true)
+                if get_rudder_state(st.rudder) == nil
+                  #channel is already closed
+                  BayLog.debug("%s Rudder is already closed: rd=%s", self, st.rudder);
+                  next
+                else
+                  @agent.send_read_letter(id, st.rudder, self, n, nil, true)
+                end
 
               rescue Exception => e
-                @agent.send_read_letter(st, -1, nil, e, true)
+                @agent.send_error_letter(id, st.rudder, self, e, true)
               end
             end
           end
 
           def next_write(st)
+            id = st.id
+
             Thread.new do
               BayLog.debug("%s next write st=%s", @agent, st)
 
-              if st == nil || st.closed
+              if st == nil
                 BayLog.warn("%s Channel is closed: %s", @agent, st.rudder)
                 next
               end
 
               u = st.write_queue[0]
-              BayLog.debug("%s Try to write: pkt=%s buflen=%d closed=%s", self, u.tag, u.buf.length, st.closed);
+              BayLog.debug("%s Try to write: pkt=%s buflen=%d", self, u.tag, u.buf.length)
 
               n = 0
               begin
-                if !st.closed && u.buf.length > 0
+                if u.buf.length > 0
                   n = st.rudder.write(u.buf)
                   u.buf.slice!(0, n)
                 end
               rescue Exception => e
-                @agent.send_wrote_letter(st, -1, e, true)
+                @agent.send_error_letter(id, st.rudder, self, e, true)
                 next
               end
 
-              @agent.send_wrote_letter(st, n, nil, true)
+              @agent.send_wrote_letter(id, st.rudder, self, n, true)
             end
           end
 

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

@@ -26,7 +26,12 @@ module Baykit
             close_all()
           end
 
+          def on_busy()
+            BayLog.debug("%s onBusy (ignore)", self)
+          end
+
           def on_free()
+            BayLog.debug("%s onFree", self)
             if @agent.aborted
               return
             end

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

@@ -36,6 +36,13 @@ module Baykit
             st.access()
           end
 
+          def remove_rudder_state(rd)
+            @rudders_lock.synchronize do
+              @rudders.delete(rd.key())
+            end
+            @channel_count -= 1
+          end
+
           def get_rudder_state(rd)
             return find_rudder_state_by_key(rd.key)
           end
@@ -56,31 +63,15 @@ module Baykit
             return true
           end
 
-          def close_rudder(st)
-            BayLog.debug("%s closeRd %s state=%s closed=%s", agent, st.rudder, st, st.closed)
-
-            @lock.synchronize do
-              if st.closed
-                return
-              end
-              st.closed = true
-            end
-
-            remove_rudder_state(st.rudder)
+          def close_rudder(rd)
+            BayLog.debug("%s closeRd %s", agent, rd)
 
             begin
-              st.rudder.close()
+              rd.close()
             rescue IOError => e
               Baylog.error_e(e)
             end
 
-            while consume_oldest_unit(st) do
-
-            end
-
-            if st.transporter != nil
-              st.transporter.on_closed(st.rudder)
-            end
           end
 
           def is_busy()
@@ -98,13 +89,6 @@ module Baykit
             end
           end
 
-          def remove_rudder_state(rd)
-            @rudders_lock.synchronize do
-              @rudders.delete(rd.key())
-            end
-            @channel_count -= 1
-          end
-
           def close_timeout_sockets
             if @rudders.empty?
               return
@@ -128,7 +112,7 @@ module Baykit
             end
 
             close_list.each do |st|
-              close_rudder(st)
+              req_close(st.rudder)
             end
           end
 
@@ -139,7 +123,7 @@ module Baykit
             end
             copied.each do |st|
               if st.rudder != @agent.command_receiver.rudder
-                close_rudder(st)
+                close_rudder(st.rudder)
               end
             end
           end

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

@@ -1,4 +1,4 @@
-require 'baykit/bayserver/agent/multiplexer/transporter'
+require 'baykit/bayserver/common/transporter'
 require 'baykit/bayserver/protocol/protocol_exception'
 require 'baykit/bayserver/agent/next_socket_action'
 
@@ -7,7 +7,7 @@ module Baykit
     module Agent
       module Multiplexer
         class PlainTransporter
-          include Transporter   # Implements
+          include Baykit::BayServer::Common::Transporter   # Implements
           include Baykit::BayServer::Agent
           include Baykit::BayServer::Protocol
           include Baykit::BayServer::Util
@@ -40,15 +40,16 @@ module Baykit
 
           end
 
-          def on_connect(rd)
+          def on_connected(rd)
             BayLog.trace("%s onConnect", self)
+            check_rudder rd
 
             return @ship.notify_connect
-            ;
           end
 
           def on_read(rd, buf, adr)
             BayLog.debug("%s onRead", self)
+            check_rudder rd
 
             if buf.length == 0
               return @ship.notify_eof
@@ -78,31 +79,38 @@ module Baykit
           end
 
           def on_error(rd, e)
+            check_rudder rd
             @ship.notify_error(e)
           end
 
           def on_closed(rd)
+            check_rudder rd
             @ship.notify_close
           end
 
           def req_connect(rd, adr)
+            check_rudder rd
             @multiplexer.req_connect(rd, adr)
           end
 
           def req_read(rd)
+            check_rudder rd
             @multiplexer.req_read(rd)
           end
 
           def req_write(rd, buf, adr, tag, &lis)
-            @multiplexer.req_write(rd, buf, adr, tag, lis)
+            check_rudder rd
+            @multiplexer.req_write(rd, buf, adr, tag, &lis)
           end
 
           def req_close(rd)
+            check_rudder rd
             @closed = true
             @multiplexer.req_close(rd)
           end
 
           def check_timeout(rd, duration_sec)
+            check_rudder rd
             return @ship.check_timeout(duration_sec)
           end
 
@@ -120,6 +128,13 @@ module Baykit
           def secure()
             return false
           end
+
+          private
+          def check_rudder(rd)
+            if rd != @ship.rudder
+              raise Sink.new("Invalid rudder: %s", rd)
+            end
+          end
         end
       end
     end