bayserver-docker-cgi 2.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8c40b3461b0d48853cda84ce66339ccd38cb7c8df440545db4704bc977d7d222
+  data.tar.gz: 55fbb0b776f0f507ea2c992d42e763ee8b4be06c3832f9bf0edb639a22724604
+SHA512:
+  metadata.gz: aab5f4a311b0d0b1f5290485b8bffa43f149dc34b541618ead9b4c814494505f9d353c37cc129f4859d439b30aa123bf8012e0f25a9a7c377d744846401d2d42
+  data.tar.gz: d2e34ba6288296842337128f1bd13dc35b219fb6ad6dce045e0ba6aa963a36bfc2c92a2b12eefe4d99407395a449f9666d0f5dc7d7b526a5e07c10a4d4d3dcaf

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

@@ -0,0 +1,226 @@
+require 'baykit/bayserver/bcf/package'
+require 'baykit/bayserver/agent/transporter/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_message'
+require 'baykit/bayserver/taxi/taxi_runner'
+require 'baykit/bayserver/util/http_status'
+require 'baykit/bayserver/util/cgi_util'
+require 'baykit/bayserver/util/sys_util'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Cgi
+        class CgiDocker < Baykit::BayServer::Docker::Base::ClubBase
+          include Baykit::BayServer::Bcf
+          include Baykit::BayServer::Util
+          include Baykit::BayServer::Agent
+          include Baykit::BayServer::Agent::Transporter
+          include Baykit::BayServer::Docker
+          include Baykit::BayServer::Docker::Cgi
+          include Baykit::BayServer::Tours
+          include Baykit::BayServer::Taxi
+
+          DEFAULT_PROC_READ_METHOD = Harbor::FILE_SEND_METHOD_TAXI
+          DEFAULT_TIMEOUT_SEC = 60
+
+          attr :interpreter
+          attr :script_base
+          attr :doc_root
+
+          # 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
+          end
+
+          ######################################################
+          # Implements Docker
+          ######################################################
+
+          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
+
+
+          ######################################################
+          # Implements DockerBase
+          ######################################################
+
+          def init_key_val(kv)
+            case kv.key.downcase
+            when "interpreter"
+              @interpreter = kv.value
+
+            when "scriptbase"
+              @script_base = kv.value
+
+            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
+
+              when "timeout"
+                @timeout_sec = int(kv.value)
+
+              else
+                raise ConfigException.new(kv.file_name, kv.line_no, BayMessage.get(:CFG_INVALID_PARAMETER_VALUE, kv.value))
+              end
+            else
+              return super
+            end
+            return true
+          end
+
+          ######################################################
+          # Implements Club
+          ######################################################
+
+          def arrive(tur)
+
+            if tur.req.uri.include?("..")
+              raise HttpException.new(HttpStatus::FORBIDDEN, tur.req.uri)
+              return
+            end
+
+            base = script_base
+            if base == nil
+              base = tur.town.location()
+            end
+
+            if StringUtil.empty?(base)
+              raise HttpException.new(HttpStatus::INTERNAL_SERVER_ERROR, "%s scriptBase of cgi docker or location of town is not specified.", tur.town)
+            end
+
+            root = doc_root
+            if root == nil
+              root = tur.town.location()
+            end
+
+            if StringUtil.empty?(root)
+              raise HttpException.new(HttpStatus::INTERNAL_SERVER_ERROR, "$s docRoot of cgi docker or location of town is not specified.", tur.town)
+            end
+
+            env = CgiUtil.get_env_hash(tur.town.name, root, base, tur)
+            if BayServer.harbor.trace_header?
+              env.keys.each do |name|
+                value = env[name]
+                BayLog.info("%s cgi: env: %s=%s", tur, name, value)
+              end
+            end
+
+            file_name = env[CgiUtil::SCRIPT_FILENAME]
+            if !File.file?(file_name)
+              raise HttpException.new(HttpStatus::NOT_FOUND, file_name)
+            end
+
+            bufsize = 8192;
+            handler = CgiReqContentHandler.new(self, tur)
+            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)
+              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)
+              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)
+              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)
+              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(bufsize)
+              out_yat.init(tur, out_txi)
+              out_txi.init(handler.std_out[0], out_yat)
+              if !TaxiRunner.post(out_txi)
+                raise HttpException.new(HttpStatus.SERVICE_UNAVAILABLE, "Taxi is busy!")
+              end
+
+              err_txi = ReadFileTaxi.new(bufsize)
+              err_yat.init(tur)
+              err_txi.init(handler.std_err[0], err_yat)
+              if !TaxiRunner.post(err_txi)
+                raise HttpException.new(HttpStatus.SERVICE_UNAVAILABLE, "Taxi is busy!")
+              end
+
+            else
+              raise Sink.new();
+            end
+          end
+
+          def create_command(env)
+            script = env[CgiUtil::SCRIPT_FILENAME]
+            if @interpreter == nil
+              command = script
+            else
+              command = @interpreter + " " + script
+            end
+            command
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'baykit/bayserver/bayserver'
+require 'baykit/bayserver/util/message'
+require 'baykit/bayserver/util/locale'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Cgi
+        class CgiMessage
+          include Util
+
+          class << self
+            def initialize()
+              self.init()
+            end
+          end
+
+          @@msg = Message.new
+
+          def self.init()
+            @msg.init(BayServer.bserv_home + "/lib/conf/cgi_messages", Locale.default())
+          end
+
+          def self.get(key, *args)
+            return @@msg.get(key, *args)
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+require 'baykit/bayserver/train/train'
+require 'baykit/bayserver/tours/req_content_handler'
+
+require 'baykit/bayserver/util/string_util'
+require 'baykit/bayserver/util/http_status'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Cgi
+        class CgiReqContentHandler
+          include Baykit::BayServer::Tours::ReqContentHandler   # implements
+
+          include Baykit::BayServer::Agent
+          include Baykit::BayServer::Train
+          include Baykit::BayServer::Tours
+          include Baykit::BayServer::Util
+
+          READ_CHUNK_SIZE = 8192
+
+          attr :cgi_docker
+          attr :tour
+          attr :tour_id
+          attr :available
+          attr :pid
+          attr :std_in
+          attr :std_out
+          attr :std_err
+          attr :std_out_closed
+          attr :std_err_closed
+
+          def initialize(cgi_docker, tur)
+            @cgi_docker = cgi_docker
+            @tour = tur
+            @tour_id = tur.tour_id
+          end
+
+          ######################################################
+          # Implements ReqContentHandler
+          ######################################################
+
+          def on_read_content(tur, buf, start, len)
+            BayLog.debug("%s CGI:onReadReqContent: len=%d", tur, len)
+
+            wrote_len = @std_in[1].write(buf[start, len])
+            BayLog.debug("%s CGI:onReadReqContent: wrote=%d", tur, wrote_len)
+            tur.req.consumed(Tour::TOUR_ID_NOCHECK, len)
+          end
+
+          def on_end_content(tur)
+            BayLog.trace("%s CGI:endReqContent", tur)
+          end
+
+          def on_abort(tur)
+            BayLog.debug("%s CGI:abortReq", tur)
+            if !@std_out_closed
+              @tour.ship.agent.non_blocking_handler.ask_to_close(@std_out[0])
+            end
+            if !@std_err_closed
+              @tour.ship.agent.non_blocking_handler.ask_to_close(@std_err[0])
+            end
+
+            BayLog.debug("%s KILL PROCESS!: %d", tur, @pid)
+            Process.kill('KILL', @pid)
+
+            return false  # not aborted immediately
+          end
+
+          ######################################################
+          # Other methods
+          ######################################################
+
+          def start_tour(env)
+            @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")
+
+            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])
+            BayLog.debug("%s created process; %s", @tour, @pid)
+
+            @std_in[0].close()
+            @std_out[1].close()
+            @std_err[1].close()
+            BayLog.debug("#{@tour} PID: #{pid}")
+
+            @std_out_closed = false
+            @std_err_closed = false
+
+          end
+
+          def std_out_closed()
+            @std_out_closed = true
+            if @std_out_closed && @std_err_closed
+              process_finished()
+            end
+          end
+
+          def std_err_closed()
+            @std_err_closed = true
+            if @std_out_closed && @std_err_closed
+              process_finished()
+            end
+          end
+
+          def process_finished()
+            pid, stat = Process.wait2(@pid)
+
+            BayLog.debug("%s CGI Process finished: pid=%s code=%s", @tour, pid, stat.exitstatus)
+            if pid == nil
+              BayLog.error("Process not finished: %d", @pid)
+            end
+
+            begin
+              if stat.exitstatus != 0
+                # Exec failed
+                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)
+              end
+            rescue IOError => e
+              BayLog.error_e(e)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require 'baykit/bayserver/agent/next_socket_action'
+require 'baykit/bayserver/watercraft/yacht'
+require 'baykit/bayserver/util/string_util'
+require 'baykit/bayserver/util/reusable'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Cgi
+        class CgiStdErrYacht < Baykit::BayServer::WaterCraft::Yacht
+
+          include Baykit::BayServer::Agent
+          include Baykit::BayServer::Util
+
+          attr :tour
+          attr :tour_id
+
+          def initialize
+            super
+            reset()
+          end
+
+          def to_s()
+            return "CGIErrYat##{@yacht_id}/#{@object_id} tour=#{@tour} id=#{@tour_id}";
+          end
+
+          ######################################################
+          # implements Reusable
+          ######################################################
+
+          def reset()
+            @tour = nil
+            @tour_id = 0
+          end
+
+          ######################################################
+          # implements Yacht
+          ######################################################
+
+          def notify_read(buf, adr)
+
+            BayLog.debug("%s CGI StdErr %d bytesd", self, buf.length)
+            if(buf.length() > 0)
+              BayLog.error("CGI Stderr: %s", buf)
+            end
+
+            return NextSocketAction::CONTINUE;
+
+          end
+
+          def notify_eof()
+            BayLog.debug("%s CGI StdErr: EOF\\(^o^)/", self)
+            return NextSocketAction::CLOSE
+          end
+
+          def notify_close()
+            BayLog.debug("%s CGI StdErr: notifyClose", self)
+            @tour.req.content_handler.std_err_closed()
+          end
+
+          def check_timeout(duration)
+            BayLog.warn("%s invalid timeout check", self)
+            return false
+          end
+
+          ######################################################
+          # Custom methods
+          ######################################################
+
+          def init(tur)
+            init_yacht()
+            @tour = tur
+            @tour_id = tur.tour_id
+          end
+        end
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,158 @@
+require 'baykit/bayserver/agent/next_socket_action'
+require 'baykit/bayserver/watercraft/yacht'
+require 'baykit/bayserver/util/string_util'
+require 'baykit/bayserver/util/reusable'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Cgi
+        class CgiStdOutYacht < Baykit::BayServer::WaterCraft::Yacht
+
+          include Baykit::BayServer::Agent
+          include Baykit::BayServer::Util
+
+          attr :file_wrote_len
+
+          attr :tour
+          attr :tour_id
+
+          attr :remain
+          attr :header_reading
+
+          def initialize
+            super
+            reset()
+          end
+
+          def to_s()
+            return "CGIYat##{@yacht_id}/#{@object_id} tour=#{@tour} id=#{@tour_id}";
+          end
+
+          ######################################################
+          # implements Reusable
+          ######################################################
+
+          def reset()
+            @file_wrote_len = 0
+            @tour = nil
+            @tour_id = 0
+            @header_reading = true
+            @remain = ""
+          end
+
+          ######################################################
+          # implements Yacht
+          ######################################################
+
+          def notify_read(buf, adr)
+            @file_wrote_len += buf.length
+            BayLog.trace("%s read file %d bytes: total=%d", self, buf.length, @file_wrote_len)
+
+            pos = 0
+            if @header_reading
+
+              while true
+                p = buf.index("\n", pos)
+
+                #BayLog.debug("pos: %d", pos)
+
+                if p == nil
+                  break
+                end
+
+                line = buf[pos .. p]
+                pos = p + 1
+
+                if @remain.length > 0
+                  line = @remain + line
+                end
+                @remain = ""
+
+                line = line.strip()
+
+                #  if line is empty ("\r\n")
+                #  finish header reading.
+                if StringUtil.empty?(line)
+                  @header_reading = false
+                  @tour.res.send_headers(@tour_id)
+                  break
+                else
+                  if BayServer.harbor.trace_header()
+                    BayLog.info("%s CGI: res header line: %s", tour, line);
+                  end
+
+                  sep_pos = line.index(':')
+                  if sep_pos != nil
+                    key = line[0 .. sep_pos - 1].strip()
+                    val = line[sep_pos + 1 .. -1].strip()
+
+                    if key.downcase() == "status"
+                      begin
+                        val = val.split(" ")[0]
+                        @tour.res.headers.status = val.to_i()
+                      rescue => e
+                        BayLog.error_e(e)
+                      end
+                    else
+                      @tour.res.headers.add(key, val);
+                    end
+                  end
+                end
+              end
+            end
+
+            available = true
+
+            if @header_reading
+              @remain += buf[pos .. -1]
+            else
+              if buf.length - pos > 0
+                available = @tour.res.send_content(@tour_id, buf, pos, buf.length - pos);
+              end
+            end
+
+            if available
+              return NextSocketAction::CONTINUE;
+            else
+              return NextSocketAction::SUSPEND;
+            end
+
+          end
+
+          def notify_eof()
+            BayLog.debug("%s CGI StdOut: EOF(^o^)", self)
+            return NextSocketAction::CLOSE
+          end
+
+          def notify_close()
+            BayLog.debug("%s CGI StdOut: notifyClose", self)
+            @tour.req.content_handler.std_out_closed()
+          end
+
+          def check_timeout(duration)
+            BayLog.warn("%s invalid timeout check", self)
+            return false
+          end
+
+          ######################################################
+          # Custom methods
+          ######################################################
+
+          def init(tur, valve)
+            init_yacht()
+            @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
+  end
+end
+
+

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

@@ -0,0 +1,182 @@
+require 'baykit/bayserver/train/train'
+require 'baykit/bayserver/tours/req_content_handler'
+
+require 'baykit/bayserver/util/string_util'
+require 'baykit/bayserver/util/http_status'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Cgi
+        class CgiTrain < Baykit::BayServer::Train::Train
+          include Baykit::BayServer::Tours::ReqContentHandler   # implements
+
+          include Baykit::BayServer::Agent
+          include Baykit::BayServer::Train
+          include Baykit::BayServer::Tours
+          include Baykit::BayServer::Util
+
+          READ_CHUNK_SIZE = 8192
+
+          attr :cgi_docker
+          attr :env
+          attr :available
+          attr :lock
+          attr :pid
+          attr :std_in
+          attr :std_out
+          attr :std_err
+
+          def initialize(cgi_docker, tur)
+            super(tur)
+            @cgi_docker = cgi_docker
+          end
+
+          def start_tour(env)
+            @env = env
+            @available = false
+            @lock = Mutex.new()
+
+            @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)
+            BayLog.debug("%s Spawn: %s", @tour, command)
+            @pid = Process.spawn(@env, command, :in => @std_in[0], :out => @std_out[1], :err => @std_err[1])
+            @std_in[0].close()
+            @std_out[1].close()
+            @std_err[1].close()
+            BayLog.debug("#{@tour} PID: #{pid}")
+
+            @tour.req.set_content_handler(self)
+
+          end
+
+          def depart
+
+            begin
+
+              ###############
+              # Handle StdOut
+              HttpUtil.parse_message_headers(@std_out[0], @tour.res.headers)
+
+              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)
+                  end
+                end
+              end
+
+              status = @tour.res.headers.get("Status")
+              #BayLog.debug "Headers: #{@tours.res.headers.headers}"
+              #BayLog.debug "Status: #{status}"
+              if !StringUtil.empty?(status)
+                pos = status.index(" ")
+                if pos
+                  code = status[0, pos].to_i
+                else
+                  code = status.to_i
+                end
+                @tour.res.headers.status = code
+              end
+
+              @tour.res.set_consume_listener do |len, resume|
+                if resume
+                  @available = true
+                end
+              end
+
+              @tour.res.send_headers(@tour_id)
+
+              #BayLog.info("Reading STDOUT")
+              while true
+                buf = StringUtil.alloc(READ_CHUNK_SIZE)
+                c = std_out[0].read(READ_CHUNK_SIZE, buf)
+                if !c
+                  break
+                end
+
+                BayLog.trace("%s CGITrain: read stdout bytes: len=%d", @tour, buf.length)
+                @available = @tour.res.send_content(@tour_id, buf, 0, buf.length)
+                while !@available
+                  sleep(0.1)
+                end
+              end
+
+              #BayLog.info("Reading STDERR")
+              ###############
+              # Handle StdErr
+              ###############
+              while true
+                buf = StringUtil.alloc(READ_CHUNK_SIZE)
+                c = std_err[0].read(READ_CHUNK_SIZE, buf)
+                if !c
+                  break
+                end
+
+                BayLog.warn("%s CGITrain: read stderr bytes: %d", @tour, buf.length)
+                BayLog.warn(buf)
+              end
+
+              @tour.res.end_content @tour_id
+
+            rescue HttpException => e
+              raise e
+            rescue => e
+              BayLog.error("%s CGITrain: Catch error: %s", @tour, e)
+              BayLog.error_e(e)
+              raise HttpException.new(HttpStatus::INTERNAL_SERVER_ERROR, "CGI error")
+            ensure
+              begin
+                BayLog.debug("%s CGITrain: waiting process end", @tour)
+                Process.wait(@pid)
+                close_pipes()
+
+                BayLog.debug("%s CGITrain: process ended", @tour)
+              rescue => e
+                BayLog.error_e(e)
+              end
+            end
+          end
+
+          def on_read_content(tur, buf, start, len)
+            BayLog.info("%s CGITrain:onReadContent: len=%d", tur, len)
+
+            wrote_len = @std_in[1].write(buf[start, len])
+            BayLog.info("%s CGITrain:onReadContent: wrote=%d", tur, wrote_len)
+            tur.req.consumed(Tour::TOUR_ID_NOCHECK, len)
+          end
+
+          def on_end_content(tur)
+            BayLog.trace("%s CGITrain:endContent", tur)
+
+            if !TrainRunner.post(self)
+              raise HttpException.new(HttpStatus::SERVICE_UNAVAILABLE, "TrainRunner is busy")
+            end
+          end
+
+          def on_abort(tur)
+            BayLog.debug("%s CGITrain:abort", tur)
+            close_pipes()
+
+            BayLog.debug("%s KILL PROCESS!: %d", tur, @pid)
+            Process.kill('KILL', @pid)
+
+            return false  # not aborted immediately
+          end
+
+          def close_pipes()
+            @std_in[1].close()
+            @std_out[0].close()
+            @std_err[0].close()
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'baykit/bayserver/bcf/package'
+require 'baykit/bayserver/docker/cgi/cgi_docker'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Cgi
+        class PhpCgiDocker < Baykit::BayServer::Docker::Cgi::CgiDocker
+          include Baykit::BayServer::Util
+
+          ENV_PHP_SELF = "PHP_SELF"
+          ENV_REDIRECT_STATUS = "REDIRECT_STATUS"
+
+          ######################################################
+          # Implements Docker
+          ######################################################
+
+          def init(elm, parent)
+            super
+
+            if @interpreter == nil
+              @interpreter = "php-cgi";
+            end
+
+            BayLog.debug("PHP interpreter: " + interpreter)
+          end
+
+          ######################################################
+          # Override CgiDocker
+          ######################################################
+
+          def create_command(env)
+            env[ENV_PHP_SELF] = env[CgiUtil::SCRIPT_NAME]
+            env[ENV_REDIRECT_STATUS] = 200.to_s
+            super
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: bayserver-docker-cgi
+version: !ruby/object:Gem::Version
+  version: 2.2.0
+platform: ruby
+authors:
+- Michisuke-P
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-08-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bayserver-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+description: AJP docker of BayServer
+email: michisukep@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+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_train.rb
+- lib/baykit/bayserver/docker/cgi/php_cgi_docker.rb
+homepage: https://baykit.yokohama
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: AJP docker of BayServer
+test_files: []