bayserver-docker-fcgi 2.3.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 289a23cc5810c090a239df6233dd8bd63f973bb39d8a65eb8b265b0233973904
-  data.tar.gz: b7f740d4e725432a763b5b9f0fdf8e6bd7aac3e5852ef52b6560e9ed72bd4de0
+  metadata.gz: ac6e10f22238925d53d4b263e48e07563a08b4d353b452f5364c1d6dd817c67c
+  data.tar.gz: 24b6c04656d85b3eeb0884179c7598a9b32a877e50850157650b5a0ac86a22c1
 SHA512:
-  metadata.gz: 3f0ed513d2ea1dbe0a6ba4493ca70fe533537969cffaf8f2821bc7fb022bec02b955aec0d9644abf99cca9b0a30f8af68a925701cc8f591f95708955996f5f63
-  data.tar.gz: c7fedd620450d4965aab1e1044b7b853c50c0afb894b3282ad75ba17f8c41431f7fb724f7c6c0de4229936c7c11f279cd76291ac13cdc03f3a49b83e3fe8c15f
+  metadata.gz: d4bb7bbcbc6041bf6528228520d36b698fd1964e9317fe1691db84a852aaff8f05832c3a58816b53948c7ee25f086c542d11ab0885e31143ba4745f007875bd8
+  data.tar.gz: fb9d03f73913be62b8ea301ca66dea5f16819e602b7dfc5c674cd822cb2dbf09022a8c8e4a7b2214084a779d79a48654feef8c94e7fabfff8387ab00f4037018

data/lib/baykit/bayserver/docker/fcgi/fcg_handler.rb

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

data/lib/baykit/bayserver/docker/fcgi/fcg_inbound_handler.rb

@@ -1,47 +1,65 @@
 require 'baykit/bayserver/protocol/protocol_exception'
-require 'baykit/bayserver/docker/base/inbound_handler'
+require 'baykit/bayserver/common/inbound_handler'
 require 'baykit/bayserver/tours/req_content_handler'
 require 'baykit/bayserver/util/cgi_util'
 
 require 'baykit/bayserver/docker/fcgi/fcg_protocol_handler'
+require 'baykit/bayserver/docker/fcgi/fcg_handler'
 
 module Baykit
   module BayServer
     module Docker
       module Fcgi
-        class FcgInboundHandler < Baykit::BayServer::Docker::Fcgi::FcgProtocolHandler
+        class FcgInboundHandler
 
           class InboundProtocolHandlerFactory
             include Baykit::BayServer::Protocol::ProtocolHandlerFactory  # implements
 
+            include Baykit::BayServer::Protocol
+
             def create_protocol_handler(pkt_store)
-              return FcgInboundHandler.new(pkt_store)
+              ib_handler = FcgInboundHandler.new
+              cmd_unpacker = FcgCommandUnPacker.new(ib_handler)
+              pkt_unpacker = FcgPacketUnPacker.new(pkt_store, cmd_unpacker)
+              pkt_packer = PacketPacker.new()
+              cmd_packer = CommandPacker.new(pkt_packer, pkt_store)
+
+              proto_handler = FcgProtocolHandler.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 FcgHandler # implements
+
           include Baykit::BayServer::Agent
           include Baykit::BayServer::Tours
           include Baykit::BayServer::Protocol
           include Baykit::BayServer::Util
+          include Baykit::BayServer::Docker::Fcgi::Command
 
           STATE_BEGIN_REQUEST = 1
           STATE_READ_PARAMS = 2
           STATE_READ_STDIN = 3
 
           attr :state
+          attr :protocol_handler
           attr :cont_len
 
           attr :env
           attr :req_id
           attr :req_keep_alive
 
-          def initialize(pkt_store)
-            super(pkt_store, true)
+          def initialize
             @env = {}
-            reset_state()
+            reset()
           end
 
+          def init(proto_handler)
+            @protocol_handler = proto_handler
+          end
+          
           def to_s()
             return ClassUtil.get_local_name(self.class)
           end
@@ -50,23 +68,22 @@ module Baykit
           # implements Reusable
           ######################################################
           def reset
-            super
             @env.clear()
             reset_state()
           end
 
           ######################################################
-          # implements InboundHandler
+          # implements TourHandler
           ######################################################
 
           def send_res_headers(tur)
-            BayLog.debug("%s PH:sendHeaders: tur=%s", @ship, tur)
+            BayLog.debug("%s PH:sendHeaders: tur=%s", ship, tur)
 
             scode = tur.res.headers.status
             status = "#{scode} #{HttpStatus.description(scode)}"
             tur.res.headers.set(Headers::STATUS, status)
 
-            if BayServer.harbor.trace_header?
+            if BayServer.harbor.trace_header
               BayLog.info("%s resStatus:%d", tur, tur.res.headers.status)
               tur.res.headers.names().each do |name|
                 tur.res.headers.values(name) do |value|
@@ -79,32 +96,32 @@ module Baykit
             HttpUtil.send_mime_headers(tur.res.headers, buf)
             HttpUtil.send_new_line(buf)
             cmd = CmdStdOut.new(tur.req.key, buf.buf, 0, buf.length)
-            @command_packer.post(@ship, cmd)
+            @protocol_handler.post(cmd)
           end
 
           def send_res_content(tur, bytes, ofs, len, &callback)
             cmd = CmdStdOut.new(tur.req.key, bytes, ofs, len);
-            @command_packer.post(@ship, cmd, &callback)
+            @protocol_handler.post(cmd, &callback)
           end
 
           def send_end_tour(tur, keep_alive, &callback)
-            BayLog.debug("%s PH:endTour: tur=%s keep=%s", @ship, tur, keep_alive)
+            BayLog.debug("%s PH:endTour: tur=%s keep=%s", ship, tur, keep_alive)
 
             # Send empty stdout command
             cmd = CmdStdOut.new(tur.req.key)
-            @command_packer.post(@ship, cmd)
+            @protocol_handler.post(cmd)
 
             # Send end request command
             cmd = CmdEndRequest.new(tur.req.key)
 
             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()
@@ -116,8 +133,8 @@ module Baykit
             end
           end
 
-          def send_req_protocol_error(err)
-            tur = @ship.get_error_tour()
+          def on_protocol_error(err)
+            tur = ship.get_error_tour()
             tur.res.send_error(Tour::TOUR_ID_NOCHECK, HttpStatus::BAD_REQUEST, err.message, err)
             true
           end
@@ -155,7 +172,7 @@ module Baykit
           end
 
           def handle_params(cmd)
-            BayLog.debug("%s handle_params req_id=%d", @ship, cmd.req_id)
+            BayLog.debug("%s handle_params req_id=%d", ship, cmd.req_id)
 
             if state != STATE_READ_PARAMS
               raise ProtocolException.new("Invalid FCGI command: %d state=%d", cmd.type, @state)
@@ -163,8 +180,8 @@ module Baykit
 
             check_req_id(cmd.req_id)
 
-            BayLog.debug("%s handle_param get_tour req_id=%d", @ship, cmd.req_id)
-            tur = @ship.get_tour(cmd.req_id)
+            BayLog.debug("%s handle_param get_tour req_id=%d", ship, cmd.req_id)
+            tur = ship.get_tour(cmd.req_id)
 
             if cmd.params.empty?
               # Header completed
@@ -182,28 +199,23 @@ module Baykit
               req_cont_len = tur.req.headers.content_length()
 
               BayLog.debug("%s read header method=%s protocol=%s uri=%s contlen=%d",
-                           @ship, tur.req.method, tur.req.protocol, tur.req.uri, @cont_len)
+                           ship, tur.req.method, tur.req.protocol, tur.req.uri, @cont_len)
 
-              if BayServer.harbor.trace_header?
+              if BayServer.harbor.trace_header
                 cmd.params.each do |nv|
                   BayLog.info("%s  reqHeader: %s=%s", tur, nv[0], nv[1])
                 end
               end
 
               if req_cont_len > 0
-                tur.req.set_consume_listener(req_cont_len) do |len, resume|
-                  sid = @ship.ship_id
-                  if resume
-                    @ship.resume(sid)
-                  end
-                end
+                tur.req.set_limit(req_cont_len)
               end
 
               change_state(STATE_READ_STDIN)
               begin
                 start_tour(tur)
               rescue HttpException => e
-                BayLog.debug("%s Http error occurred: %s", @ship, e)
+                BayLog.debug("%s Http error occurred: %s", ship, e)
 
                 if req_cont_len <= 0
                   # no post data
@@ -220,14 +232,14 @@ module Baykit
               end
 
             else
-              if BayServer.harbor.trace_header?
+              if BayServer.harbor.trace_header
                 BayLog.info("%s Read FcgiParam", tur)
               end
 
               cmd.params.each do |nv|
                 name = nv[0]
                 value = nv[1]
-                if BayServer.harbor.trace_header?
+                if BayServer.harbor.trace_header
                   BayLog.info("%s  param: %s=%s", tur, name, value);
                 end
                 @env[name] = value
@@ -257,41 +269,48 @@ module Baykit
           end
 
           def handle_stdin(cmd)
-            BayLog.debug("%s handle_stdin req_id=%d len=%d", @ship, cmd.req_id, cmd.length)
+            BayLog.debug("%s handle_stdin req_id=%d len=%d", ship, cmd.req_id, cmd.length)
 
             if @state != STATE_READ_STDIN
               raise ProtocolException.new("Invalid FCGI command: %d state=%d", cmd.type, @state)
             end
 
-            check_req_id(cmd.req_id)
-
-            tur = @ship.get_tour(cmd.req_id)
-            if cmd.length == 0
-              #  request content completed
-              if tur.error != nil
-                # Error has occurred on header completed
-                tur.res.set_consume_listener do |len, resume|
+            begin
+              check_req_id(cmd.req_id)
+
+              tur = ship.get_tour(cmd.req_id)
+              if cmd.length == 0
+                #  request content completed
+                if tur.error != nil
+                  # Error has occurred on header completed
+                  BayLog.debug("%s Delay send error", tur)
+                  raise tur.error
+                else
+                  begin
+                    end_req_content(Tour::TOUR_ID_NOCHECK, tur)
+                    return NextSocketAction::CONTINUE
+                  end
                 end
-                tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, tur.error)
-                reset_state()
-                return NextSocketAction::WRITE
               else
-                begin
-                  end_req_content(Tour::TOUR_ID_NOCHECK, tur)
+                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_read(sid)
+                  end
+                end
+
+                if !success
+                  return NextSocketAction::SUSPEND
+                else
                   return NextSocketAction::CONTINUE
-                rescue HttpException => e
-                  tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, e)
-                  return NextSocketAction::WRITE
                 end
               end
-            else
-              success = tur.req.post_content(Tour::TOUR_ID_NOCHECK, cmd.data, cmd.start, cmd.length)
 
-              if !success
-                return NextSocketAction::SUSPEND
-              else
-                return NextSocketAction::CONTINUE
-              end
+            rescue HttpException => e
+              tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, tur.error)
+              tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, e)
+              reset_state()
+              return NextSocketAction::WRITE
             end
           end
 
@@ -300,6 +319,11 @@ module Baykit
           end
 
           private
+
+          def ship
+            return @protocol_handler.ship
+          end
+
           def check_req_id(received_id)
             if received_id == FcgPacket::FCGI_NULL_REQUEST_ID
               raise ProtocolException.new("Invalid request id: %d", received_id)
@@ -310,7 +334,7 @@ module Baykit
             end
 
             if @req_id != received_id
-              BayLog.error("%s invalid request id: received=%d reqId=%d", @ship, received_id, req_id)
+              BayLog.error("%s invalid request id: received=%d reqId=%d", sip, received_id, req_id)
               raise ProtocolException.new("Invalid request id: %d", received_id)
             end
           end
@@ -326,7 +350,7 @@ module Baykit
           end
 
           def end_req_content(check_id, tur)
-            tur.req.end_content(check_id)
+            tur.req.end_req_content(check_id)
             reset_state()
           end
 
@@ -336,7 +360,7 @@ module Baykit
 
             tur.req.remote_port = @env[CgiUtil::REMOTE_PORT].to_i
             tur.req.remote_address = @env[CgiUtil::REMOTE_ADDR]
-            tur.req.remote_host_func = lambda { @req_command.remote_host }
+            tur.req.remote_host_func = lambda { tur.req.remote_address }
 
             tur.req.server_name = @env[CgiUtil::SERVER_NAME]
             tur.req.server_address = @env[CgiUtil::SERVER_ADDR]

data/lib/baykit/bayserver/docker/fcgi/fcg_protocol_handler.rb

@@ -20,17 +20,10 @@ module Baykit
           include Baykit::BayServer::Protocol
           include Baykit::BayServer::Docker::Fcgi::Command
 
-          def initialize(pkt_store, svr_mode)
-            @command_unpacker = FcgCommandUnPacker.new(self)
-            @packet_unpacker = FcgPacketUnPacker.new(pkt_store, @command_unpacker)
-            @packet_packer = PacketPacker.new()
-            @command_packer = CommandPacker.new(@packet_packer, pkt_store)
-            @server_mode = svr_mode
+          def initialize(fcg_handler, pkt_unpacker, pkt_packer, cmd_unpacker, cmd_packer, svr_mode)
+            super(pkt_unpacker, pkt_packer, cmd_unpacker, cmd_packer, fcg_handler, svr_mode)
           end
 
-          def inspect()
-            return "PH[#{@ship}]"
-          end
 
           ######################################################
           # Implements ProtocolHandler

data/lib/baykit/bayserver/docker/fcgi/fcg_warp_docker.rb

@@ -1,18 +1,20 @@
 require 'baykit/bayserver/bcf/package'
-require 'baykit/bayserver/docker/warp/warp_docker'
-require 'baykit/bayserver/agent/transporter/plain_transporter'
+require 'baykit/bayserver/docker/base/warp_base'
+require 'baykit/bayserver/agent/multiplexer/plain_transporter'
 require 'baykit/bayserver/docker/fcgi/package'
+require 'baykit/bayserver/util/io_util'
 
 module Baykit
   module BayServer
     module Docker
       module Fcgi
-        class FcgWarpDocker < Baykit::BayServer::Docker::Warp::WarpDocker
+        class FcgWarpDocker < Baykit::BayServer::Docker::Base::WarpBase
           include Baykit::BayServer::Docker::Fcgi::FcgDocker  # implements
 
           include Baykit::BayServer::Bcf
           include Baykit::BayServer::Protocol
-          include Baykit::BayServer::Agent::Transporter
+          include Baykit::BayServer::Util
+          include Baykit::BayServer::Agent::Multiplexer
 
           attr :script_base
           attr :doc_root
@@ -34,7 +36,7 @@ module Baykit
 
           def init_key_val(kv)
             case kv.key.downcase
-            when "scritbase"
+            when "scriptbase"
               @script_base = kv.value
             when "docroot"
               @doc_root = kv.value
@@ -58,8 +60,15 @@ 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
+            )
+            return tp
           end
 
           ######################################################

data/lib/baykit/bayserver/docker/fcgi/fcg_warp_handler.rb

@@ -1,3 +1,5 @@
+require 'baykit/bayserver/sink'
+
 require 'baykit/bayserver/protocol/protocol_exception'
 require 'baykit/bayserver/tours/package'
 require 'baykit/bayserver/agent/next_socket_action'
@@ -6,7 +8,7 @@ require 'baykit/bayserver/util/string_util'
 require 'baykit/bayserver/util/simple_buffer'
 require 'baykit/bayserver/util/cgi_util'
 
-require 'baykit/bayserver/docker/warp/warp_data'
+require 'baykit/bayserver/common/warp_data'
 require 'baykit/bayserver/docker/fcgi/fcg_protocol_handler'
 require 'baykit/bayserver/docker/fcgi/command/package'
 require 'baykit/bayserver/docker/fcgi/fcg_params'
@@ -15,14 +17,24 @@ module Baykit
   module BayServer
     module Docker
       module Fcgi
-        class FcgWarpHandler < Baykit::BayServer::Docker::Fcgi::FcgProtocolHandler
-          include Baykit::BayServer::Docker::Warp::WarpHandler # implements
+        class FcgWarpHandler
+          include Baykit::BayServer::Common::WarpHandler # implements
+          include FcgHandler
 
           class WarpProtocolHandlerFactory
             include Baykit::BayServer::Protocol::ProtocolHandlerFactory  # implements
+            include Baykit::BayServer::Protocol
 
             def create_protocol_handler(pkt_store)
-              return FcgWarpHandler.new(pkt_store)
+              warp_handler =  FcgWarpHandler.new
+              cmd_unpacker = FcgCommandUnPacker.new(warp_handler)
+              pkt_unpacker = FcgPacketUnPacker.new(pkt_store, cmd_unpacker)
+              pkt_packer = PacketPacker.new()
+              cmd_packer = CommandPacker.new(pkt_packer, pkt_store)
+
+              proto_handler = FcgProtocolHandler.new(warp_handler, pkt_unpacker, pkt_packer, cmd_unpacker, cmd_packer, false)
+              warp_handler.init(proto_handler)
+              return proto_handler
             end
           end
 
@@ -30,13 +42,14 @@ module Baykit
           include Baykit::BayServer::Protocol
           include Baykit::BayServer::Tours
           include Baykit::BayServer::Util
-          include Baykit::BayServer::Docker::Warp
+          include Baykit::BayServer::Common
           include Baykit::BayServer::Docker::Fcgi::Command
 
 
           STATE_READ_HEADER = 1
           STATE_READ_CONTENT = 2
 
+          attr :protocol_handler
           attr :cur_warp_id
           attr :state
           attr :line_buf
@@ -45,15 +58,17 @@ module Baykit
           attr :last
           attr :data
 
-          def initialize(pkt_store)
-            super(pkt_store, false)
+          def initialize
             @cur_warp_id = 0
             @line_buf = SimpleBuffer.new
             reset()
           end
 
+          def init(proto_handler)
+            @protocol_handler = proto_handler
+          end
+
           def reset
-            super
             reset_state
             @line_buf.reset
             @pos = 0
@@ -71,28 +86,33 @@ module Baykit
           end
 
           def new_warp_data(warp_id)
-            return WarpData.new(@ship, warp_id)
+            return WarpData.new(ship, warp_id)
           end
 
-          def post_warp_headers(tur)
+          ######################################################
+          # Implements TourHandler
+          ######################################################
+
+          def send_res_headers(tur)
             send_begin_req(tur)
             send_params(tur)
           end
 
-          def post_warp_contents(tur, buf, start, len, &callback)
+          def send_res_content(tur, buf, start, len, &callback)
             send_stdin(tur, buf, start, len, &callback)
           end
 
-          def post_warp_end(tur)
-            callback = lambda do
-              @ship.agent.non_blocking_handler.ask_to_read(@ship.socket)
-            end
+          def send_end_tour(tur, keep_alive, &callback)
             send_stdin(tur, nil, 0, 0, &callback)
           end
 
           def verify_protocol(proto)
           end
 
+          def on_protocol_error(e)
+            raise Sink.new
+          end
+
 
           ######################################################
           # Implements FcgCommandHandler
@@ -103,7 +123,7 @@ module Baykit
           end
 
           def handle_end_request(cmd) 
-            tur = @ship.get_tour(cmd.req_id)
+            tur = ship.get_tour(cmd.req_id)
             end_req_content(tur)
             NextSocketAction::CONTINUE
           end 
@@ -123,10 +143,10 @@ module Baykit
           end
 
           def handle_stdout(cmd)
-            BayLog.debug("%s handle_stdout req_id=%d len=%d", @ship, cmd.req_id, cmd.length)
+            BayLog.debug("%s handle_stdout req_id=%d len=%d", ship, cmd.req_id, cmd.length)
             #BayLog.debug "#{self} handle_stdout data=#{cmd.data}"
 
-            tur = @ship.get_tour(cmd.req_id)
+            tur = ship.get_tour(cmd.req_id)
             if tur == nil
               raise Sink.new("Tour not found")
             end
@@ -146,9 +166,9 @@ module Baykit
             end
 
             if @pos < @last
-              BayLog.debug("%s fcgi: pos=%d last=%d len=%d", @ship, @pos, @last, @last - @pos)
+              BayLog.debug("%s fcgi: pos=%d last=%d len=%d", ship, @pos, @last, @last - @pos)
               if @state == STATE_READ_CONTENT
-                available = tur.res.send_content(Tour::TOUR_ID_NOCHECK, @data, @pos, @last - @pos)
+                available = tur.res.send_res_content(Tour::TOUR_ID_NOCHECK, @data, @pos, @last - @pos)
                 if !available
                   return NextSocketAction::SUSPEND
                 end
@@ -158,6 +178,10 @@ module Baykit
             NextSocketAction::CONTINUE
           end
 
+          ######################################################
+          # Implements FcgCommandHandler
+          ######################################################
+
           ######################################################
           # Custom methods
           ######################################################
@@ -179,11 +203,11 @@ module Baykit
                 tur.res.headers.remove(Headers::STATUS)
               end
 
-              BayLog.debug("%s fcgi: read header status=%d contlen=%d", @ship, tur.res.headers.status, wdat.res_headers.content_length())
-              sid = @ship.ship_id
+              BayLog.debug("%s fcgi: read header status=%d contlen=%d", ship, tur.res.headers.status, wdat.res_headers.content_length())
+              sid = ship.ship_id
               tur.res.set_consume_listener do |len, resume|
                 if resume
-                  @ship.resume(sid)
+                  ship.resume_read(sid)
                 end
               end
 
@@ -229,8 +253,8 @@ module Baykit
                   end
 
                   headers.add(name, value)
-                  if BayServer.harbor.trace_header?
-                    BayLog.info("%s fcgi_warp: resHeader: %s=%s", @ship, name, value)
+                  if BayServer.harbor.trace_header
+                    BayLog.info("%s fcgi_warp: resHeader: %s=%s", ship, name, value)
                   end
                 end
                 @line_buf.reset()
@@ -242,8 +266,8 @@ module Baykit
           end
 
           def end_req_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
 
@@ -258,18 +282,18 @@ module Baykit
 
           def send_stdin(tur, data, ofs, len, &callback)
             cmd = CmdStdIn.new(WarpData.get(tur).warp_id, data, ofs, len)
-            @ship.post(cmd, callback)
+            ship.post(cmd, &callback)
           end
 
           def send_begin_req(tur)
             cmd = CmdBeginRequest.new(WarpData.get(tur).warp_id)
             cmd.role = CmdBeginRequest::FCGI_RESPONDER
             cmd.keep_conn = true
-            @ship.post(cmd)
+            ship.post(cmd)
           end
 
           def send_params(tur)
-            script_base = @ship.docker.script_base
+            script_base = ship.docker.script_base
             if script_base == nil
               script_base = tur.town.location
             end
@@ -278,7 +302,7 @@ module Baykit
               raise StandardError.new("#{tur.town} Could not create SCRIPT_FILENAME. Location of town not specified.")
             end
 
-            doc_root = @ship.docker.doc_root
+            doc_root = ship.docker.doc_root
             if doc_root == nil
               doc_root = tur.town.location
             end
@@ -298,7 +322,7 @@ module Baykit
               end
             end
 
-            script_fname = "proxy:fcgi://#{@ship.docker.host}:#{@ship.docker.port}#{script_fname}"
+            script_fname = "proxy:fcgi://#{ship.docker.host}:#{ship.docker.port}#{script_fname}"
             cmd.add_param(CgiUtil::SCRIPT_FILENAME, script_fname)
 
             # Add FCGI params
@@ -308,18 +332,21 @@ module Baykit
             #cmd.add_param(FcgParams::X_FORWARDED_PROTO, tur.is_secure ? "https" : "http")
             #cmd.add_param(FcgParams::X_FORWARDED_PORT, tur.req.req_port.to_s)
 
-            if BayServer.harbor.trace_header?
+            if BayServer.harbor.trace_header
               cmd.params.each do |kv|
-                BayLog.info("%s fcgi_warp: env: %s=%s", @ship, kv[0], kv[1])
+                BayLog.info("%s fcgi_warp: env: %s=%s", ship, kv[0], kv[1])
               end
             end
 
-            @ship.post(cmd)
+            ship.post(cmd)
 
             cmd_params_end = CmdParams.new(WarpData.get(tur).warp_id)
-            @ship.post(cmd_params_end)
+            ship.post(cmd_params_end)
           end
 
+          def ship
+            return @protocol_handler.ship
+          end
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bayserver-docker-fcgi
 version: !ruby/object:Gem::Version
-  version: 2.3.2
+  version: 3.0.0
 platform: ruby
 authors:
 - Michisuke-P
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-12-23 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.2
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.3.2
+        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.
@@ -46,6 +46,7 @@ files:
 - lib/baykit/bayserver/docker/fcgi/fcg_command_handler.rb
 - lib/baykit/bayserver/docker/fcgi/fcg_command_unpacker.rb
 - lib/baykit/bayserver/docker/fcgi/fcg_docker.rb
+- lib/baykit/bayserver/docker/fcgi/fcg_handler.rb
 - lib/baykit/bayserver/docker/fcgi/fcg_inbound_handler.rb
 - lib/baykit/bayserver/docker/fcgi/fcg_packet.rb
 - lib/baykit/bayserver/docker/fcgi/fcg_packet_factory.rb