bayserver-core 2.2.2 → 2.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3384e309df7bc1a51935394fa90199ec3037f2a40978a6612e5c4a8ae826cdbf
-  data.tar.gz: 0dd2baf7f2cf5878eda0fcace793d50f3dce873962c983e3d49fe899542cf158
+  metadata.gz: 2f0a7628ec3be8f1d727392730648c785b8018968fb343dc20434549ae60abae
+  data.tar.gz: 0ef73388d47ef99c304a1b0aaaa951eec6d25222a5fbb0bd71e7f6aeb37edebd
 SHA512:
-  metadata.gz: 3a84b96eba136c9bf08ec77ced8300289967bbe4a55d0aa9bdf66a4ceaad72dc0e27409878b92faf9f594ea11ed48dcff58fbc669b38daad37ef163c6d7b7bae
-  data.tar.gz: 64f1d19b52431b7f0986be35723231ea56ed17941314ce44ecab9d4a26296dc89e60f7a179f1eb71a4e5e3719de7d6630ac38a01f97a63ec20b2655707fba5f2
+  metadata.gz: cd9122b0cfaf0eae17477d39ec7fd9e323a7944210222a6182861a91a11087da69560d4e70bca2f25c14f76804af0e57ffbf09c3c5fd2f5337b80351e98a74d6
+  data.tar.gz: 32b56a60249f626736a1102681cabbc1dec4f7dca68ee8e156c5a42930a04b38c69ca77aeef8eedc979d3ca419b5371ccb12ee1d758675c1af1b3facda28f439

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

@@ -37,7 +37,7 @@ module Baykit
               when GrandAgent::CMD_MEM_USAGE
                 @agent.print_usage()
               when GrandAgent::CMD_SHUTDOWN
-                @agent.shutdown()
+                @agent.req_shutdown()
                 @aborted = true
               when GrandAgent::CMD_ABORT
                 IOUtil.write_int32(@communication_channel, GrandAgent::CMD_OK)

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

@@ -1,4 +1,5 @@
 require 'socket'
+require 'objspace'
 
 require 'baykit/bayserver/sink'
 require 'baykit/bayserver/agent/accept_handler'
@@ -23,15 +24,6 @@ module Baykit
         include Baykit::BayServer::Agent::Signal
         include Baykit::BayServer::Util
 
-        module GrandAgentLifecycleListener
-          #
-          # interface
-          #
-          #             void add(int agentId);
-          #             void remove(int agentId);
-          #
-        end
-
         SELECT_TIMEOUT_SEC = 10
 
         CMD_OK = 0
@@ -54,6 +46,7 @@ module Baykit
         attr :unanchorable_transporters
         attr :aborted
         attr :command_receiver
+        attr :timer_handlers
 
         class << self
           attr :agents
@@ -83,6 +76,7 @@ module Baykit
           @agent_id = agent_id
           @anchorable = anchorable
 
+          @timer_handlers = []
           if @anchorable
             @accept_handler = AcceptHandler.new(self, GrandAgent.anchorable_port_map)
           else
@@ -102,7 +96,7 @@ module Baykit
 
 
         def to_s()
-          return "Agt#" + @agent_id.to_s
+          return "agt#" + @agent_id.to_s
         end
 
 
@@ -131,92 +125,90 @@ module Baykit
           busy = true
           begin
             while not @aborted
-              begin
-                count = -1
-
-                if @accept_handler
-                  test_busy = @accept_handler.ch_count >= @max_inbound_ships
-                  if test_busy != busy
-                    busy = test_busy
-                    if busy
-                      @accept_handler.on_busy()
-                    else
-                      @accept_handler.on_free()
-                    end
+
+              count = -1
+
+              if @accept_handler
+                test_busy = @accept_handler.ch_count >= @max_inbound_ships
+                if test_busy != busy
+                  busy = test_busy
+                  if busy
+                    @accept_handler.on_busy()
+                  else
+                    @accept_handler.on_free()
                   end
                 end
+              end
 
-                if !busy && @selector.count() == 2
-                  # agent finished
-                  BayLog.debug("%s Selector has no key", self)
-                  break
-                end
+              if !busy && @selector.count() == 2
+                # agent finished
+                BayLog.debug("%s Selector has no key", self)
+                break
+              end
 
-                if !@spin_handler.empty?
-                  timeout = 0
-                else
-                  timeout = @select_timeout_sec
-                end
+              if !@spin_handler.empty?
+                timeout = 0
+              else
+                timeout = @select_timeout_sec
+              end
 
-                #@BayServer.debug("Selecting... read=" + read_list.to_s)
-                selected_map = @selector.select(timeout)
-                #BayLog.debug("%s selected: %s", self, selected_map)
+              if @aborted
+                BayLog.info("%s aborted by another thread", self)
+                break
+              end
+              #@BayServer.debug("Selecting... read=" + read_list.to_s)
+              selected_map = @selector.select(timeout)
+              #BayLog.debug("%s selected: %s", self, selected_map)
 
-                processed = @non_blocking_handler.register_channel_ops() > 0
+              processed = @non_blocking_handler.register_channel_ops() > 0
 
-                if selected_map.length == 0
-                  # No channel is selected
-                  processed |= @spin_handler.process_data()
-                end
+              if @aborted
+                BayLog.info("%s aborted by another thread", self)
+                break
+              end
 
-                selected_map.keys().each do |ch|
-                  if ch == @select_wakeup_pipe[0]
-                    # Waked up by ask_to_*
-                    on_waked_up(ch)
-                  elsif ch == @command_receiver.communication_channel
-                    @command_receiver.on_pipe_readable()
-                  elsif @accept_handler && @accept_handler.server_socket?(ch)
-                    @accept_handler.on_acceptable(ch)
-                  else
-                    @non_blocking_handler.handle_channel(ch, selected_map[ch])
-                  end
-                  processed = true
-                end
+              if selected_map.length == 0
+                # No channel is selected
+                processed |= @spin_handler.process_data()
+              end
 
-                if not processed
-                  # timeout check
-                  @non_blocking_handler.close_timeout_sockets()
-                  @spin_handler.stop_timeout_spins()
+              selected_map.keys().each do |ch|
+                if ch == @select_wakeup_pipe[0]
+                  # Waked up by ask_to_*
+                  on_waked_up(ch)
+                elsif ch == @command_receiver.communication_channel
+                  @command_receiver.on_pipe_readable()
+                elsif @accept_handler && @accept_handler.server_socket?(ch)
+                  @accept_handler.on_acceptable(ch)
+                else
+                  @non_blocking_handler.handle_channel(ch, selected_map[ch])
                 end
+                processed = true
+              end
 
-              rescue => e
-                raise e
+              if not processed
+                # timeout check
+                @timer_handlers.each do |h|
+                  h.on_timer()
+                end
               end
+
             end # while
 
           rescue => e
-            BayLog.error_e(e)
-            raise e
+            BayLog.fatal(e)
           ensure
             BayLog.info("%s end", self)
-            abort_agent(nil, 0)
+            shutdown()
           end
         end
 
         def shutdown()
-          BayLog.debug("%s shutdown", self)
+          BayLog.info("%s shutdown", self)
+
           if @accept_handler != nil
             @accept_handler.shutdown()
           end
-          @aborted = true
-          wakeup()
-        end
-
-        def abort_agent(err = nil, status = 1)
-          if err
-            BayLog.fatal("%s abort", self)
-            BayLog.fatal_e(err)
-          end
 
           @command_receiver.end()
           GrandAgent.listeners.each do |lis|
@@ -224,14 +216,20 @@ module Baykit
           end
 
           GrandAgent.agents.delete(@agent_id)
+          clean()
 
           if BayServer.harbor.multi_core
             exit(1)
-          else
-            clean()
           end
+        end
 
+        def abort_agent()
+          BayLog.info("%s abort", self)
+        end
+
+        def req_shutdown()
           @aborted = true
+          wakeup()
         end
 
         def reload_cert()
@@ -248,8 +246,15 @@ module Baykit
 
         def print_usage()
           # print memory usage
-          BayLog.info("Agent#%d MemUsage", @agent_id);
-          MemUsage.get(@agent_id).print_usage(1);
+          BayLog.info("%s MemUsage", self)
+          BayLog.info("  Ruby version: %s", RUBY_VERSION)
+          memsize = ObjectSpace.memsize_of_all
+          # formatted by comma
+          msize_comma = memsize.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse.then do |str|
+            str[0] == ',' ? str[1..-1] : str
+          end
+          BayLog.info("  Total object size: %s bytes", msize_comma)
+          MemUsage.get(@agent_id).print_usage(1)
         end
 
         def wakeup
@@ -261,6 +266,14 @@ module Baykit
           @command_receiver = CommandReceiver.new(self, com_channel)
         end
 
+        def add_timer_handler(handler)
+          @timer_handlers << handler
+        end
+
+        def remove_timer_handler(handler)
+          @timer_handlers.delete(handler)
+        end
+
         private
         def on_waked_up(pipe_fd)
           #BayLog.debug("%s waked up", self)

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

@@ -69,6 +69,7 @@ module Baykit
         def print_usage()
           BayLog.debug("%s Send mem_usage command", self)
           send(GrandAgent::CMD_MEM_USAGE)
+          sleep(0.5)  # Lazy implementation
         end
 
         def send(cmd)

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

@@ -0,0 +1,16 @@
+
+module Baykit
+  module BayServer
+    module Agent
+      module LifecycleListener
+        #
+        # interface
+        #
+        #             void add(int agentId);
+        #             void remove(int agentId);
+        #
+      end
+    end
+  end
+end
+

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

@@ -11,6 +11,7 @@ module Baykit
         #   Sockets or file descriptors are kinds of channel
         #
         class NonBlockingHandler
+          include Baykit::BayServer::Agent::TimerHandler # implements
           include Baykit::BayServer::Agent
           include Baykit::BayServer::Util
 
@@ -78,6 +79,8 @@ module Baykit
             @ch_count = 0
             @operations = []
             @operations_lock = Monitor.new()
+
+            @agent.add_timer_handler(self)
           end
 
 
@@ -85,6 +88,18 @@ module Baykit
             return @agent.to_s()
           end
 
+          ######################################################
+          # Implements TimerHandler
+          ######################################################
+
+          def on_timer()
+            self.close_timeout_sockets()
+          end
+
+          ######################################################
+          # Custom methods
+          ######################################################
+
           def handle_channel(ch, op)
 
             ch_state = find_channel_state(ch)
@@ -106,8 +121,15 @@ module Baykit
                 next_action = ch_state.listener.on_connectable(ch)
                 if next_action == nil
                   raise Sink.new("unknown next action")
-                elsif next_action == NextSocketAction::CONTINUE
-                  ask_to_read(ch)
+                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
@@ -253,9 +275,14 @@ module Baykit
             now = DateTime.now
             @ch_map.values.each do |ch_state|
               if ch_state.listener != nil
-                duration =  ((now - ch_state.last_access_time) * 86400).to_i
-                if ch_state.listener.check_timeout(ch_state.channel, duration)
-                  BayLog.debug("%s timeout: skt=%s", @agent, ch_state.channel)
+                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
@@ -283,7 +310,7 @@ module Baykit
 
           def ask_to_connect(ch, addr)
             ch_state = find_channel_state(ch)
-            BayLog.debug("%s askToConnect addr=%s skt=%s chState=%s", @agent, addr, ch, ch_state)
+            BayLog.debug("%s askToConnect addr=%s skt=%s chState=%s", @agent, addr.ip_address, ch, ch_state)
 
             begin
               ch.connect_nonblock(addr)
@@ -292,7 +319,7 @@ module Baykit
             end
 
             ch_state.connecting = true
-            add_operation(ch, Selector::OP_READ, true)
+            add_operation(ch, Selector::OP_WRITE, true)
           end
 
           def ask_to_read(ch)
@@ -379,9 +406,12 @@ module Baykit
           def close_channel(ch, ch_state)
             BayLog.debug("%s Close chState=%s", @agent, ch_state)
 
+            ch.close()
+
             if ch_state == nil
               ch_state = find_channel_state(ch)
             end
+
             if ch_state.accepted and @agent.accept_handler
               agent.accept_handler.on_closed
             end
@@ -398,7 +428,6 @@ module Baykit
               BayLog.warn_e(e)
             end
 
-            ch.close()
           end
 
           def add_channel_state(ch, ch_state)

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

@@ -68,6 +68,7 @@ module Baykit
             begin
               a = Addrinfo.tcp(host, port)
               s = Socket.new(a.ipv4? ? Socket::AF_INET : Socket::AF_INET6, Socket::SOCK_STREAM)
+              s.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, [60, 0].pack("l_2"))
               s.connect(a)
               s.write(cmd + "\n")
               s.flush();

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

@@ -1,9 +1,12 @@
+require 'baykit/bayserver/agent/timer_handler'
 
 module Baykit
   module BayServer
     module Agent
       class SpinHandler
 
+        include Baykit::BayServer::Agent::TimerHandler # implements
+
         module SpinListener
           #
           # interface
@@ -35,12 +38,25 @@ module Baykit
           @lock = Mutex.new
           @agent = agt
           @spin_count = 0
+          @agent.add_timer_handler(self)
         end
 
         def to_s()
           return @agent.to_s()
         end
 
+        ######################################################
+        # Implements TimerHandler
+        ######################################################
+
+        def on_timer()
+          stop_timeout_spins()
+        end
+
+        ######################################################
+        # Custom methods
+        ######################################################
+        #
         def process_data()
           if @listeners.empty?
             return false

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

@@ -0,0 +1,15 @@
+
+module Baykit
+  module BayServer
+    module Agent
+      module TimerHandler # interface
+
+        def on_timer()
+          raise NotImplementedError()
+        end
+
+      end
+    end
+  end
+end
+

data/lib/baykit/bayserver/docker/base/inbound_ship.rb

@@ -65,13 +65,13 @@ module Baykit
           # Other methods
           ######################################################
 
-          def get_tour(tur_key)
+          def get_tour(tur_key, force=false, rent=true)
             tur = nil
             store_key = InboundShip.uniq_key(@ship_id, tur_key)
             @lock.synchronize do
               tur = @tour_store.get(store_key)
-              if tur == nil
-                tur = @tour_store.rent(store_key, false)
+              if tur == nil && rent
+                tur = @tour_store.rent(store_key, force)
                 if tur == nil
                   return nil
                 end
@@ -135,13 +135,7 @@ module Baykit
               @port_docker.additional_headers.each do |nv|
                 tur.res.headers.add(nv[0], nv[1])
               end
-              begin
-                @protocol_handler.send_res_headers(tur)
-              rescue IOError => e
-                BayLog.debug_e(e, "%s abort: %s", tur, e)
-                tur.change_state(Tour::TOUR_ID_NOCHECK, Tour::TourState::ABORTED)
-                raise e
-              end
+              @protocol_handler.send_res_headers(tur)
             end
           end
 
@@ -163,28 +157,12 @@ module Baykit
 
             check_ship_id(check_id)
 
-            if tur.zombie? || tur.aborted?
-              # Don't send peer any data
-              BayLog::debug("%s Aborted or zombie tour. do nothing: %s state=%s", self, tur, tur.state)
-              tur.change_state(Tour::TOUR_ID_NOCHECK, TourState::ENDED)
-              if callback != nil
-                callback.call()
-              end
-              return
-            end
-
             max_len = @protocol_handler.max_res_packet_data_size();
             if len > max_len
               send_res_content(Ship::SHIP_ID_NOCHECK, tur, bytes, ofs, max_len)
               send_res_content(Ship::SHIP_ID_NOCHECK, tur, bytes, ofs + max_len, len - max_len, &callback)
             else
-              begin
-                @protocol_handler.send_res_content(tur, bytes, ofs, len, &callback)
-              rescue IOError => e
-                BayLog.debug_e(e, "%s abort: %s", tur, e)
-                tur.change_state(Tour::TOUR_ID_NOCHECK, Tour::TourState::ABORTED)
-                raise e
-              end
+              @protocol_handler.send_res_content(tur, bytes, ofs, len, &callback)
             end
           end
 
@@ -193,34 +171,25 @@ module Baykit
               check_ship_id(chk_ship_id)
               BayLog.debug("%s sendEndTour: %s state=%s", self, tur, tur.state)
 
-              if tur.zombie? || tur.aborted?
-                # Don't send peer any data. Do nothing
-                BayLog.debug("%s Aborted or zombie tour. do nothing: %s state=%s", self, tur, tur.state)
-                tur.change_state(Tour::TOUR_ID_NOCHECK, Tour::TourState::ENDED)
-                callback.call()
-              else
-                if !tur.valid?
-                  raise Sink.new("Tour is not valid")
+              if !tur.valid?
+                raise Sink.new("Tour is not valid")
+              end
+              keep_alive = false
+              if tur.req.headers.get_connection() == Headers::CONNECTION_KEEP_ALIVE
+                keep_alive = true
+                if keep_alive
+                  res_conn = tur.res.headers.get_connection()
+                  keep_alive = (res_conn == Headers::CONNECTION_KEEP_ALIVE) ||
+                    (res_conn == Headers::CONNECTION_UNKOWN)
                 end
-                keep_alive = false
-                if tur.req.headers.get_connection() == Headers::CONNECTION_KEEP_ALIVE
-                  keep_alive = true
-                  if keep_alive
-                    res_conn = tur.res.headers.get_connection()
-                    keep_alive = (res_conn == Headers::CONNECTION_KEEP_ALIVE) ||
-                      (res_conn == Headers::CONNECTION_UNKOWN)
-                  end
-                  if keep_alive
-                    if tur.res.headers.content_length() < 0
-                      keep_alive = false
-                    end
+                if keep_alive
+                  if tur.res.headers.content_length() < 0
+                    keep_alive = false
                   end
                 end
-
-                tur.change_state(Tour::TOUR_ID_NOCHECK, Tour::TourState::ENDED)
-
-                @protocol_handler.send_end_tour(tur, keep_alive, &callback)
               end
+
+              @protocol_handler.send_end_tour(tur, keep_alive, &callback)
             end
           end
 

data/lib/baykit/bayserver/docker/base/inbound_ship_store.rb

@@ -1,4 +1,5 @@
 require 'baykit/bayserver/agent/grand_agent'
+require 'baykit/bayserver/agent/lifecycle_listener'
 
 require 'baykit/bayserver/docker/base/inbound_ship'
 require 'baykit/bayserver/docker/base/inbound_ship_store'
@@ -16,7 +17,7 @@ module Baykit
           include Baykit::BayServer::Agent
 
           class AgentListener
-            include Baykit::BayServer::Agent::GrandAgent::GrandAgentLifecycleListener # implements
+            include Baykit::BayServer::Agent::LifecycleListener # implements
 
             def add(agt)
               InboundShipStore.stores[agt.agent_id] = InboundShipStore.new();

data/lib/baykit/bayserver/docker/built_in/built_in_log_docker.rb

@@ -1,4 +1,5 @@
 require 'baykit/bayserver/agent/grand_agent'
+require 'baykit/bayserver/agent/lifecycle_listener'
 require 'baykit/bayserver/agent/transporter/plain_transporter'
 require 'baykit/bayserver/agent/transporter/spin_write_transporter'
 require 'baykit/bayserver/docker/built_in/write_file_taxi'
@@ -20,7 +21,7 @@ module Baykit
             include Baykit::BayServer::Bcf
 
             class AgentListener
-              include Baykit::BayServer::Agent::GrandAgent::GrandAgentLifecycleListener  # implements
+              include Baykit::BayServer::Agent::LifecycleListener  # implements
               include Baykit::BayServer::Agent::Transporter
 
               attr :log_docker
@@ -45,7 +46,7 @@ module Baykit
 
                 when LOG_WRITE_METHOD_TAXI
                   tp = WriteFileTaxi.new()
-                  tp.init(File.open(file_name, "a"), boat)
+                  tp.init(agt.agent_id, File.open(file_name, "a"), boat)
 
                 end
 

data/lib/baykit/bayserver/docker/built_in/write_file_taxi.rb

@@ -19,6 +19,7 @@ module Baykit
           attr :data_listener
           attr :write_queue
           attr :lock
+          attr :agent_id
 
           def initialize()
             super
@@ -26,7 +27,8 @@ module Baykit
             @lock = Mutex.new()
           end
 
-          def init(out, data_listener)
+          def init(agt_id, out, data_listener)
+            @agent_id = agt_id
             @outfile = out
             @data_listener = data_listener
             @ch_valid = true
@@ -81,6 +83,10 @@ module Baykit
             end
           end
 
+          def on_timer()
+
+          end
+
           def post(data, adr, tag)
             @lock.synchronize do
               empty = @write_queue.empty?
@@ -92,7 +98,7 @@ module Baykit
           end
 
           def next_run()
-            TaxiRunner.post(self)
+            TaxiRunner.post(@agent_id, self)
           end
         end
       end