bayserver-docker-ajp 2.3.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6da1e75ad4a6e81ac2a945a0e810e43e40ba4177773ec564d10916c37f2bfff
-  data.tar.gz: dba0eec4aa3a27792e1ca0a7f5e1528309a0dfb7d898b22146a78d9bfafe64de
+  metadata.gz: 30ab4e8d79a5923f9ea6966dfe181914b91b84689fd882fdee087410ac2dff49
+  data.tar.gz: a12f0f026ff69ee6cc30b7e87375d1fa920f53f304c9f62e4b6336025c4cb8f2
 SHA512:
-  metadata.gz: 5194f32c9a0faeae7829b7a48861a614e541ef4881c8da8baddad0efd0bd37cd9b8e06f216ea2755ebc9d3c991dc54680530fd9d67b2077fcbaa4a64fce83392
-  data.tar.gz: 845fb8948e148e5fece71c276892a6795b05ca02c9bda0af018ffa33b7efd8535d9d904de79ad3ca7132cb8de6d57656aca685954295c04ce9bdf8b0a384718a
+  metadata.gz: d8974095d7f61f7fb5a37e5fb79ec8f09fd2943e50de38abe0408ead09ab32dcadc3dd07275d3bc5d541a56b4d76726aaba93bedce0dc7fa9a94bafa9b8aceb0
+  data.tar.gz: aa0e3db7f26a6885da95615c1a8c4f8ec07fd301ced14f81db6b31ad5153b6dbdf99754fcdbff90531ede059f199fb48a2eb2823caea03d3a26a4481487edbd4

data/lib/baykit/bayserver/docker/ajp/ajp_command_handler.rb

@@ -7,17 +7,37 @@ module Baykit
         module AjpCommandHandler
           include Baykit::BayServer::Protocol::CommandHandler  # implements
 
-          # abstract method
-          #
-          # handle_data(cmd)
-          # handle_end_response(cmd)
-          # handle_forward_request(cmd)
-          # handle_send_body_chunk(cmd)
-          # handle_send_headers(cmd)
-          # handle_shutdown(cmd)
-          # handle_get_body_chunk(cmd)
-          # need_data()
-          #
+          def handle_data(cmd)
+            raise NotImplementedError.new
+          end
+
+          def handle_end_response(cmd)
+            raise NotImplementedError.new
+          end
+
+          def handle_forward_request(cmd)
+            raise NotImplementedError.new
+          end
+
+          def handle_send_body_chunk(cmd)
+            raise NotImplementedError.new
+          end
+
+          def handle_send_headers(cmd)
+            raise NotImplementedError.new
+          end
+
+          def handle_shutdown(cmd)
+            raise NotImplementedError.new
+          end
+
+          def handle_get_body_chunk(cmd)
+            raise NotImplementedError.new
+          end
+
+          def need_data()
+            raise NotImplementedError.new
+          end
         end
       end
     end

data/lib/baykit/bayserver/docker/ajp/ajp_handler.rb

@@ -0,0 +1,14 @@
+
+module Baykit
+  module BayServer
+    module Docker
+      module Ajp
+        module AjpHandler  # interface
+          def on_protocol_error(e)
+            raise NotImplementedError.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb

@@ -1,26 +1,38 @@
-require 'baykit/bayserver/docker/base/inbound_handler'
+require 'baykit/bayserver/common/inbound_handler'
 require 'baykit/bayserver/tours/req_content_handler'
 
 require 'baykit/bayserver/util/string_util'
 require 'baykit/bayserver/util/http_util'
 require 'baykit/bayserver/docker/ajp/ajp_protocol_handler'
+require 'baykit/bayserver/docker/ajp/ajp_handler'
 require 'baykit/bayserver/docker/ajp/command/package'
 
 module Baykit
   module BayServer
     module Docker
       module Ajp
-        class AjpInboundHandler < Baykit::BayServer::Docker::Ajp::AjpProtocolHandler
+        class AjpInboundHandler
 
           class InboundProtocolHandlerFactory
             include Baykit::BayServer::Protocol::ProtocolHandlerFactory  # implements
+            include Baykit::BayServer::Protocol
 
             def create_protocol_handler(pkt_store)
-              return AjpInboundHandler.new(pkt_store)
+              ib_handler = AjpInboundHandler.new
+              cmd_unpacker = AjpCommandUnPacker.new(ib_handler)
+              pkt_unpacker = AjpPacketUnPacker.new(pkt_store, cmd_unpacker)
+              pkt_packer = PacketPacker.new()
+              cmd_packer = CommandPacker.new(pkt_packer, pkt_store)
+
+              proto_handler = AjpProtocolHandler.new(ib_handler, pkt_unpacker, pkt_packer, cmd_unpacker, cmd_packer, true)
+              ib_handler.init(proto_handler)
+              return proto_handler
             end
           end
 
-          include Baykit::BayServer::Docker::Base::InboundHandler # implements
+          include Baykit::BayServer::Common::InboundHandler # implements
+          include Baykit::BayServer::Docker::Ajp::AjpHandler # implements
+
           include Baykit::BayServer::Util
           include Baykit::BayServer::Agent
           include Baykit::BayServer::Protocol
@@ -33,20 +45,23 @@ module Baykit
           DUMMY_KEY = 1
           attr :cur_tour_id
           attr :req_command
+          attr :protocol_handler
 
           attr :state
           attr :keeping
 
-          def initialize(pkt_store)
-            super(pkt_store, true)
-            reset_state()
+          def initialize
+            reset
+          end
+
+          def init(proto_handler)
+            @protocol_handler = proto_handler
           end
 
           ######################################################
           # implements Reusable
           ######################################################
-          def reset()
-            super
+          def reset
             reset_state()
             @req_command = nil
             @keeping = false
@@ -65,29 +80,29 @@ module Baykit
               end
             end
             cmd.status = tur.res.headers.status
-            command_packer.post(@ship, cmd)
+            @protocol_handler.post(cmd)
 
             BayLog.debug("%s send header: content-length=%d", self, tur.res.headers.content_length())
           end
 
           def send_res_content(tur, bytes, ofs, len, &lis)
             cmd = CmdSendBodyChunk.new(bytes, ofs, len);
-            @command_packer.post(ship, cmd, &lis);
+            @protocol_handler.post(cmd, &lis);
           end
 
           def send_end_tour(tur, keep_alive, &callback)
-            BayLog.debug("%s endTour: tur=%s keep=%s", @ship, tur, keep_alive)
+            BayLog.debug("%s endTour: tur=%s keep=%s", ship, tur, keep_alive)
             cmd = CmdEndResponse.new()
             cmd.reuse = keep_alive
 
             ensure_func = lambda do
               if !keep_alive
-                command_packer.end(@ship)
+                ship.post_close
               end
             end
 
             begin
-              command_packer.post(@ship, cmd) do
+              @protocol_handler.post(cmd) do
                 BayLog.debug("%s call back in sendEndTour: tur=%s keep=%s", self, tur, keep_alive)
                 ensure_func.call()
                 callback.call()
@@ -99,8 +114,8 @@ module Baykit
             end
           end
 
-          def send_req_protocol_error(e)
-            tur = @ship.get_error_tour()
+          def on_protocol_error(e)
+            tur = ship.get_error_tour()
             tur.res.send_error(Tour::TOUR_ID_NOCHECK, HttpStatus::BAD_REQUEST, e.message, e)
             return true
           end
@@ -110,17 +125,17 @@ module Baykit
           # implements AjpCommandHandler
           ######################################################
           def handle_forward_request(cmd)
-            BayLog.debug("%s handleForwardRequest method=%s uri=%s", @ship, cmd.method, cmd.req_uri)
+            BayLog.debug("%s handleForwardRequest method=%s uri=%s", ship, cmd.method, cmd.req_uri)
             if @state != STATE_READ_FORWARD_REQUEST
               raise ProtocolException.new("Invalid AJP command: #{cmd.type}")
             end
 
             @keeping = false
             @req_command = cmd
-            tur = @ship.get_tour(DUMMY_KEY)
+            tur = ship.get_tour(DUMMY_KEY)
             if tur == nil
               BayLog.error(BayMessage.get(:INT_NO_MORE_TOURS))
-              tur = @ship.get_tour(AjpInboundHandler::DUMMY_KEY, true)
+              tur = ship.get_tour(AjpInboundHandler::DUMMY_KEY, true)
               tur.res.send_error(Tour::TOUR_ID_NOCHECK, HttpStatus::SERVICE_UNAVAILABLE, "No available tours")
               tur.res.end_content(Tour::TOUR_ID_NOCHECK)
               return NextSocketAction::CONTINUE
@@ -140,7 +155,7 @@ module Baykit
             BayLog.debug("%s read header method=%s protocol=%s uri=%s contlen=%d",
                          tur, tur.req.method, tur.req.protocol, tur.req.uri, tur.req.headers.content_length)
 
-            if BayServer.harbor.trace_header?
+            if BayServer.harbor.trace_header
               cmd.headers.names.each do |name|
                 cmd.headers.values(name).each do |value|
                   BayLog.info("%s header: %s=%s", tur, name, value)
@@ -150,12 +165,7 @@ module Baykit
 
             req_cont_len = cmd.headers.content_length
             if req_cont_len > 0
-              sid = @ship.ship_id
-              tur.req.set_consume_listener(req_cont_len) do |len, resume|
-                if resume
-                  @ship.resume(sid)
-                end
-              end
+              tur.req.set_limit(req_cont_len)
             end
 
             begin
@@ -184,46 +194,55 @@ module Baykit
           end
 
           def handle_data(cmd)
-            BayLog.debug("%s handleData len=%s", @ship, cmd.length)
+            BayLog.debug("%s handleData len=%s", ship, cmd.length)
 
             if @state != STATE_READ_DATA
               raise RuntimeError.new("Invalid AJP command: #{cmd.type} state=#{@state}")
             end
 
-            tur = @ship.get_tour(DUMMY_KEY)
-            success = tur.req.post_content(Tour::TOUR_ID_NOCHECK, cmd.data, cmd.start, cmd.length)
+            tur = ship.get_tour(DUMMY_KEY)
 
-            if tur.req.bytes_posted == tur.req.bytes_limit
-              # request content completed
+            begin
+              sid = ship.ship_id
+              success = tur.req.post_req_content(Tour::TOUR_ID_NOCHECK, cmd.data, cmd.start, cmd.length) do |len, resume|
+                if resume
+                  ship.resume(sid)
+                end
+              end
 
-              if tur.error != nil
-                tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, tur.error)
-                reset_state()
-                return NextSocketAction::WRITE
-              else
-                begin
-                  end_req_content(tur)
-                  return NextSocketAction::CONTINUE
-                rescue HttpException => e
-                  tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, e)
+              if tur.req.bytes_posted == tur.req.bytes_limit
+                # request content completed
+
+                if tur.error != nil
+                  tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, tur.error)
                   reset_state()
                   return NextSocketAction::WRITE
+                else
+                  end_req_content(tur)
+                  return NextSocketAction::CONTINUE
                 end
-              end
-            else
-              bch = CmdGetBodyChunk.new()
-              bch.req_len = tur.req.bytes_limit - tur.req.bytes_posted
-              if bch.req_len > AjpPacket::MAX_DATA_LEN
-                bch.req_len = AjpPacket::MAX_DATA_LEN
-              end
-              command_packer.post(@ship, bch)
-
-              if !success
-                return NextSocketAction::SUSPEND
               else
-                return NextSocketAction::CONTINUE
+                bch = CmdGetBodyChunk.new()
+                bch.req_len = tur.req.bytes_limit - tur.req.bytes_posted
+                if bch.req_len > AjpPacket::MAX_DATA_LEN
+                  bch.req_len = AjpPacket::MAX_DATA_LEN
+                end
+                @protocol_handler.post(bch)
+
+                if !success
+                  return NextSocketAction::SUSPEND
+                else
+                  return NextSocketAction::CONTINUE
+                end
               end
+
+            rescue HttpException => e
+              tur.req.abort
+              tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, e)
+              reset_state()
+              return NextSocketAction::WRITE
             end
+
           end
 
           def handle_send_body_chunk(cmd)
@@ -235,7 +254,7 @@ module Baykit
           end
 
           def handle_shutdown(cmd)
-            BayLog.info("%s handle_shutdown", @ship)
+            BayLog.info("%s handle_shutdown", ship)
             BayServer.shutdown
             NextSocketAction::CLOSE
           end
@@ -253,6 +272,11 @@ module Baykit
           end
 
           private
+
+          def ship
+            return @protocol_handler.ship
+          end
+
           def reset_state
             change_state(STATE_READ_FORWARD_REQUEST)
           end
@@ -262,7 +286,7 @@ module Baykit
           end
 
           def end_req_content(tur)
-            tur.req.end_content(Tour::TOUR_ID_NOCHECK)
+            tur.req.end_req_content(Tour::TOUR_ID_NOCHECK)
             reset_state()
           end
 
@@ -270,7 +294,7 @@ module Baykit
             HttpUtil.parse_host_port(tur, @req_command.is_ssl ? 443 : 80)
             HttpUtil.parse_authorization(tur)
 
-            skt = @ship.socket
+            skt = ship.rudder.io
             tur.req.remote_port = nil
             tur.req.remote_address = @req_command.remote_addr
             tur.req.remote_host_func = lambda { @req_command.remote_host }

data/lib/baykit/bayserver/docker/ajp/ajp_protocol_handler.rb

@@ -1,7 +1,4 @@
 require 'baykit/bayserver/protocol/protocol_handler'
-require 'baykit/bayserver/protocol/packet_store'
-require 'baykit/bayserver/util/http_status'
-require 'baykit/bayserver/tours/package'
 require 'baykit/bayserver/docker/ajp/package'
 require 'baykit/bayserver/docker/ajp/command/package'
 
@@ -14,16 +11,11 @@ module Baykit
 
           include Baykit::BayServer::Protocol
           include Baykit::BayServer::Agent
-          include Baykit::BayServer::Util
           include Baykit::BayServer::Docker::Ajp::Command
 
 
-          def initialize(pkt_store, svr_mode)
-            @command_unpacker = AjpCommandUnPacker.new(self)
-            @packet_unpacker = AjpPacketUnPacker.new(pkt_store, @command_unpacker)
-            @packet_packer = PacketPacker.new()
-            @command_packer = CommandPacker.new(@packet_packer, pkt_store)
-            @server_mode = svr_mode
+          def initialize(ajp_handler, pkt_unpacker, pkt_packer, cmd_unpacker, cmd_packer, svr_mode)
+            super(pkt_unpacker, pkt_packer, cmd_unpacker, cmd_packer, ajp_handler, svr_mode)
           end
 
           def to_s

data/lib/baykit/bayserver/docker/ajp/ajp_warp_docker.rb

@@ -1,18 +1,20 @@
-require 'baykit/bayserver/docker/warp/warp_docker'
+require 'baykit/bayserver/docker/base/warp_base'
 require 'baykit/bayserver/docker/ajp/package'
-require 'baykit/bayserver/agent/transporter/plain_transporter'
+require 'baykit/bayserver/agent/multiplexer/plain_transporter'
+require 'baykit/bayserver/util/io_util'
 require 'baykit/bayserver/protocol/packet_store'
 
 module Baykit
   module BayServer
     module Docker
       module Ajp
-        class AjpWarpDocker < Baykit::BayServer::Docker::Warp::WarpDocker
+        class AjpWarpDocker < Baykit::BayServer::Docker::Base::WarpBase
           include Baykit::BayServer::Docker::Ajp::AjpDocker  # implements
 
           include Baykit::BayServer::Agent
+          include Baykit::BayServer::Agent::Multiplexer
           include Baykit::BayServer::Protocol
-          include Baykit::BayServer::Agent::Transporter
+          include Baykit::BayServer::Util
 
           ######################################################
           # Implements WarpDocker
@@ -29,8 +31,10 @@ module Baykit
             return PROTO_NAME
           end
 
-          def new_transporter(agt, skt)
-            PlainTransporter.new(false, IOUtil.get_sock_recv_buf_size(skt))
+          def new_transporter(agt, rd, sip)
+            tp = PlainTransporter.new(agt.net_multiplexer, sip, false, IOUtil.get_sock_recv_buf_size(rd.io), false)
+            tp.init
+            return tp
           end
 
           ######################################################

data/lib/baykit/bayserver/docker/ajp/ajp_warp_handler.rb

@@ -1,8 +1,10 @@
 require 'baykit/bayserver/agent/next_socket_action'
 require 'baykit/bayserver/protocol/protocol_exception'
+require 'baykit/bayserver/common/warp_data'
 require 'baykit/bayserver/docker/ajp/command/package'
 require 'baykit/bayserver/util/string_util'
 
+require 'baykit/bayserver/docker/ajp/ajp_handler'
 require 'baykit/bayserver/docker/ajp/ajp_protocol_handler'
 
 
@@ -10,14 +12,24 @@ module Baykit
   module BayServer
     module Docker
       module Ajp
-        class AjpWarpHandler < Baykit::BayServer::Docker::Ajp::AjpProtocolHandler
-          include Baykit::BayServer::Docker::Warp::WarpHandler # implements
+        class AjpWarpHandler
+          include Baykit::BayServer::Common::WarpHandler # implements
+          include AjpHandler # implements
 
           class WarpProtocolHandlerFactory
             include Baykit::BayServer::Protocol::ProtocolHandlerFactory  # implements
+            include Baykit::BayServer::Protocol
 
             def create_protocol_handler(pkt_store)
-              return AjpWarpHandler.new(pkt_store)
+              ib_handler = AjpWarpHandler.new
+              cmd_unpacker = AjpCommandUnPacker.new(ib_handler)
+              pkt_unpacker = AjpPacketUnPacker.new(pkt_store, cmd_unpacker)
+              pkt_packer = PacketPacker.new()
+              cmd_packer = CommandPacker.new(pkt_packer, pkt_store)
+
+              proto_handler = AjpProtocolHandler.new(ib_handler, pkt_unpacker, pkt_packer, cmd_unpacker, cmd_packer, false)
+              ib_handler.init(proto_handler)
+              return proto_handler
             end
           end
 
@@ -25,9 +37,9 @@ module Baykit
           include Baykit::BayServer::Agent
           include Baykit::BayServer::Protocol
           include Baykit::BayServer::Tours
-          include Baykit::BayServer::Docker::Warp
           include Baykit::BayServer::Docker::Ajp::Command
           include Baykit::BayServer::Util
+          include Baykit::BayServer::Common
 
           FIXED_WARP_ID = 1
 
@@ -38,13 +50,15 @@ module Baykit
 
           attr :cont_read_len
 
-          def initialize(pkt_store)
-            super(pkt_store, false)
+          def initialize
             reset()
           end
 
+          def init(proto_handler)
+            @protocol_handler = proto_handler
+          end
+
           def reset()
-            super
             reset_state()
             @cont_read_len = 0
           end
@@ -54,31 +68,37 @@ module Baykit
           end
 
           ######################################################
-          # Implements WarpHandler
+          # Implements TourHandler
           ######################################################
-          def next_warp_id()
-            return 1
+
+          def send_res_headers(tur)
+            send_forward_request(tur)
           end
 
-          def new_warp_data(warp_id)
-            return WarpData.new(ship, warp_id)
+          def send_res_content(tur, buf, start, len, &lis)
+            send_data(tur, buf, start, len, &lis)
           end
 
-          def post_warp_headers(tur)
-            send_forward_request(tur)
+          def send_end_tour(tur, keep_alive, &lis)
+            ship.post(nil, &lis)
           end
 
-          def post_warp_contents(tur, buf, start, len, &callback)
-            send_data(tur, buf, start, len, &callback)
+          def on_protocol_error(e)
+            raise Sink.new
           end
 
-          def post_warp_end(tur)
-            callback = lambda do
-              @ship.agent.non_blocking_handler.ask_to_read(@ship.socket)
-            end
-            @ship.post(nil, callback)
+          ######################################################
+          # Implements WarpHandler
+          ######################################################
+          def next_warp_id()
+            return 1
+          end
+
+          def new_warp_data(warp_id)
+            return WarpData.new(ship, warp_id)
           end
 
+
           def verify_protocol(proto)
           end
 
@@ -90,8 +110,8 @@ module Baykit
           end
 
           def handle_end_response(cmd)
-            BayLog.debug("%s handle_end_response reuse=%s", @ship, cmd.reuse)
-            tur = @ship.get_tour(FIXED_WARP_ID)
+            BayLog.debug("%s handle_end_response reuse=%s st=%d", ship, cmd.reuse, @state)
+            tur = ship.get_tour(FIXED_WARP_ID)
 
             if @state == STATE_READ_HEADER
               end_res_header(tur)
@@ -111,22 +131,22 @@ module Baykit
           end
 
           def handle_send_body_chunk(cmd)
-            BayLog.debug("%s handle_send_body_chunk: len=%d", @ship, cmd.length)
-            tur = @ship.get_tour(FIXED_WARP_ID)
+            BayLog.debug("%s handle_send_body_chunk: len=%d st=%d", ship, cmd.length, @state)
+            tur = ship.get_tour(FIXED_WARP_ID)
 
             if @state == STATE_READ_HEADER
 
-              sid = @ship.ship_id
+              sid = ship.ship_id
               tur.res.set_consume_listener do |len, resume|
                 if resume
-                  @ship.resume(sid)
+                  ship.resume_read(sid)
                 end
               end
 
               end_res_header(tur)
             end
 
-            available = tur.res.send_content(tur.tour_id, cmd.chunk, 0, cmd.length)
+            available = tur.res.send_res_content(tur.tour_id, cmd.chunk, 0, cmd.length)
             @cont_read_len += cmd.length
 
             if available
@@ -137,9 +157,9 @@ module Baykit
           end
 
           def handle_send_headers(cmd)
-            BayLog.debug("%s handle_send_headers", @ship)
+            BayLog.debug("%s handle_send_headers", ship)
 
-            tur = @ship.get_tour(FIXED_WARP_ID)
+            tur = ship.get_tour(FIXED_WARP_ID)
 
             if @state != STATE_READ_HEADER
               raise ProtocolException.new("Invalid AJP command: %d state=%s", cmd.type, @state)
@@ -147,14 +167,14 @@ module Baykit
 
             wdat = WarpData.get(tur)
 
-            if BayServer.harbor.trace_header?
+            if BayServer.harbor.trace_header
               BayLog.info("%s recv res status: %d", wdat, cmd.status)
             end
 
             wdat.res_headers.status = cmd.status
             cmd.headers.keys.each do |name|
               cmd.headers[name].each do |value|
-                if BayServer.harbor.trace_header?
+                if BayServer.harbor.trace_header
                   BayLog.info("%s recv res header: %s=%s", wdat, name, value)
                 end
                 wdat.res_headers.add(name, value)
@@ -173,10 +193,6 @@ module Baykit
             return NextSocketAction::CONTINUE
           end
 
-          def handle_eof
-            raise EOFError.new()
-          end
-
           def need_data
             return false
           end
@@ -190,8 +206,8 @@ module Baykit
           end
 
           def end_res_content(tur)
-            @ship.end_warp_tour(tur)
-            tur.res.end_content(Tour::TOUR_ID_NOCHECK)
+            ship.end_warp_tour(tur)
+            tur.res.end_res_content(Tour::TOUR_ID_NOCHECK)
             reset_state()
           end
 
@@ -218,7 +234,7 @@ module Baykit
             end
 
             rel_uri = rel_uri[town_path.length .. -1]
-            req_uri = @ship.docker.warp_base + rel_uri
+            req_uri = ship.docker.warp_base + rel_uri
 
             pos = req_uri.index('?')
             if pos != nil
@@ -231,10 +247,10 @@ module Baykit
             cmd.remote_addr = tur.req.remote_address
             cmd.remote_host = tur.req.remote_host()
             cmd.server_name = tur.req.server_name
-            cmd.server_port = @ship.docker.port
+            cmd.server_port = ship.docker.port
             cmd.is_ssl = tur.is_secure
             cmd.headers = tur.req.headers
-            if BayServer.harbor.trace_header?
+            if BayServer.harbor.trace_header
               cmd.headers.names.each do |name|
                 cmd.headers.values(name).each do |value|
                   BayLog.info("%s sendWarpHeader: %s=%s", WarpData.get(tur), name, value)
@@ -242,7 +258,7 @@ module Baykit
               end
             end
 
-            @ship.post(cmd)
+            ship.post(cmd)
           end
 
           def send_data(tur, data, ofs, len, &callback)
@@ -251,7 +267,11 @@ module Baykit
             cmd = CmdData.new(data, ofs, len)
             cmd.to_server = true
 
-            @ship.post(cmd, &callback)
+            ship.post(cmd, &callback)
+          end
+
+          def ship
+            return @protocol_handler.ship
           end
 
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bayserver-docker-ajp
 version: !ruby/object:Gem::Version
-  version: 2.3.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Michisuke-P
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-12-04 00:00:00.000000000 Z
+date: 2024-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bayserver-core
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.3.1
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.3.1
+        version: 3.0.0
 description: BayServer is one of the high-speed web servers. It operates as a single-threaded,
   asynchronous server, which makes it exceptionally fast. It also supports multi-core
   processors, harnessing the full potential of the CPU's capabilities.
@@ -38,6 +38,7 @@ files:
 - lib/baykit/bayserver/docker/ajp/ajp_command_handler.rb
 - lib/baykit/bayserver/docker/ajp/ajp_command_unpacker.rb
 - lib/baykit/bayserver/docker/ajp/ajp_docker.rb
+- lib/baykit/bayserver/docker/ajp/ajp_handler.rb
 - lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb
 - lib/baykit/bayserver/docker/ajp/ajp_packet.rb
 - lib/baykit/bayserver/docker/ajp/ajp_packet_factory.rb