bayserver-core 3.0.2 → 3.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f16ef089e90f79b3ab9ff9e3ad60146b5fc25cc1aa569981ffc2f23738e75ed4
-  data.tar.gz: 8de08a5578314ed72c24b5580da7f9b819d1a42b218db39785490725646f00c8
+  metadata.gz: 4df3cb76d96f99278b232a1deab31c4da2888d16748bb6a9aa3a7812163fa4fa
+  data.tar.gz: 53ad43da3c1929e288d2dfb22b5d96a92db55b0e513ad4d9c33a739327a8b9ab
 SHA512:
-  metadata.gz: 88238e6b083141720fd92f5816e7a66c49b39d93a656514ca81c2edfbfa312efb9daf6f34f0390ce2c035138d998e3eb56223170b47b180bc676337fb4236812
-  data.tar.gz: 137cbe39e65d8d3144e17767f49d136764a19ca9b299a8b55817daad5a1650bacc042f2561e92f21e7411706eaf0afda6e752abfb6d68223c3d2e6126c20276b
+  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

@@ -3,15 +3,15 @@ require 'objspace'
 
 require 'baykit/bayserver/sink'
 require 'baykit/bayserver/agent/command_receiver'
-require 'baykit/bayserver/agent/letter'
+require 'baykit/bayserver/agent/letters/package'
 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'
@@ -28,9 +28,11 @@ module Baykit
         include Baykit::BayServer::Train
         include Baykit::BayServer::Taxi
         include Baykit::BayServer::Agent::Signal
+        include Baykit::BayServer::Agent::Letters
         include Baykit::BayServer::Agent::Multiplexer
         include Baykit::BayServer::Docker
         include Baykit::BayServer::Util
+        include Baykit::BayServer::Common
 
         SELECT_TIMEOUT_SEC = 10
 
@@ -53,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
@@ -147,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
 
@@ -159,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
 
@@ -177,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)
@@ -201,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?
@@ -218,23 +210,31 @@ module Baykit
                   let = @letter_queue.shift
                 end
 
-                case let.type
-                when Letter::ACCEPTED
-                  on_accept(let)
-                when Letter::CONNECTED
-                  on_connect(let)
-                when Letter::READ
-                  on_read(let)
-                when Letter::WROTE
-                  on_wrote(let)
-                when Letter::CLOSEREQ
-                  on_close_req(let)
+                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, st)
+                when ConnectedLetter
+                  on_connected(let, st)
+                when ReadLetter
+                  on_read(let, st)
+                when WroteLetter
+                  on_wrote(let, st)
+                when ClosedLetter
+                  on_closed(let, st)
+                when ErrorLetter
+                  on_error(let, st)
                 end
               end
             end # while
 
           rescue Exception => e
-            BayLog.fatal_e(e)
+            BayLog.fatal_e(e, "Uncaught Error: %s", e)
           ensure
             BayLog.info("%s end", self)
             shutdown
@@ -283,27 +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, e, wakeup)
-          send_letter(Letter.new(Letter::ACCEPTED, st, client_rd, -1, nil, e), 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, e, wakeup)
-          send_letter(Letter.new(Letter::CONNECTED, st, nil, -1, nil, e), 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, e, wakeup)
-          send_letter(Letter.new(Letter::READ, st, nil, n, adr, e), 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, e, wakeup)
-          send_letter(Letter.new(Letter::WROTE, st, nil, n, nil, e), 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_close_req_letter(st, wakeup)
-          send_letter(Letter.new(Letter::CLOSEREQ, st, nil, -1, nil, nil), 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(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
@@ -335,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()
@@ -352,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
@@ -403,42 +423,29 @@ module Baykit
           end
         end
 
-        def on_accept(let)
+        def on_accepted(let, st)
           begin
-            if let.err != nil
-              raise let.err
-            end
-
-            p = BayServer::anchorable_port_map[let.state.rudder]
+            p = BayServer::anchorable_port_map[st.rudder]
             p.on_connected(@agent_id, let.client_rudder)
-          rescue IOError => e
-            BayLog.error_e(e)
-            next_action(let.state, NextSocketAction::CLOSE, false)
           rescue HttpException => e
-            BayLog.error_e(e)
-            let.client_rudder.close
+            st.transporter.on_error(st.rudder, e)
+            next_action(st, NextSocketAction::CLOSE, false)
           end
 
-          if !@net_multiplexer.is_busy
-            let.state.multiplexer.next_accept(let.state)
+          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_connect(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
-            if let.err != nil
-              raise let.err
-            end
-
-            next_act = st.transporter.on_connect(st.rudder)
+            next_act = st.transporter.on_connected(st.rudder)
             BayLog.debug("%s nextAct=%s", self, next_act)
           rescue IOError => e
             st.transporter.on_error(st.rudder, e)
@@ -453,19 +460,8 @@ 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
-            if let.err != nil
-              BayLog.debug("%s error on OS read %s", self, let.err)
-              raise let.err
-            end
-
             BayLog.debug("%s read %d bytes (rd=%s)", self, let.n_bytes, st.rudder)
             st.bytes_read += let.n_bytes
 
@@ -476,7 +472,7 @@ module Baykit
               next_act = st.transporter.on_read(st.rudder, st.read_buf, let.address)
             end
 
-          rescue => e
+          rescue IOError => e
             st.transporter.on_error(st.rudder, e)
             next_act = NextSocketAction::CLOSE
           end
@@ -484,71 +480,84 @@ 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
-
-          begin
-            if let.err != nil
-              BayLog.debug("%s error on OS write %s", self, let.err)
-              raise let.err
-            end
-
-            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
-
-            if st.write_queue.empty?
-              raise Sink("%s Write queue is empty: rd=%s", self, st.rudder)
-            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
 
-            unit = st.write_queue[0]
-            if unit.buf.length > 0
-              BayLog.debug("Could not write enough data buf_len=%d", unit.buf.length)
-            else
-              st.multiplexer.consume_oldest_unit(st)
-            end
+          if st.write_queue.empty?
+            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)
 
             st.writing_lock.synchronize do
               if st.write_queue.empty?
                 write_more = false
                 st.writing = false
+              else
+                write_more = true
               end
             end
+          end
 
-            if write_more
-              st.multiplexer.next_write(st)
+          if write_more
+            st.multiplexer.next_write(st)
+          else
+            if st.finale
+              # close
+              BayLog.debug("%s finale return Close", self)
+              next_action(st, NextSocketAction::CLOSE, false)
             else
-              if st.finale
-                # close
-                BayLog.debug("%s finale return Close", self)
-                next_action(st, NextSocketAction::CLOSE, false)
-              else
-                # Write off
-                st.multiplexer.cancel_write(st)
-              end
+              # Write off
+              st.multiplexer.cancel_write(st)
             end
-          rescue SystemCallError, IOError => e
-            BayLog.debug("%s IO error on wrote", self)
-            st.transporter.on_error(st.rudder, e)
-            next_action(st, NextSocketAction::CLOSE, false)
           end
         end
 
-        def on_close_req(let)
-          st = let.state
-          BayLog.debug("%s reqClose rd=%s", self, st.rudder)
-          if st.closed
-            BayLog.debug("%s Rudder is already closed: rd=%s", self, st.rudder)
-            return
+        def on_closed(let, st)
+          st.multiplexer.remove_rudder_state(st.rudder)
+
+          while st.multiplexer.consume_oldest_unit(st) do
+
           end
 
-          st.multiplexer.close_rudder(st)
-          st.access
+          if st.transporter != nil
+            st.transporter.on_closed(st.rudder)
+          end
+
+          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, 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
 
         def next_action(st, act, reading)
@@ -573,7 +582,7 @@ module Baykit
             if reading
               cancel = true
             end
-            st.multiplexer.close_rudder(st)
+            st.multiplexer.req_close(st.rudder)
 
           when NextSocketAction::SUSPEND
             if reading
@@ -596,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

@@ -0,0 +1,17 @@
+module Baykit
+  module BayServer
+    module Agent
+      module Letters
+        class AcceptedLetter < Letter
+          attr :client_rudder
+
+          def initialize(state_id, rd, mpx, client_rd)
+            super(state_id, rd, mpx)
+            @client_rudder = client_rd
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,14 @@
+module Baykit
+  module BayServer
+    module Agent
+      module Letters
+        class ClosedLetter < Letter
+          def initialize(state_id, rd, mpx)
+            super state_id, rd, mpx
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,14 @@
+module Baykit
+  module BayServer
+    module Agent
+      module Letters
+        class ConnectedLetter < Letter
+          def initialize(state_id, rd, mpx)
+            super state_id, rd, mpx
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,16 @@
+module Baykit
+  module BayServer
+    module Agent
+      module Letters
+        class ErrorLetter < Letter
+          attr :err
+          def initialize(state_id, rd, mpx, err)
+            super state_id, rd, mpx
+            @err = err
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,19 @@
+module Baykit
+  module BayServer
+    module Agent
+      module Letters
+        class Letter
+          attr :state_id
+          attr :rudder
+          attr :multiplexer
+          def initialize(state_id, rd, mpx)
+            @state_id = state_id
+            @rudder = rd
+            @multiplexer = mpx
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,9 @@
+require 'baykit/bayserver/agent/letters/letter'
+require 'baykit/bayserver/agent/letters/accepted_letter'
+require 'baykit/bayserver/agent/letters/closed_letter'
+require 'baykit/bayserver/agent/letters/connected_letter'
+require 'baykit/bayserver/agent/letters/error_letter'
+require 'baykit/bayserver/agent/letters/read_letter'
+require 'baykit/bayserver/agent/letters/wrote_letter'
+
+

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

@@ -0,0 +1,20 @@
+module Baykit
+  module BayServer
+    module Agent
+      module Letters
+        class ReadLetter < Letter
+
+          attr :n_bytes
+          attr :address
+
+          def initialize(state_id, rd, mpx, n, adr = "")
+            super state_id, rd, mpx
+            @n_bytes = n
+            @address = adr
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,17 @@
+module Baykit
+  module BayServer
+    module Agent
+      module Letters
+        class WroteLetter < Letter
+          attr :n_bytes
+
+          def initialize(state_id, rd, mpx, n)
+            super state_id, rd, mpx
+            @n_bytes = n
+          end
+        end
+      end
+    end
+  end
+end
+