bayserver-core 3.0.3 → 3.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9348bdf1dfc44575c6c32641abe4b528e2db7071fd9b7a55755506b0f378aff
-  data.tar.gz: d3270dd6bece78416305353131145facf4ae7d8be1aedbb6693449fe4e1447c4
+  metadata.gz: 4df3cb76d96f99278b232a1deab31c4da2888d16748bb6a9aa3a7812163fa4fa
+  data.tar.gz: 53ad43da3c1929e288d2dfb22b5d96a92db55b0e513ad4d9c33a739327a8b9ab
 SHA512:
-  metadata.gz: f3e15075fac52deabffc014ab83697557c77f77e50a09309c93fd6dfa3b0589efddc145f3c5099679812f27cf19e60b5d4366b4a8aae27d35a1725058d4ca9c6
-  data.tar.gz: 23210e3f3afc97b4c15080ffe7fd2a52e0d8b51724ffe723d4e4c40f4a10715cc77ca3feba8e4f394de5cbf68ccf321e0ef714d14dc872d0c87ab12b863562c7
+  metadata.gz: c0005c9f1ae41149009d37a7c18fc795e0957a437b40d9f80efa13cd4504317ef3e34524f47d79eb91b2a23fc23575af2e337dbe5f6c110fd3bfc30895fc57e3
+  data.tar.gz: 13a49be5a1cbde27fd6986b6e05af2937cc3ee5bb8961d33d7246850596a52422d738a09bdb7adff6c07f68e923157e6058e2c5e0c95714db50dfa2c00a5b840

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

@@ -14,9 +14,11 @@ module Baykit
         include Baykit::BayServer::Agent::Monitor
         include Baykit::BayServer::Util
 
+        attr :closed
 
         def init(agt_id, rd, tp)
           super
+          @closed = false
         end
 
         def to_s()

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

@@ -8,10 +8,10 @@ require 'baykit/bayserver/agent/multiplexer/spider_multiplexer'
 require 'baykit/bayserver/agent/multiplexer/spin_multiplexer'
 require 'baykit/bayserver/agent/multiplexer/job_multiplexer'
 require 'baykit/bayserver/agent/multiplexer/taxi_multiplexer'
-require 'baykit/bayserver/agent/multiplexer/rudder_state'
 require 'baykit/bayserver/agent/monitor/grand_agent_monitor'
 require 'baykit/bayserver/agent/signal/signal_agent'
 
+require 'baykit/bayserver/common/rudder_state'
 require 'baykit/bayserver/docker/harbor'
 
 require 'baykit/bayserver/train/train_runner'
@@ -32,6 +32,7 @@ module Baykit
         include Baykit::BayServer::Agent::Multiplexer
         include Baykit::BayServer::Docker
         include Baykit::BayServer::Util
+        include Baykit::BayServer::Common
 
         SELECT_TIMEOUT_SEC = 10
 
@@ -54,9 +55,7 @@ module Baykit
         attr :taxi_multiplexer
         attr :recipient
 
-        attr :send_wakeup_pipe
         attr :max_inbound_ships
-        attr :unanchorable_transporters
         attr :aborted
         attr :command_receiver
         attr :timer_handlers
@@ -148,7 +147,6 @@ module Baykit
           BayLog.info(BayMessage.get(:MSG_RUNNING_GRAND_AGENT, self))
 
           if @net_multiplexer.is_non_blocking
-            BayLog.info("rec=%s", @command_receiver)
             @command_receiver.rudder.set_non_blocking
           end
 
@@ -160,7 +158,9 @@ module Baykit
               if @net_multiplexer.is_non_blocking
                 rd.set_non_blocking
               end
-              @net_multiplexer.add_rudder_state(rd, RudderState.new(rd))
+              st = RudderStateStore.get_store(@agent_id).rent
+              st.init(rd)
+              @net_multiplexer.add_rudder_state(rd, st)
             end
           end
 
@@ -178,20 +178,11 @@ module Baykit
           end
 =end
 
-          busy = true
+
+          @net_multiplexer.on_free
           begin
             while true
 
-              test_busy = @net_multiplexer.is_busy
-              if test_busy != busy
-                busy = test_busy
-                if busy
-                  @net_multiplexer.on_busy
-                else
-                  @net_multiplexer.on_free
-                end
-              end
-
               if not @spin_multiplexer.is_empty
                 # If "SpinHandler" is running, the select function does not block.
                 received = @recipient.receive(false)
@@ -202,7 +193,7 @@ module Baykit
 
               if @aborted
                 BayLog.info("%s aborted by another thread", self)
-                break;
+                break
               end
 
               if @spin_multiplexer.is_empty && @letter_queue.empty?
@@ -219,19 +210,25 @@ module Baykit
                   let = @letter_queue.shift
                 end
 
+                st = let.multiplexer.get_rudder_state(let.rudder)
+                if st == nil
+                  BayLog.debug("%s rudder is already returned: %s", self, let.rudder)
+                  next
+                end
+
                 case let
                 when AcceptedLetter
-                  on_accepted(let)
+                  on_accepted(let, st)
                 when ConnectedLetter
-                  on_connected(let)
+                  on_connected(let, st)
                 when ReadLetter
-                  on_read(let)
+                  on_read(let, st)
                 when WroteLetter
-                  on_wrote(let)
+                  on_wrote(let, st)
                 when ClosedLetter
-                  on_closed(let)
+                  on_closed(let, st)
                 when ErrorLetter
-                  on_error(let)
+                  on_error(let, st)
                 end
               end
             end # while
@@ -286,31 +283,51 @@ module Baykit
           @command_receiver = CommandReceiver.new()
           com_transporter = PlainTransporter.new(@net_multiplexer, @command_receiver, true, 8, false)
           @command_receiver.init(@agent_id, rd, com_transporter)
-          @net_multiplexer.add_rudder_state(@command_receiver.rudder, RudderState.new(@command_receiver.rudder, com_transporter))
-          BayLog.info("ComRec=%s", @command_receiver)
+
+          st = RudderStateStore.get_store(@agent_id).rent
+          st.init(@command_receiver.rudder, com_transporter)
+          @net_multiplexer.add_rudder_state(@command_receiver.rudder, st)
         end
 
-        def send_accepted_letter(st, client_rd, wakeup)
-          send_letter(AcceptedLetter.new(st, client_rd), wakeup)
+        def send_accepted_letter(state_id, rd, mpx, client_rd, wakeup)
+          if rd == nil
+            raise ArgumentError.new
+          end
+          send_letter(AcceptedLetter.new(state_id, rd, mpx, client_rd), wakeup)
         end
 
-        def send_connected_letter(st, wakeup)
-          send_letter(ConnectedLetter.new(st), wakeup)
+        def send_connected_letter(state_id, rd, mpx, wakeup)
+          if rd == nil
+            raise ArgumentError.new
+          end
+          send_letter(ConnectedLetter.new(state_id, rd, mpx), wakeup)
         end
-        def send_read_letter(st, n, adr, wakeup)
-          send_letter(ReadLetter.new(st, n, adr), wakeup)
+        def send_read_letter(state_id, rd, mpx, n, adr, wakeup)
+          if rd == nil
+            raise ArgumentError.new
+          end
+          send_letter(ReadLetter.new(state_id, rd, mpx, n, adr), wakeup)
         end
 
-        def send_wrote_letter(st, n, wakeup)
-          send_letter(WroteLetter.new(st, n), wakeup)
+        def send_wrote_letter(state_id, rd, mpx, n, wakeup)
+          if rd == nil
+            raise ArgumentError.new
+          end
+          send_letter(WroteLetter.new(state_id, rd, mpx, n), wakeup)
         end
 
-        def send_closed_letter(st, wakeup)
-          send_letter(ClosedLetter.new(st), wakeup)
+        def send_closed_letter(state_id, rd, mpx, wakeup)
+          if rd == nil
+            raise ArgumentError.new
+          end
+          send_letter(ClosedLetter.new(state_id, rd, mpx), wakeup)
         end
 
-        def send_error_letter(st, err, wakeup)
-          send_letter(ErrorLetter.new(st, err), wakeup)
+        def send_error_letter(state_id, rd, mpx, err, wakeup)
+          if rd == nil
+            raise ArgumentError.new
+          end
+          send_letter(ErrorLetter.new(state_id, rd, mpx, err), wakeup)
         end
 
         def shutdown
@@ -342,7 +359,7 @@ module Baykit
 
 
         def reload_cert
-          GrandAgent.anchorable_port_map.values().each do |port|
+          BayServer.anchorable_port_map.values().each do |port|
             if port.secure()
               begin
                 port.secure_docker.reload_cert()
@@ -359,10 +376,6 @@ module Baykit
           end
         end
 
-        def count_postpone
-          return @postpone_queue.length
-        end
-
         def req_catch_up
           BayLog.debug("%s Req catchUp", self)
           if count_postpone > 0
@@ -410,8 +423,7 @@ module Baykit
           end
         end
 
-        def on_accepted(let)
-          st = let.state
+        def on_accepted(let, st)
           begin
             p = BayServer::anchorable_port_map[st.rudder]
             p.on_connected(@agent_id, let.client_rudder)
@@ -420,18 +432,16 @@ module Baykit
             next_action(st, NextSocketAction::CLOSE, false)
           end
 
-          if !@net_multiplexer.is_busy
+          if @net_multiplexer.is_busy
+            BayLog.warn("%s net multiplexer is busy: %s", self, @net_multiplexer)
+            @net_multiplexer.on_busy
+            @busy = true
+          else
             st.multiplexer.next_accept(st)
           end
         end
 
-        def on_connected(let)
-          st = let.state
-          if st.closed
-            BayLog.debug("%s Rudder is already closed: rd=%s", self, st.rudder);
-            return;
-          end
-
+        def on_connected(let, st)
           BayLog.debug("%s connected rd=%s", self, st.rudder)
           next_act = nil
           begin
@@ -450,14 +460,7 @@ module Baykit
           next_action(st, next_act, false)
         end
 
-        def on_read(let)
-          st = let.state
-          if st.closed
-            BayLog.debug("
-            %s Rudder is already closed: rd=%s", self, st.rudder)
-            return
-          end
-
+        def on_read(let, st)
           begin
             BayLog.debug("%s read %d bytes (rd=%s)", self, let.n_bytes, st.rudder)
             st.bytes_read += let.n_bytes
@@ -477,13 +480,7 @@ module Baykit
           next_action(st, next_act, true)
         end
 
-        def on_wrote(let)
-          st = let.state
-          if st.closed
-            BayLog.debug("%s Rudder is already closed: rd=%s", self, st.rudder)
-            return
-          end
-
+        def on_wrote(let, st)
           BayLog.debug("%s wrote %d bytes rd=%s qlen=%d", self, let.n_bytes, st.rudder, st.write_queue.length)
           st.bytes_wrote += let.n_bytes
 
@@ -491,19 +488,22 @@ module Baykit
             raise Sink("%s Write queue is empty: rd=%s", self, st.rudder)
           end
 
+          write_more = false
           unit = st.write_queue[0]
           if unit.buf.length > 0
             BayLog.debug("Could not write enough data buf_len=%d", unit.buf.length)
+            write_more = true
           else
+            # Removes write unit from writeQueue
             st.multiplexer.consume_oldest_unit(st)
-          end
-
-          write_more = true
 
-          st.writing_lock.synchronize do
-            if st.write_queue.empty?
-              write_more = false
-              st.writing = false
+            st.writing_lock.synchronize do
+              if st.write_queue.empty?
+                write_more = false
+                st.writing = false
+              else
+                write_more = true
+              end
             end
           end
 
@@ -521,14 +521,7 @@ module Baykit
           end
         end
 
-        def on_closed(let)
-          st = let.state
-          BayLog.debug("%s on closed rd=%s", self, st.rudder)
-          if st.closed
-            BayLog.debug("%s Rudder is already closed: rd=%s", self, st.rudder)
-            return
-          end
-
+        def on_closed(let, st)
           st.multiplexer.remove_rudder_state(st.rudder)
 
           while st.multiplexer.consume_oldest_unit(st) do
@@ -539,19 +532,31 @@ module Baykit
             st.transporter.on_closed(st.rudder)
           end
 
-          st.closed = true
-          st.access
+          RudderStateStore.get_store(@agent_id).Return(st)
+
+          if @busy && !@net_multiplexer.is_busy
+            BayLog.warn("%s net multiplexer is free: %s", self, @net_multiplexer)
+            @net_multiplexer.on_free
+            @busy = false
+          end
         end
 
-        def on_error(let)
-          begin
-            raise let.err
-          rescue SystemCallError, IOError, OpenSSL::SSL::SSLError, HttpException => e
-            BayLog.error_e(e)
-            next_action(let.state, NextSocketAction::CLOSE, false)
-          rescue => e
-            BayLog.fatal_e(e, "Cannot handle error")
-            raise e
+        def on_error(let, st)
+
+          if let.err.is_a?(SystemCallError) ||
+            let.err.is_a?(IOError) ||
+            let.err.is_a?(OpenSSL::SSL::SSLError) ||
+            let.err.is_a?(HttpException)
+
+            if st.transporter != nil
+              st.transporter.on_error(st.rudder, let.err)
+            else
+              BayLog.error_e(let.err, "%s onError error=%s", self, let.err);
+            end
+            next_action(st, NextSocketAction::CLOSE, false)
+          else
+            BayLog.fatal_e(let.e, "Cannot handle error")
+            raise let.e
           end
         end
 
@@ -600,6 +605,9 @@ module Baykit
           st.access
         end
 
+        def count_postpone
+          return @postpone_queue.length
+        end
 
         ######################################################
         # class methods

data/lib/baykit/bayserver/agent/letters/accepted_letter.rb

@@ -5,8 +5,8 @@ module Baykit
         class AcceptedLetter < Letter
           attr :client_rudder
 
-          def initialize(st, client_rd)
-            super(st)
+          def initialize(state_id, rd, mpx, client_rd)
+            super(state_id, rd, mpx)
             @client_rudder = client_rd
           end
         end

data/lib/baykit/bayserver/agent/letters/closed_letter.rb

@@ -3,8 +3,8 @@ module Baykit
     module Agent
       module Letters
         class ClosedLetter < Letter
-          def initialize(st)
-            super st
+          def initialize(state_id, rd, mpx)
+            super state_id, rd, mpx
           end
         end
       end

data/lib/baykit/bayserver/agent/letters/connected_letter.rb

@@ -3,8 +3,8 @@ module Baykit
     module Agent
       module Letters
         class ConnectedLetter < Letter
-          def initialize(st)
-            super st
+          def initialize(state_id, rd, mpx)
+            super state_id, rd, mpx
           end
         end
       end

data/lib/baykit/bayserver/agent/letters/error_letter.rb

@@ -4,8 +4,8 @@ module Baykit
       module Letters
         class ErrorLetter < Letter
           attr :err
-          def initialize(st, err)
-            super st
+          def initialize(state_id, rd, mpx, err)
+            super state_id, rd, mpx
             @err = err
           end
         end

data/lib/baykit/bayserver/agent/letters/letter.rb

@@ -3,9 +3,13 @@ module Baykit
     module Agent
       module Letters
         class Letter
-          attr :state
-          def initialize(st)
-            @state = st
+          attr :state_id
+          attr :rudder
+          attr :multiplexer
+          def initialize(state_id, rd, mpx)
+            @state_id = state_id
+            @rudder = rd
+            @multiplexer = mpx
           end
         end
       end

data/lib/baykit/bayserver/agent/letters/read_letter.rb

@@ -7,8 +7,8 @@ module Baykit
           attr :n_bytes
           attr :address
 
-          def initialize(st, n, adr = "")
-            super st
+          def initialize(state_id, rd, mpx, n, adr = "")
+            super state_id, rd, mpx
             @n_bytes = n
             @address = adr
           end

data/lib/baykit/bayserver/agent/letters/wrote_letter.rb

@@ -5,8 +5,8 @@ module Baykit
         class WroteLetter < Letter
           attr :n_bytes
 
-          def initialize(st, n)
-            super st
+          def initialize(state_id, rd, mpx, n)
+            super state_id, rd, mpx
             @n_bytes = n
           end
         end

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
 
@@ -75,19 +73,6 @@ module Baykit
             GrandAgentMonitor.agent_aborted @agent_id, @child_pid, @anchorable
           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
-          end
-
           def shutdown()
             BayLog.debug("%s send shutdown command", self)
             send(GrandAgent::CMD_SHUTDOWN)
@@ -136,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
@@ -160,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
 
@@ -245,9 +229,23 @@ module Baykit
 
           def self.join
             while !@monitors.empty?
+              err = nil
               @monitors.values.each do |mon|
-                mon.child_thread.join
-                sleep 5
+                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