bayserver-docker-cgi 2.3.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f6c7a519ed1f67b4b941dfeb5c66c2dff99cd31c645eeeb201a169421e93151
-  data.tar.gz: f161be830e5b01d8db91a4bdc6382398b96a322b3c79e4eb2ff749d7c85d3213
+  metadata.gz: '089b472c6337c1d1fd5ad7ceb32aef640d25e5f10f24b6bc664a8ce07f6dc712'
+  data.tar.gz: cafcd01d757b59b35ddfd524de0d99410b5ce99e8279f0be0867824137df2b02
 SHA512:
-  metadata.gz: 0dd409623f68df7faa3857f3ace43dfae5b12ae30c97c0054f2e01e37b49ac00db03c15da85fe9b376d4f981f3388956c3a0e6c3c4e6203bd7a318e47044756b
-  data.tar.gz: 9173eebb2000009a89c7bc2599a302361fab8259b08019082bd3096f0c37dabd52807d8eb9fd8a7ad1ef068da748029e7a3115ceff016e400271ac4004edc76b
+  metadata.gz: 4377dd1a66ebb4336e0f0cf935a88862d1bc6b580344e7e5727808e0edf963862b8533e5fb1ffea56ab84b39094d716968ae140fdee3ec58c6a27d8f6eee5c26
+  data.tar.gz: e8e6a74006b99e8db55f924280d92670e4205994cd29b79a3f4184ed3082ec4a2ecd50535b94228b75e6aa9addb23301ca9c38c65f2b1b9ac17e1c75bbc2fafb

data/lib/baykit/bayserver/docker/cgi/cgi_docker.rb

@@ -1,13 +1,13 @@
 require 'baykit/bayserver/bcf/package'
-require 'baykit/bayserver/agent/transporter/plain_transporter'
+require 'baykit/bayserver/agent/multiplexer/plain_transporter'
 require 'baykit/bayserver/agent/transporter/spin_read_transporter'
 require 'baykit/bayserver/tours/tour'
 require 'baykit/bayserver/tours/read_file_taxi'
 require 'baykit/bayserver/docker/base/club_base'
 require 'baykit/bayserver/docker/harbor'
 require 'baykit/bayserver/docker/cgi/cgi_req_content_handler'
-require 'baykit/bayserver/docker/cgi/cgi_std_out_yacht'
-require 'baykit/bayserver/docker/cgi/cgi_std_err_yacht'
+require 'baykit/bayserver/docker/cgi/cgi_std_out_ship'
+require 'baykit/bayserver/docker/cgi/cgi_std_err_ship'
 require 'baykit/bayserver/docker/cgi/cgi_message'
 require 'baykit/bayserver/taxi/taxi_runner'
 require 'baykit/bayserver/util/http_status'
@@ -22,30 +22,33 @@ module Baykit
           include Baykit::BayServer::Bcf
           include Baykit::BayServer::Util
           include Baykit::BayServer::Agent
-          include Baykit::BayServer::Agent::Transporter
+          include Baykit::BayServer::Agent::Multiplexer
           include Baykit::BayServer::Docker
           include Baykit::BayServer::Docker::Cgi
           include Baykit::BayServer::Tours
           include Baykit::BayServer::Taxi
+          include Baykit::BayServer::Rudders
 
-          DEFAULT_PROC_READ_METHOD = Harbor::FILE_SEND_METHOD_TAXI
           DEFAULT_TIMEOUT_SEC = 0
 
           attr :interpreter
           attr :script_base
           attr :doc_root
           attr :timeout_sec
+          attr :max_processes
+          attr :process_count
+          attr :wait_count
 
-          # Method to read stdin/stderr
-          attr :proc_read_method
 
           def initialize()
             super
             @interpreter = nil
             @script_base = nil
             @doc_root = nil
-            @proc_read_method = CgiDocker::DEFAULT_PROC_READ_METHOD
             @timeout_sec = CgiDocker::DEFAULT_TIMEOUT_SEC
+            @max_processes = -1
+            @process_count = 0
+            @wait_count = 0
           end
 
           ######################################################
@@ -54,16 +57,6 @@ module Baykit
 
           def init(elm, parent)
             super
-
-            if @proc_read_method == Harbor::FILE_SEND_METHOD_SELECT and !SysUtil.support_select_pipe()
-              BayLog.warn(BayMessage.get(:CGI_PROC_READ_METHOD_SELECT_NOT_SUPPORTED))
-              @proc_read_method = Harbor::FILE_SEND_METHOD_TAXI
-            end
-
-            if @proc_read_method == Harbor::FILE_SEND_METHOD_SPIN and !SysUtil.support_nonblock_pipe_read()
-              BayLog.warn(BayMessage.get(:CGI_PROC_READ_METHOD_SPIN_NOT_SUPPORTED))
-              @proc_read_method = Harbor::FILE_SEND_METHOD_TAXI
-            end
           end
 
 
@@ -82,25 +75,12 @@ module Baykit
             when "docroot"
               @doc_root = kv.value
 
-            when "processreadmethod"
-              case kv.value.downcase()
-
-              when "select"
-                @proc_read_method = Harbor::FILE_SEND_METHOD_SELECT
-
-              when "spin"
-                @proc_read_method = Harbor::FILE_SEND_METHOD_SPIN
-
-              when "taxi"
-                @proc_read_method = Harbor::FILE_SEND_METHOD_TAXI
-
-              else
-                raise ConfigException.new(kv.file_name, kv.line_no, BayMessage.get(:CFG_INVALID_PARAMETER_VALUE, kv.value))
-              end
-
             when "timeout"
               @timeout_sec = kv.value.to_i
 
+            when "maxprocesses"
+              @max_processes = kv.value.to_i
+
             else
               return super
             end
@@ -137,7 +117,7 @@ module Baykit
             end
 
             env = CgiUtil.get_env_hash(tur.town.name, root, base, tur)
-            if BayServer.harbor.trace_header?
+            if BayServer.harbor.trace_header
               env.keys.each do |name|
                 value = env[name]
                 BayLog.info("%s cgi: env: %s=%s", tur, name, value)
@@ -149,67 +129,9 @@ module Baykit
               raise HttpException.new(HttpStatus::NOT_FOUND, file_name)
             end
 
-            bufsize = 8192;
-            handler = CgiReqContentHandler.new(self, tur)
+            handler = CgiReqContentHandler.new(self, tur, env)
             tur.req.set_content_handler(handler)
-            handler.start_tour(env)
-            fname = "cgi#"
-
-            out_yat = CgiStdOutYacht.new()
-            err_yat = CgiStdErrYacht.new()
-
-            case(@proc_read_method)
-            when Harbor::FILE_SEND_METHOD_SELECT
-              out_tp = PlainTransporter.new(false, bufsize)
-              out_yat.init(tur, out_tp, handler)
-              out_tp.init(tur.ship.agent.non_blocking_handler, handler.std_out[0], out_yat)
-              out_tp.open_valve()
-
-              err_tp = PlainTransporter.new(false, bufsize)
-              err_yat.init(tur, handler)
-              err_tp.init(tur.ship.agent.non_blocking_handler, handler.std_err[0], err_yat)
-              err_tp.open_valve()
-
-            when Harbor::FILE_SEND_METHOD_SPIN
-
-              def eof_checker()
-                begin
-                  pid = Process.wait(handler.pid,  Process::WNOHANG)
-                  return pid != nil
-                rescue Errno::ECHILD => e
-                  BayLog.error_e(e)
-                  return true
-                end
-              end
-
-              out_tp = SpinReadTransporter.new(bufsize)
-              out_yat.init(tur, out_tp, handler)
-              out_tp.init(tur.ship.agent.spin_handler, out_yat, handler.std_out[0], -1, @timeout_sec, eof_checker)
-              out_tp.open_valve()
-
-              err_tp = SpinReadTransporter.new(bufsize)
-              err_yat.init(tur, handler)
-              err_tp.init(tur.ship.agent.spin_handler, err_yat, handler.std_out[0], -1, @timeout_sec, eof_checker)
-              err_tp.open_valve()
-
-            when Harbor::FILE_SEND_METHOD_TAXI
-              out_txi = ReadFileTaxi.new(tur.ship.agent.agent_id, bufsize)
-              out_yat.init(tur, out_txi, handler)
-              out_txi.init(handler.std_out[0], out_yat)
-              if !TaxiRunner.post(tur.ship.agent.agent_id, out_txi)
-                raise HttpException.new(HttpStatus.SERVICE_UNAVAILABLE, "Taxi is busy!")
-              end
-
-              err_txi = ReadFileTaxi.new(tur.ship.agent.agent_id, bufsize)
-              err_yat.init(tur, handler)
-              err_txi.init(handler.std_err[0], err_yat)
-              if !TaxiRunner.post(tur.ship.agent.agent_id, err_txi)
-                raise HttpException.new(HttpStatus.SERVICE_UNAVAILABLE, "Taxi is busy!")
-              end
-
-            else
-              raise Sink.new();
-            end
+            handler.req_start_tour()
           end
 
           def create_command(env)
@@ -221,6 +143,33 @@ module Baykit
             end
             command
           end
+
+          ######################################################
+          # Other methods
+          ######################################################
+
+          def get_wait_count
+            @wait_count
+          end
+
+          def add_process_count
+            if @max_processes <= 0 || @process_count < @max_processes
+              @process_count += 1
+              BayLog.debug("%s Process count: %d", self, @process_count)
+              return true
+            end
+
+            @wait_count += 1
+            return false
+          end
+
+          def sub_process_count
+            return @process_count -= 1
+          end
+
+          def sub_wait_count
+            return @wait_count -= 1
+          end
         end
       end
     end

data/lib/baykit/bayserver/docker/cgi/cgi_req_content_handler.rb

@@ -1,6 +1,10 @@
+require 'baykit/bayserver/agent/grand_agent'
+require 'baykit/bayserver/agent/multiplexer/plain_transporter'
+require 'baykit/bayserver/common/postpone'
 require 'baykit/bayserver/train/train'
 require 'baykit/bayserver/tours/req_content_handler'
 
+require 'baykit/bayserver/rudders/io_rudder'
 require 'baykit/bayserver/util/string_util'
 require 'baykit/bayserver/util/http_status'
 
@@ -10,10 +14,13 @@ module Baykit
       module Cgi
         class CgiReqContentHandler
           include Baykit::BayServer::Tours::ReqContentHandler   # implements
+          include Baykit::BayServer::Common::Postpone   # implements
 
           include Baykit::BayServer::Agent
+          include Baykit::BayServer::Agent::Multiplexer
           include Baykit::BayServer::Train
           include Baykit::BayServer::Tours
+          include Baykit::BayServer::Rudders
           include Baykit::BayServer::Util
 
           READ_CHUNK_SIZE = 8192
@@ -23,50 +30,67 @@ module Baykit
           attr :tour_id
           attr :available
           attr :pid
-          attr :std_in
-          attr :std_out
-          attr :std_err
+          attr :std_in_rd
+          attr :std_out_rd
+          attr :std_err_rd
           attr :std_out_closed
           attr :std_err_closed
           attr :last_access
+          attr_accessor :multiplexer
+          attr :env
 
-          def initialize(cgi_docker, tur)
+          def initialize(cgi_docker, tur, env)
             @cgi_docker = cgi_docker
             @tour = tur
             @tour_id = tur.tour_id
+            @env = env
             @std_out_closed = true
             @std_err_closed = true
           end
 
+          ######################################################
+          # Implements Postpone
+          ######################################################
+          def run
+            @cgi_docker.sub_wait_count
+            BayLog.info("%s challenge postponed tour", @tour, @cgi_docker.get_wait_count)
+            req_start_tour
+          end
+
           ######################################################
           # Implements ReqContentHandler
           ######################################################
 
-          def on_read_content(tur, buf, start, len)
+          def on_read_req_content(tur, buf, start, len, &callback)
             BayLog.debug("%s CGI:onReadReqContent: len=%d", tur, len)
 
-            wrote_len = @std_in[1].write(buf[start, len])
+            wrote_len = @std_in_rd.write(buf[start, len])
             BayLog.debug("%s CGI:onReadReqContent: wrote=%d", tur, wrote_len)
-            tur.req.consumed(Tour::TOUR_ID_NOCHECK, len)
+            tur.req.consumed(Tour::TOUR_ID_NOCHECK, len, &callback)
             access()
           end
 
-          def on_end_content(tur)
+          def on_end_req_content(tur)
             BayLog.trace("%s CGI:endReqContent", tur)
             access()
           end
 
-          def on_abort(tur)
+          def on_abort_req(tur)
             BayLog.debug("%s CGI:abortReq", tur)
+
             if !@std_out_closed
-              @tour.ship.agent.non_blocking_handler.ask_to_close(@std_out[0])
+              @multiplexer.req_close(@std_out_rd)
             end
             if !@std_err_closed
-              @tour.ship.agent.non_blocking_handler.ask_to_close(@std_err[0])
+              @multiplexer.req_close(@std_err_rd)
             end
 
-            BayLog.debug("%s KILL PROCESS!: %d", tur, @pid)
-            Process.kill('KILL', @pid)
+            if @pid == nil
+              BayLog.warn("%s Cannot kill process (pid is null)", tur)
+            else
+              BayLog.debug("%s KILL PROCESS!: %d", tur, @pid)
+              Process.kill('KILL', @pid)
+            end
 
             return false  # not aborted immediately
           end
@@ -75,29 +99,110 @@ module Baykit
           # Other methods
           ######################################################
 
-          def start_tour(env)
+          def req_start_tour
+            if @cgi_docker.add_process_count
+              BayLog.info("%s start tour: wait count=%d", @tour, @cgi_docker.get_wait_count)
+              start_tour
+            else
+              BayLog.warn("%s Cannot start tour: wait count=%d", @tour, @cgi_docker.get_wait_count)
+              agt = GrandAgent.get(@tour.ship.agent_id)
+              agt.add_postpone(self)
+            end
+            access()
+          end
+
+          def start_tour
             @available = false
 
-            @std_in = IO.pipe()
-            @std_out = IO.pipe()
-            @std_err = IO.pipe()
-            @std_in[1].set_encoding("ASCII-8BIT")
-            @std_out[0].set_encoding("ASCII-8BIT")
-            @std_err[0].set_encoding("ASCII-8BIT")
+            std_in = IO.pipe()
+            std_out = IO.pipe()
+            std_err = IO.pipe()
+            std_in[1].set_encoding("ASCII-8BIT")
+            std_out[0].set_encoding("ASCII-8BIT")
+            std_err[0].set_encoding("ASCII-8BIT")
 
-            command = @cgi_docker.create_command(env)
+            command = @cgi_docker.create_command(@env)
             BayLog.debug("%s Spawn: %s", @tour, command)
-            @pid = Process.spawn(env, command, :in => @std_in[0], :out => @std_out[1], :err => @std_err[1])
+            @pid = Process.spawn(env, command, :in => std_in[0], :out => std_out[1], :err => std_err[1])
             BayLog.debug("%s created process; %s", @tour, @pid)
 
-            @std_in[0].close()
-            @std_out[1].close()
-            @std_err[1].close()
+            std_in[0].close()
+            std_out[1].close()
+            std_err[1].close()
+
+            @std_in_rd = IORudder.new(std_in[1])
+            @std_out_rd = IORudder.new(std_out[0])
+            @std_err_rd = IORudder.new(std_err[0])
             BayLog.debug("#{@tour} PID: #{pid}")
 
             @std_out_closed = false
             @std_err_closed = false
-            access()
+
+            bufsize = 8192
+
+            agt = GrandAgent.get(@tour.ship.agent_id)
+
+            case(BayServer.harbor.cgi_multiplexer)
+            when Harbor::MULTIPLEXER_TYPE_SPIDER
+              mpx = agt.spider_multiplexer
+              @std_out_rd.set_non_blocking
+              @std_err_rd.set_non_blocking
+
+            when Harbor::MULTIPLEXER_TYPE_SPIN
+
+              def eof_checker()
+                begin
+                  pid = Process.wait(handler.pid,  Process::WNOHANG)
+                  return pid != nil
+                rescue Errno::ECHILD => e
+                  BayLog.error_e(e)
+                  return true
+                end
+              end
+              mpx = agt.spin_multiplexer
+              @std_out_rd.set_non_blocking
+              @std_err_rd.set_non_blocking
+
+            when Harbor::MULTIPLEXER_TYPE_TAXI
+              mpx = agt.taxi_multiplexer
+
+            when Harbor::MULTIPLEXER_TYPE_JOB
+              mpx = agt.job_multiplexer
+
+            else
+              raise Sink.new();
+            end
+
+            if mpx != nil
+              @multiplexer = mpx
+              out_ship = CgiStdOutShip.new
+              out_tp = PlainTransporter.new(agt.net_multiplexer, out_ship, false, bufsize, false)
+
+              out_ship.init_std_out(@std_out_rd, @tour.ship.agent_id, @tour, out_tp, self)
+
+              mpx.add_rudder_state(
+                @std_out_rd,
+                RudderState.new(@std_out_rd, out_tp)
+              )
+
+              ship_id = @tour.ship.ship_id
+              @tour.res.set_consume_listener do |len, resume|
+                if resume
+                  out_ship.resume_read(ship_id)
+                end
+              end
+
+              err_ship = CgiStdErrShip.new
+              err_tp = PlainTransporter.new(agt.net_multiplexer, err_ship, false, bufsize, false)
+              err_ship.init_std_err(@std_err_rd, @tour.ship.agent_id, self)
+              mpx.add_rudder_state(
+                @std_err_rd,
+                RudderState.new(@std_err_rd, err_tp)
+              )
+
+              mpx.req_read(@std_out_rd)
+              mpx.req_read(@std_err_rd)
+            end
           end
 
           def std_out_closed()
@@ -115,7 +220,7 @@ module Baykit
           end
 
           def access()
-            @last_access = Time.now.to_i
+            @last_access = Time.now.tv_sec
           end
 
           def timed_out()
@@ -123,7 +228,7 @@ module Baykit
               return false
             end
 
-            duration_sec = Time.now.to_i - @last_access
+            duration_sec = Time.now.tv_sec - @last_access
             BayLog.debug("%s Check CGI timeout: dur=%d, timeout=%d", @tour, duration_sec, @cgi_docker.timeout_sec)
             return duration_sec > @cgi_docker.timeout_sec
           end
@@ -132,9 +237,8 @@ module Baykit
             BayLog.debug("%s CGI Process finished: pid=%s", @tour, @pid)
 
             pid, stat = Process.wait2(@pid)
-            print(stat)
-
             BayLog.debug("%s CGI Process finished: pid=%s code=%s", @tour, pid, stat.exitstatus)
+            agt_id = @tour.ship.agent_id
 
             begin
               if stat.exitstatus != 0
@@ -142,11 +246,18 @@ module Baykit
                 BayLog.error("%s CGI Invalid exit status pid=%d code=%s", @tour, @pid, stat.exitstatus)
                 @tour.res.send_error(@tour_id, HttpStatus::INTERNAL_SERVER_ERROR, "Invalid exit Status")
               else
-                @tour.res.end_content(@tour_id)
+                @tour.res.end_res_content(@tour_id)
               end
             rescue IOError => e
               BayLog.error_e(e)
             end
+
+            @cgi_docker.sub_process_count
+            if @cgi_docker.get_wait_count > 0
+              BayLog.warn("agt#%d Catch up postponed process: process wait count=%d", agt_id, @cgi_docker.get_wait_count)
+              agt = GrandAgent.get(agt_id)
+              agt.req_catch_up
+            end
           end
         end
       end

data/lib/baykit/bayserver/docker/cgi/{cgi_std_err_yacht.rb → cgi_std_err_ship.rb}

@@ -1,5 +1,5 @@
 require 'baykit/bayserver/agent/next_socket_action'
-require 'baykit/bayserver/watercraft/yacht'
+require 'baykit/bayserver/common/read_only_ship'
 require 'baykit/bayserver/util/string_util'
 require 'baykit/bayserver/util/reusable'
 
@@ -7,13 +7,11 @@ module Baykit
   module BayServer
     module Docker
       module Cgi
-        class CgiStdErrYacht < Baykit::BayServer::WaterCraft::Yacht
+        class CgiStdErrShip < Baykit::BayServer::Common::ReadOnlyShip
 
           include Baykit::BayServer::Agent
           include Baykit::BayServer::Util
 
-          attr :tour
-          attr :tour_id
           attr :handler
 
           def initialize
@@ -21,8 +19,13 @@ module Baykit
             reset()
           end
 
+          def init_std_err(rd, agt_id, handler)
+            init(agt_id, rd, nil)
+            @handler = handler
+          end
+
           def to_s()
-            return "CGIErrYat##{@yacht_id}/#{@object_id} tour=#{@tour} id=#{@tour_id}";
+            return "agt#{@agent_id} err_ship#{@ship_id}/#{@object_id}";
           end
 
           ######################################################
@@ -30,16 +33,15 @@ module Baykit
           ######################################################
 
           def reset()
-            @tour = nil
-            @tour_id = 0
+            super
             @handler = nil
           end
 
           ######################################################
-          # implements Yacht
+          # implements ReadOnlyShip
           ######################################################
 
-          def notify_read(buf, adr)
+          def notify_read(buf)
 
             BayLog.debug("%s CGI StdErr %d bytesd", self, buf.length)
             if(buf.length() > 0)
@@ -50,14 +52,18 @@ module Baykit
 
           end
 
+          def notify_error(e)
+            BayLog.debug_e(e)
+          end
+
           def notify_eof()
-            BayLog.debug("%s stderr EOF\\(^o^)/", @tour)
+            BayLog.debug("agt#%d CGI stderr EOF\\(^o^)/", @agent_id)
             return NextSocketAction::CLOSE
           end
 
           def notify_close()
-            BayLog.debug("%s stderr notifyClose", @tour)
-            @tour.req.content_handler.std_err_closed()
+            BayLog.debug("agt#%d CGI stderr notifyClose", @agent_id)
+            @handler.std_err_closed()
           end
 
           def check_timeout(duration_sec)
@@ -69,12 +75,6 @@ module Baykit
           # Custom methods
           ######################################################
 
-          def init(tur, handler)
-            init_yacht()
-            @tour = tur
-            @tour_id = tur.tour_id
-            @handler = handler
-          end
         end
       end
     end

data/lib/baykit/bayserver/docker/cgi/{cgi_std_out_yacht.rb → cgi_std_out_ship.rb}

@@ -1,5 +1,5 @@
 require 'baykit/bayserver/agent/next_socket_action'
-require 'baykit/bayserver/watercraft/yacht'
+require 'baykit/bayserver/common/read_only_ship'
 require 'baykit/bayserver/util/string_util'
 require 'baykit/bayserver/util/reusable'
 
@@ -7,7 +7,7 @@ module Baykit
   module BayServer
     module Docker
       module Cgi
-        class CgiStdOutYacht < Baykit::BayServer::WaterCraft::Yacht
+        class CgiStdOutShip < Baykit::BayServer::Common::ReadOnlyShip
 
           include Baykit::BayServer::Agent
           include Baykit::BayServer::Util
@@ -26,8 +26,16 @@ module Baykit
             reset()
           end
 
+          def init_std_out(rd, agent_id, tur, tp, handler)
+            init(agent_id, rd, tp)
+            @handler = handler
+            @tour = tur
+            @tour_id = tur.tour_id
+            @header_reading = true
+          end
+
           def to_s()
-            return "CGIYat##{@yacht_id}/#{@object_id} tour=#{@tour} id=#{@tour_id}";
+            return "agt##{@agent_id} out_ship#{@ship_id}/#{@object_id}";
           end
 
           ######################################################
@@ -44,10 +52,10 @@ module Baykit
           end
 
           ######################################################
-          # implements Yacht
+          # implements ReadOnlyShip
           ######################################################
 
-          def notify_read(buf, adr)
+          def notify_read(buf)
             @file_wrote_len += buf.length
             BayLog.trace("%s read file %d bytes: total=%d", self, buf.length, @file_wrote_len)
 
@@ -110,7 +118,7 @@ module Baykit
               @remain += buf[pos .. -1]
             else
               if buf.length - pos > 0
-                available = @tour.res.send_content(@tour_id, buf, pos, buf.length - pos);
+                available = @tour.res.send_res_content(@tour_id, buf, pos, buf.length - pos);
               end
             end
 
@@ -123,6 +131,10 @@ module Baykit
 
           end
 
+          def notify_error(e)
+            BayLog.debug_e(e, "%s CGI notifyError", self)
+          end
+
           def notify_eof()
             BayLog.debug("%s stdout EOF(^o^)", @tour)
             return NextSocketAction::CLOSE
@@ -130,7 +142,7 @@ module Baykit
 
           def notify_close()
             BayLog.debug("%s stdout notifyClose", @tour)
-            @tour.req.content_handler.std_out_closed()
+            @handler.std_out_closed()
           end
 
           def check_timeout(duration_sec)
@@ -150,17 +162,6 @@ module Baykit
           # Custom methods
           ######################################################
 
-          def init(tur, valve, handler)
-            init_yacht()
-            @handler = handler
-            @tour = tur
-            @tour_id = tur.tour_id
-            tur.res.set_consume_listener do |len, resume|
-              if resume
-                valve.open_valve();
-              end
-            end
-          end
         end
       end
     end

data/lib/baykit/bayserver/docker/cgi/cgi_train.rb

@@ -64,7 +64,7 @@ module Baykit
               # Handle StdOut
               HttpUtil.parse_message_headers(@std_out[0], @tour.res.headers)
 
-              if BayServer.harbor.trace_header?
+              if BayServer.harbor.trace_header
                 @tour.res.headers.names.each do |name|
                   @tour.res.headers.values(name).each do |value|
                     BayLog.info("%s CGI: resHeader: %s=%s", @tour, name, value)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bayserver-docker-cgi
 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.
@@ -37,8 +37,8 @@ files:
 - lib/baykit/bayserver/docker/cgi/cgi_docker.rb
 - lib/baykit/bayserver/docker/cgi/cgi_message.rb
 - lib/baykit/bayserver/docker/cgi/cgi_req_content_handler.rb
-- lib/baykit/bayserver/docker/cgi/cgi_std_err_yacht.rb
-- lib/baykit/bayserver/docker/cgi/cgi_std_out_yacht.rb
+- lib/baykit/bayserver/docker/cgi/cgi_std_err_ship.rb
+- lib/baykit/bayserver/docker/cgi/cgi_std_out_ship.rb
 - lib/baykit/bayserver/docker/cgi/cgi_train.rb
 - lib/baykit/bayserver/docker/cgi/php_cgi_docker.rb
 homepage: https://baykit.yokohama