bayserver-core 2.3.2 → 3.0.1

data/lib/baykit/bayserver/common/vehicle_runner.rb

@@ -0,0 +1,127 @@
+require 'baykit/bayserver/bayserver'
+require 'baykit/bayserver/agent/grand_agent'
+require 'baykit/bayserver/agent/timer_handler'
+require 'baykit/bayserver/agent/lifecycle_listener'
+require 'baykit/bayserver/util/executor_service'
+require 'baykit/bayserver/sink'
+
+module Baykit
+  module BayServer
+    module Common
+      class VehicleRunner
+
+        class AgentListener
+          include Baykit::BayServer::Agent::LifecycleListener # implements
+          include Baykit::BayServer::Agent
+
+          attr :runner
+          def initialize(runner)
+            @runner = runner
+          end
+
+          def add(agt_id)
+            while @runner.services.length < agt_id
+              @runner.services << nil
+            end
+            @runner.services[agt_id - 1] = VehicleRunner::VehicleService.new(GrandAgent.get(agt_id), @runner)
+          end
+
+          def remove(agt_id)
+            BayLog.debug("agt#%d remove VehicleRunner", agt_id)
+            @runner.services[agt_id - 1].terminate
+            @runner.services[agt_id - 1] = nil
+          end
+        end
+
+
+        class VehicleService
+          include Baykit::BayServer::Util
+
+          attr :agent
+          attr :exe
+          attr :runnings
+          attr :runnings_lock
+
+          def initialize(agt, runner)
+            @agent = agt
+            @agent.add_timer_handler(self)
+            @runnings = []
+            @runnings_lock = Mutex.new
+            @exe = ExecutorService.new("Runner", runner.max_vehicles)
+          end
+
+          ########################################
+          # Implements TimerHandler
+          ########################################
+          def on_timer
+            @runnings_lock.synchronize do
+              @runnings.each do |vcl|
+                vcl.on_timer
+              end
+            end
+          end
+
+
+          ########################################
+          # Private methods
+          ########################################
+
+          def terminate()
+            @agent.remove_timer_handler(self)
+            @exe.shutdown
+          end
+
+          def submit(vcl)
+            @exe.submit() do
+              if @agent.aborted
+                BayLog.error("%s Agent is aborted", @agent)
+                return
+              end
+
+              @runnings_lock.synchronize do
+                @runnings << vcl
+              end
+
+              begin
+                vcl.run
+              rescue => e
+                BayLog.fatal_e(e)
+                @agent.req_shutdown
+              ensure
+                @runnings_lock.synchronize do
+                  @runnings.delete(vcl)
+                end
+              end
+            end
+          end
+        end
+
+        include Baykit::BayServer::Agent
+
+        attr :max_vehicles
+        attr :services
+
+        def initialize
+          @max_vehicles = 0
+          @services = []
+        end
+
+        ########################################
+        # Custom methods
+        ########################################
+        def init(max)
+          if(max <= 0)
+            raise Sink.new()
+          end
+          @max_vehicles = max
+          GrandAgent.add_lifecycle_listener(AgentListener.new(self))
+        end
+
+        def post(agt_id, vcl)
+          @services[agt_id - 1].submit(vcl)
+        end
+
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/{docker/warp → common}/warp_data.rb

@@ -1,12 +1,13 @@
+require 'baykit/bayserver/agent/grand_agent'
 require 'baykit/bayserver/tours/req_content_handler'
 
 module Baykit
   module BayServer
-    module Docker
-      module Warp
+    module Common
         class WarpData
           include Baykit::BayServer::Tours::ReqContentHandler # implements
           include Baykit::BayServer::Util
+          include Baykit::BayServer::Agent
 
           attr :warp_ship
           attr :warp_ship_id
@@ -26,7 +27,10 @@ module Baykit
             @ended = false
           end
 
-          def on_read_content(tur, buf, start, len)
+          ################################
+          # Implements ReqContentHandler
+          ################################
+          def on_read_req_content(tur, buf, start, len, &lis)
             BayLog.debug("%s Read req content tur=%s len=%d", @warp_ship, tur, len);
             @warp_ship.check_ship_id(@warp_ship_id)
             max_len = @warp_ship.protocol_handler.max_req_packet_data_size()
@@ -44,34 +48,39 @@ module Baykit
                 buf = buf.dup()
               end
 
-              @warp_ship.warp_handler.post_warp_contents(
+              @warp_ship.warp_handler.send_res_content(
                 tur,
                 buf,
                 start + pos,
                 post_len) do
-                  tur.req.consumed(tur_id, len)
+                  tur.req.consumed(tur_id, len, &lis)
                 end
               pos += max_len
             end
           end
 
-          def on_end_content(tur)
+          def on_end_req_content(tur)
             BayLog.debug("%s End req content tur=%s", @warp_ship, tur)
             @warp_ship.check_ship_id(@warp_ship_id)
-            @warp_ship.warp_handler.post_warp_end(tur)
+            @warp_ship.warp_handler.send_end_tour(tur, false) do
+              agt = GrandAgent.get(@warp_ship.agent_id)
+              agt.net_multiplexer.req_read(@warp_ship.rudder)
+            end
           end
 
-          def on_abort(tur)
+          def on_abort_req(tur)
             BayLog.debug("%s on req abort tur=%s", @warp_ship, tur)
             @warp_ship.check_ship_id(@warp_ship_id)
             @warp_ship.abort(@warp_ship_id)
             return false # not aborted immediately
           end
 
+          ################################
+          # Other methods
+          ################################
 
           def start
             if !@started
-              @warp_ship.protocol_handler.command_packer.flush(@warp_ship)
               BayLog.debug("%s Start Warp tour", self)
               @warp_ship.flush()
               @started = true
@@ -86,7 +95,6 @@ module Baykit
             return tur.req.content_handler
           end
         end
-      end
     end
   end
 end

data/lib/baykit/bayserver/common/warp_handler.rb

@@ -0,0 +1,27 @@
+require 'baykit/bayserver/tours/tour_handler'
+
+module Baykit
+  module BayServer
+    module Common
+        module WarpHandler # interface
+          include Baykit::BayServer::Tours::TourHandler
+
+          def next_warp_id()
+            raise NotImplementedError.new
+          end
+
+          def new_warp_data(warp_id)
+            raise NotImplementedError.new
+          end
+
+          #
+          # Verify if protocol is allowed
+          #
+          def verify_protocol(protocol)
+            raise NotImplementedError.new
+          end
+
+        end
+    end
+  end
+end

data/lib/baykit/bayserver/{docker/warp → common}/warp_ship.rb

@@ -1,20 +1,20 @@
 require 'baykit/bayserver/util/counter'
 require 'baykit/bayserver/util/http_status'
-require 'baykit/bayserver/docker/warp/warp_ship'
+require 'baykit/bayserver/common/warp_ship'
 
 module Baykit
   module BayServer
-    module Docker
-      module Warp
-        class WarpShip < Baykit::BayServer::WaterCraft::Ship
+      module Common
+        class WarpShip < Baykit::BayServer::Ships::Ship
           include Baykit::BayServer::Agent
-          include Baykit::BayServer::WaterCraft
+          include Baykit::BayServer::Ships
           include Baykit::BayServer::Tours
           include Baykit::BayServer::Util
 
           attr :tour_map
           attr :docker
 
+          attr :protocol_handler
           attr_accessor :connected
           attr :socket_timeout_sec
           attr :lock
@@ -30,17 +30,29 @@ module Baykit
             @cmd_buf = []
           end
 
+          def init_warp(rd, agt_id, tp, dkr, proto_hnd)
+            init(agt_id, rd, tp)
+            @docker = dkr
+            @socket_timeout_sec = @docker.timeout_sec >= 0 ? @docker.timeout_sec : BayServer.harbor.socket_timeout_sec
+            @protocol_handler = proto_hnd
+            @protocol_handler.init(self)
+          end
+
           def to_s()
-            return "warp##{@ship_id}/#{@object_id}[#{protocol}]"
+            protocol = ""
+            if @protocol_handler != nil
+              protocol = "[#{@protocol_handler.protocol}]"
+            end
+            return "agt##{agent_id} wsip##{@ship_id}/#{@object_id}[#{protocol}]"
           end
 
           def inspect
             to_s
           end
 
-          ######################################################
+          #########################################
           # Implements Reusable
-          ######################################################
+          #########################################
 
           def reset()
             super
@@ -52,19 +64,89 @@ module Baykit
             @cmd_buf = []
           end
 
+          #########################################
+          # Implements Ship
+          #########################################
+          def notify_handshake_done(proto)
+            @protocol_handler.verify_protocol(protocol)
+            NextSocketAction::CONTINUE
+          end
 
-          ######################################################
-          # Other methods
-          ######################################################
-          def init_warp(skt, agt, tp, dkr, proto_hnd)
-            init(skt, agt, tp)
-            @docker = dkr
-            @socket_timeout_sec = @docker.timeout_sec >= 0 ? @docker.timeout_sec : BayServer.harbor.socket_timeout_sec
-            set_protocol_handler(proto_hnd)
+          def notify_connect()
+            @connected = true
+            @tour_map.values.each do |pair|
+              tur = pair[1]
+              tur.check_tour_id pair[0]
+              WarpData.get(tur).start
+            end
+            NextSocketAction::CONTINUE
           end
 
+          def notify_read(buf)
+            return @protocol_handler.bytes_received(buf)
+          end
+
+          def notify_eof()
+            BayLog.debug("%s EOF detected", self)
+
+            if @tour_map.empty?
+              BayLog.debug("%s No warp tours. only close", self)
+              return NextSocketAction::CLOSE
+            end
+
+            @tour_map.each do |warp_id, pair|
+              tur = pair[1]
+              tur.check_tour_id pair[0]
+
+              begin
+                if !tur.res.header_sent
+                  BayLog.debug("%s Send ServiceUnavailable: tur=%s", self, tur)
+                  tur.res.send_error(Tour::TOUR_ID_NOCHECK, HttpStatus::SERVICE_UNAVAILABLE, "Server closed on reading headers")
+                else
+                  # NOT treat EOF as Error
+                  BayLog.debug("%s EOF is not an error: tur=%s", self, tur)
+                  tur.res.end_res_content(Tour::TOUR_ID_NOCHECK)
+                end
+              rescue IOError => e
+                BayLog::debug_e(e)
+              end
+            end
+
+            @tour_map.clear()
+            return NextSocketAction::CLOSE
+          end
+
+          def notify_error(e)
+            BayLog.error_e(e, "notify_error")
+          end
+
+          def notify_protocol_error(e)
+            BayLog.error_e(e)
+            notify_error_to_owner_tour(HttpStatus::SERVICE_UNAVAILABLE, e.message)
+            true
+          end
+
+          def notify_close
+            BayLog.debug("%s notifyClose", self)
+            notify_error_to_owner_tour(HttpStatus::SERVICE_UNAVAILABLE, "#{self} server closed")
+            end_ship()
+          end
+
+          def check_timeout(duration_sec)
+            if is_timeout(duration_sec)
+              notify_error_to_owner_tour(HttpStatus::GATEWAY_TIMEOUT, "#{self} server timeout")
+              true
+            else
+              false
+            end
+          end
+
+          ################################
+          # Other methods
+          ################################
+
           def warp_handler
-            return @protocol_handler
+            return @protocol_handler.command_handler
           end
 
           def start_warp_tour(tur)
@@ -80,7 +162,7 @@ module Baykit
             end
 
             @tour_map[warp_id] = [tur.id(), tur]
-            w_hnd.post_warp_headers(tur)
+            w_hnd.send_res_headers(tur)
 
             if @connected
               BayLog.debug("%s is already connected. Start warp tour:%s", wdat, tur);
@@ -97,7 +179,7 @@ module Baykit
             else
               @tour_map.delete wdat.warp_id
             end
-            @docker.keep_ship(self)
+            @docker.keep(self)
           end
 
           def notify_service_unavailable(msg)
@@ -137,7 +219,7 @@ module Baykit
                     BayLog.error_e(e)
                   end
                 else
-                  tur.res.end_content(Tour::TOUR_ID_NOCHECK)
+                  tur.res.end_res_content(Tour::TOUR_ID_NOCHECK)
                 end
               end
               @tour_map.clear
@@ -146,13 +228,12 @@ module Baykit
 
 
           def end_ship()
-            @docker.return_protocol_handler(@agent, @protocol_handler)
-            @docker.return_ship(self)
+            @docker.on_end_ship(self)
           end
 
           def abort(check_id)
             check_ship_id(check_id)
-            @postman.abort
+            @transporter.req_close(@rudder)
           end
 
           def is_timeout(duration)
@@ -170,14 +251,14 @@ module Baykit
             return timeout
           end
 
-          def post(cmd, listener=nil)
+          def post(cmd, &listener)
             if !@connected
               @cmd_buf << [cmd, listener]
             else
               if cmd == nil
                 listener.call()
               else
-                @protocol_handler.command_packer.post(self, cmd, &listener)
+                @protocol_handler.post(cmd, &listener)
               end
             end
           end
@@ -188,13 +269,12 @@ module Baykit
                 if cmd == nil
                   lis.call()
                 else
-                  @protocol_handler.command_packer.post(self, cmd, &lis)
+                  @protocol_handler.post(cmd, &lis)
                 end
               end
               @cmd_buf = []
           end
         end
       end
-    end
   end
 end

data/lib/baykit/bayserver/{docker/warp → common}/warp_ship_store.rb

@@ -1,14 +1,13 @@
 require 'baykit/bayserver/protocol/packet_store'
-require 'baykit/bayserver/docker/warp/package'
+require 'baykit/bayserver/common/warp_ship'
 
 module Baykit
   module BayServer
-    module Docker
-      module Warp
+    module Common
         class WarpShipStore < Baykit::BayServer::Util::ObjectStore
           include Baykit::BayServer::Protocol
           include Baykit::BayServer::Util
-          include Baykit::BayServer::Docker::Warp
+          include Baykit::BayServer::Common
 
           attr :keep_list
           attr :busy_list
@@ -49,9 +48,6 @@ module Baykit
             if wsip == nil
               raise Sink.new("BUG! ship is null")
             end
-            if wsip.postman != nil && wsip.postman.zombie?
-              raise Sink("channel is zombie: %s", wsip)
-            end
             @busy_list.append(wsip)
 
             BayLog.trace(" rent keepList=%s busyList=%s", @keep_list, @busy_list)
@@ -105,7 +101,6 @@ module Baykit
             super
           end
         end
-      end
     end
   end
 end

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

@@ -1,6 +1,6 @@
 require 'baykit/bayserver/agent/next_socket_action'
 require 'baykit/bayserver/agent/transporter/data_listener'
-require 'baykit/bayserver/watercraft/ship'
+require 'baykit/bayserver/ships/ship'
 require 'baykit/bayserver/tours/package'
 
 module Baykit
@@ -50,7 +50,7 @@ module Baykit
             if BayLog.debug_mode?
               BayLog.error_e(err)
             end
-            return @ship.protocol_handler.send_req_protocol_error(err)
+            return @ship.protocol_handler.on_protocol_error(err)
           end
 
           def notify_close

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

@@ -1,13 +1,13 @@
 require 'baykit/bayserver/protocol/protocol_handler_store'
 require 'baykit/bayserver/bcf/package'
-require 'baykit/bayserver/agent/transporter/plain_transporter'
+require 'baykit/bayserver/agent/multiplexer/plain_transporter'
+require 'baykit/bayserver/rudders/io_rudder'
 require 'baykit/bayserver/util/object_store'
 require 'baykit/bayserver/util/object_factory'
 
 require 'baykit/bayserver/docker/port'
 require 'baykit/bayserver/docker/base/docker_base'
-require 'baykit/bayserver/docker/base/inbound_data_listener'
-require 'baykit/bayserver/docker/base/inbound_ship_store'
+require 'baykit/bayserver/common/inbound_ship_store'
 
 module Baykit
   module BayServer
@@ -18,12 +18,14 @@ module Baykit
 
           include Baykit::BayServer::Bcf
           include Baykit::BayServer::Agent
-          include Baykit::BayServer::Agent::Transporter
+          include Baykit::BayServer::Agent::Multiplexer
           include Baykit::BayServer::Docker
           include Baykit::BayServer::Docker::Base
           include Baykit::BayServer::WaterCraft
           include Baykit::BayServer::Protocol
+          include Baykit::BayServer::Rudders
           include Baykit::BayServer::Util
+          include Baykit::BayServer::Common
 
           attr :permission_list
           attr :host
@@ -48,18 +50,18 @@ module Baykit
           end
 
           def to_s()
-            return super + "[" + @port + "]"
+            return super + "[#{@port}]"
           end
 
           ######################################################
           # Abstract methods
           ######################################################
           def support_anchored()
-            raise NotImplementedError()
+            raise NotImplementedError.new
           end
 
           def support_unanchored()
-            raise NotImplementedError()
+            raise NotImplementedError.new
           end
 
           ######################################################
@@ -178,46 +180,76 @@ module Baykit
             return @secure_docker != nil
           end
 
-          def check_admitted(skt)
-            @permission_list.each do |perm_dkr|
-              perm_dkr.socket_admitted(skt)
-            end
-          end
 
           def find_city(name)
             return @cities.find_city(name)
           end
 
-          def new_transporter(agt, skt)
-            sip = PortBase.get_ship_store(agt).rent()
+          def on_connected(agt_id, rd)
+
+            check_admitted(rd)
+
+            sip = PortBase.get_ship_store(agt_id).rent()
+            agt = GrandAgent.get(agt_id)
+
             if secure()
-              tp = @secure_docker.create_transporter(IOUtil.get_sock_recv_buf_size(skt))
+              tp = @secure_docker.new_transporter(
+                agt_id,
+                sip,
+                IOUtil.get_sock_recv_buf_size(rd.io))
+
+              ssl_socket = tp.new_ssl_socket(rd.io)
+              rd = IORudder.new(ssl_socket)
+              if agt.net_multiplexer.is_non_blocking
+                rd.set_non_blocking
+              end
+
             else
-              tp = PlainTransporter.new(true, IOUtil.get_sock_recv_buf_size(skt))
+              size = IOUtil.get_sock_recv_buf_size(rd.io)
+
+              tp = PlainTransporter.new(
+                agt.net_multiplexer,
+                sip,
+                true,
+                size,
+                false)
             end
 
-            proto_hnd = PortBase.get_protocol_handler_store(protocol(), agt).rent()
-            sip.init_inbound(skt, agt, tp, self, proto_hnd)
-            tp.init(agt.non_blocking_handler, skt, InboundDataListener.new(sip))
-            return tp
+            proto_hnd = PortBase.get_protocol_handler_store(protocol(), agt_id).rent()
+            sip.init_inbound(rd, agt_id, tp, self, proto_hnd)
+
+            st = RudderState.new(rd, tp)
+            agt.net_multiplexer.add_rudder_state(rd, st)
+            agt.net_multiplexer.req_read(rd)
           end
 
-          def return_protocol_handler(agt, proto_hnd)
+          def return_protocol_handler(agt_id, proto_hnd)
             BayLog.debug("%s Return protocol handler", proto_hnd)
-            PortBase.get_protocol_handler_store(proto_hnd.protocol, agt).Return(proto_hnd)
+            PortBase.get_protocol_handler_store(proto_hnd.protocol, agt_id).Return(proto_hnd)
           end
 
           def return_ship(sip)
             BayLog.debug("%s end (return ship)", sip)
-            PortBase.get_ship_store(sip.agent).Return(sip)
+            PortBase.get_ship_store(sip.agent_id).Return(sip)
+          end
+
+          ######################################################
+          # Private methods
+          ######################################################
+          private
+
+          def check_admitted(rd)
+            @permission_list.each do |perm_dkr|
+              perm_dkr.socket_admitted(rd)
+            end
           end
 
-          def PortBase.get_ship_store(agt)
-            return InboundShipStore.get_store(agt.agent_id)
+          def PortBase.get_ship_store(agt_id)
+            return InboundShipStore.get_store(agt_id)
           end
 
-          def PortBase.get_protocol_handler_store(proto, agt)
-            return ProtocolHandlerStore.get_store(proto, true, agt.agent_id)
+          def PortBase.get_protocol_handler_store(proto, agt_id)
+            return ProtocolHandlerStore.get_store(proto, true, agt_id)
           end
 
         end