bayserver-docker-terminal 2.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 33d1e39cac0afb5af49bc8cc177e7bb275a63965dc9cf17ac288e5284dacab67
+  data.tar.gz: f27f672fb7d691d506accfdc699e121990d0b1e67994039657a96d79cdd306cf
+SHA512:
+  metadata.gz: 2994251e531a31afd3d27f368bc321e8857d201d02834b438bcacaf5da0df72d40d5fd9d00b4817da71b865d37ed14d1dbdfdc38ae9806b635ce373d7cc38f19
+  data.tar.gz: be8c6e48f562cef7fd34f861a99fa582c2e84f468803bacc6ab49129aaf1856cfe8a77f6f1a469535e7f9289ccc7514e38753e99b4136e1db71699e8359514c8

data/lib/baykit/bayserver/docker/terminal/fully_hijackers_yacht.rb

@@ -0,0 +1,155 @@
+require 'baykit/bayserver/agent/next_socket_action'
+require 'baykit/bayserver/watercraft/yacht'
+require 'baykit/bayserver/util/string_util'
+require 'baykit/bayserver/util/reusable'
+
+require 'baykit/bayserver/docker/terminal/hijackers_yacht'
+
+require 'baykit/bayserver/docker/http/h1/h1_command_handler'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Terminal
+        class FullyHijackersYacht < HijackersYacht
+          include Baykit::BayServer::Docker::Http::H1::H1CommandHandler   # implements
+
+          include Baykit::BayServer::Util
+          include Baykit::BayServer::Protocol
+          include Baykit::BayServer::Docker::Http::H1
+
+          STATE_READ_HEADER = 1
+          STATE_READ_CONTENT = 2
+          STATE_FINISHED = 3
+
+          attr :state
+          attr :packet_store
+          attr :packet_unpacker
+          attr :command_unpacker
+
+          def initialize
+            super
+          end
+
+          ######################################################
+          # Init method
+          ######################################################
+          #
+          def init(tur, io, tp)
+            super
+            @packet_store = PacketStore.new(tur.ship, H1PacketFactory.new)
+            @command_unpacker = H1CommandUnPacker.new(self, false)
+            @packet_unpacker = H1PacketUnPacker.new(@command_unpacker, @packet_store)
+          end
+
+          ######################################################
+          # implements Reusable
+          ######################################################
+
+          def reset()
+            super
+            @state = STATE_FINISHED
+          end
+
+          ######################################################
+          # implements Yacht
+          ######################################################
+
+          # Override
+          def notify_read(buf, adr)
+            @file_wrote_len += buf.length
+
+            BayLog.debug "#{self} read hijack #{buf.length} bytes: total=#{@file_wrote_len}"
+
+            return @packet_unpacker.bytes_received(buf)
+
+          end
+
+
+          ######################################################
+          # Implements H1CommandHandler
+          ######################################################
+
+          def handle_header(cmd)
+            if @state == STATE_FINISHED
+              change_state(STATE_READ_HEADER)
+            end
+
+            if @state != STATE_READ_HEADER
+              raise ProtocolException("Header command not expected: state=%d", @state)
+            end
+
+            if BayServer.harbor.trace_header?
+              BayLog.info("%s hijack: resStatus: %d", self, cmd.status)
+            end
+
+            cmd.headers.each do |nv|
+              @tour.res.headers.add(nv[0], nv[1])
+              if BayServer.harbor.trace_header?
+                BayLog.info("%s hijack: resHeader: %s=%s", self, nv[0], nv[1]);
+              end
+            end
+
+            @tour.res.headers.status = cmd.status != nil ? cmd.status : HttpStatus::OK
+            @tour.res.send_headers(@tour_id)
+
+            res_cont_len = @tour.res.headers.content_length
+            BayLog.debug("%s contLen in header: %d", self, res_cont_len)
+
+            if res_cont_len == 0 || cmd.status == HttpStatus::NOT_MODIFIED
+              end_res_content(@tour)
+            else
+              change_state(STATE_READ_CONTENT)
+              sid = @tour.ship.id()
+              @tour.res.set_consume_listener do |len, resume|
+                if resume
+                  @tour.ship.resume(sid)
+                end
+              end
+            end
+            return NextSocketAction::CONTINUE
+          end
+
+          def handle_content(cmd)
+
+            if @state != STATE_READ_CONTENT
+              raise ProtocolException.new("Content command not expected")
+            end
+
+            available = @tour.res.send_content(@tour_id, cmd.buf, cmd.start, cmd.len)
+            if @tour.res.bytes_posted == @tour.res.bytes_limit
+              end_res_content(@tour)
+              return NextSocketAction::CONTINUE
+            elsif !available
+              return NextSocketAction::SUSPEND
+            else
+              NextSocketAction::CONTINUE
+            end
+          end
+
+          def handle_end_content(cmd)
+            # never called
+            raise Sink.new()
+          end
+
+          def finished()
+            return @state == STATE_FINISHED
+          end
+
+
+          private
+
+          def end_res_content(tur)
+            tur.res.end_content(Tour::TOUR_ID_NOCHECK)
+            reset()
+          end
+
+          def change_state(new_state)
+            @state = new_state
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/baykit/bayserver/docker/terminal/hijacked_data_sender.rb

@@ -0,0 +1,170 @@
+require 'baykit/bayserver/agent/next_socket_action'
+require 'baykit/bayserver/protocol/packet_store'
+require 'baykit/bayserver/docker/http/h1/h1_packet_unpacker'
+require 'baykit/bayserver/docker/http/h1/h1_command_unpacker'
+require 'baykit/bayserver/util/string_util'
+require 'baykit/bayserver/util/http_status'
+
+
+module Baykit
+  module BayServer
+    module Docker
+      module Terminal
+        #
+        # Send data of hijacked response
+        #
+        class HijackedDataSender
+          include Baykit::BayServer::Agent::NonBlockingHandler::ChannelListener  # implements
+          include Baykit::BayServer::Util
+          include Baykit::BayServer::Agent
+          include Baykit::BayServer::Protocol
+          include Baykit::BayServer::Docker::Http::H1
+
+          attr :tour
+          attr :tour_id
+          attr :fully
+
+          attr :file_wrote_len
+          attr :file_buf_list
+          attr :cur_file_idx
+          attr :read_buf_size
+          attr :cur_file_idx
+          attr :pipe_io
+
+          attr :packet_store
+          attr :packet_unpacker
+          attr :command_unpacker
+
+          DEFAULT_FREAD_BUF_SIZE = 8192
+
+          def initialize(tur, fully)
+            @tour = tur
+            @tour_id = @tour.tour_id
+            @fully = fully
+            @file_buf_list = []
+            @read_buf_size = tour.ship.protocol_handler.max_res_packet_data_size
+
+            if @fully
+              @packet_store = PacketStore.new(tur.ship, H1PacketFactory.new)
+              @command_unpacker = H1CommandUnPacker.new(self, false)
+              @packet_unpacker = H1PacketUnPacker.new(@command_unpacker, @packet_store)
+            end
+            reset
+          end
+
+          def reset
+            @file_wrote_len = 0
+            @cur_file_idx = -1
+          end
+
+          def ship
+            @tour.ship
+          end
+
+          def on_readable(chk_fd)
+            BayLog.debug "#{self} Hijack Readable"
+            check_socket(chk_fd)
+
+            buf = new_file_buffer
+            begin
+              @pipe_io.read_nonblock(@read_buf_size, buf)
+            rescue EOFError => e
+              BayLog.debug "#{self} Hijack EOF"
+              @tour.res.end_content(@tour_id)
+              return NextSocketAction::CLOSE
+            end
+
+            @file_wrote_len += buf.length
+
+            BayLog.debug "#{self} read hijack #{buf.length} bytes: total=#{@file_wrote_len}"
+
+            if @fully
+              return @packet_unpacker.bytes_received(buf)
+            else
+              available = @tour.res.send_content(@tour_id, buf, 0, buf.length)
+              if !available
+                NextSocketAction::SUSPEND
+              else
+                NextSocketAction::CONTINUE
+              end
+            end
+
+          end
+
+          def check_timeout(chk_fd, duration)
+            BayLog.debug "#{self} Hijack timeout(Ignore)"
+          end
+
+          def on_error(chk_fd, e)
+            BayLog.debug "#{self} Hijack Error"
+            check_socket(chk_fd)
+
+            BayLog.error_e e
+          end
+
+          def on_closed(chk_fd)
+            BayLog.debug "#{self} Hijack Closed(Ignore)"
+            check_socket(chk_fd)
+          end
+
+
+          def send_pipe_data(io)
+            BayLog.debug("#{self} Send hijacked data #{io.inspect}")
+            @pipe_io = io
+            @file_wrote_len = 0
+            @tour.ship.agent.non_blocking_handler.ask_to_read(@pipe_io)
+          end
+
+          # Implements H1CommandHandler
+          # Fully hijacked mode
+          def handle_header(cmd)
+            cmd.headers.each do |nv|
+              @tour.res.headers.add(nv[0], nv[1])
+            end
+
+            @tour.res.headers.status = cmd.status != nil ? cmd.status : HttpStatus::OK
+            @tour.send_headers(@tour_id)
+
+            return NextSocketAction::CONTINUE
+          end
+
+          # Implements H1CommandHandler
+          # Fully hijacked mode
+          def handle_content(cmd)
+            available = @tour.res.send_content(@tour_id, cmd.buf, cmd.start, cmd.len)
+            if !available
+              NextSocketAction::SUSPEND
+            else
+              NextSocketAction::CONTINUE
+            end
+          end
+
+          def resume
+            BayLog.debug("#{self} resume")
+            @tour.ship.agent.non_blocking_handler.ask_to_read(@pipe_io)
+          end
+
+          def to_s
+            "hijack[#{@pipe_io.inspect}]"
+          end
+
+          private
+          def check_socket(chk_fd)
+            if chk_fd != @pipe_io
+              raise RuntimeError.new("BUG: Invalid hijacked data sender instance (file was returned?): #{chk_fd}")
+            end
+          end
+
+          def new_file_buffer
+            @cur_file_idx += 1
+            if @file_buf_list.length == @cur_file_idx
+              @file_buf_list << StringUtil.alloc(@read_buf_size)
+            end
+            @file_buf_list[@cur_file_idx]
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/baykit/bayserver/docker/terminal/hijackers_yacht.rb

@@ -0,0 +1,106 @@
+require 'baykit/bayserver/agent/next_socket_action'
+require 'baykit/bayserver/watercraft/yacht'
+require 'baykit/bayserver/util/string_util'
+require 'baykit/bayserver/util/reusable'
+
+require 'baykit/bayserver/docker/http/h1/h1_command_handler'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Terminal
+        class HijackersYacht < Baykit::BayServer::WaterCraft::Yacht
+          include Baykit::BayServer::Docker::Http::H1::H1CommandHandler   # implements
+
+          include Baykit::BayServer::Util
+          include Baykit::BayServer::Agent
+          include Baykit::BayServer::Protocol
+          include Baykit::BayServer::Docker::Http::H1
+
+          attr :tour
+          attr :tour_id
+
+          attr :file_wrote_len
+          attr :pipe_io
+
+          attr :packet_store
+          attr :packet_unpacker
+          attr :command_unpacker
+
+          def initialize
+            super
+            reset()
+          end
+
+          def to_s()
+            return "hijack##{@yacht_id}/#{@object_id} tour=#{@tour} id=#{@tour_id}";
+          end
+
+          ######################################################
+          # Init method
+          ######################################################
+
+          def init(tur, io, tp)
+            init_yacht()
+            @tour = tur
+            @tour_id = @tour.tour_id
+
+            tur.res.set_consume_listener do |len, resume|
+              if resume
+                tp.open_valve();
+              end
+            end
+            @pipe_io = io
+            @file_wrote_len = 0
+            @tour.ship.agent.non_blocking_handler.ask_to_read(@pipe_io)
+          end
+
+
+          ######################################################
+          # implements Reusable
+          ######################################################
+
+          def reset()
+            @file_wrote_len = 0
+            @file_len = 0
+            @tour = nil
+            @tour_id = 0
+          end
+
+          ######################################################
+          # implements Yacht
+          ######################################################
+
+          def notify_read(buf, adr)
+            @file_wrote_len += buf.length
+
+            BayLog.debug "#{self} read hijack #{buf.length} bytes: total=#{@file_wrote_len}"
+
+            available = @tour.res.send_content(@tour_id, buf, 0, buf.length)
+            if !available
+              return NextSocketAction::SUSPEND
+            else
+              return NextSocketAction::CONTINUE
+            end
+          end
+
+          def notify_eof()
+            BayLog.debug "#{self} Hijack EOF"
+            @tour.res.end_content(@tour_id)
+            return NextSocketAction::CLOSE
+          end
+
+          def notify_close()
+            BayLog.debug("%s Hijack Closed(Ignore)", self)
+          end
+
+          def check_timeout(duration)
+            BayLog.debug("%s Hijack timeout(Ignore)", self)
+          end
+
+        end
+      end
+    end
+  end
+end
+

data/lib/baykit/bayserver/docker/terminal/terminal_docker.rb

@@ -0,0 +1,204 @@
+require 'baykit/bayserver/agent/transporter/plain_transporter'
+require 'baykit/bayserver/docker/base/port_base'
+require 'baykit/bayserver/tours/content_consume_listener'
+
+require 'baykit/bayserver/docker/terminal/fully_hijackers_yacht'
+require 'baykit/bayserver/docker/terminal/terminal_train'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Terminal
+        class TerminalDocker < Baykit::BayServer::Docker::Base::ClubBase
+          include Baykit::BayServer::Bcf
+          include Baykit::BayServer::Util
+          include Baykit::BayServer::Agent::Transporter
+          include Baykit::BayServer::Tours
+
+          RACK_TERMINAL_PIPE = "rack.terminal.pipe"
+          DEFAULT_POST_CACHE_THRESHOLD = 1024 * 128   # 128 KB
+          RACK_ERR = "Cannot find rack package. If you want to use terminal docker, please install rack package like 'gem install rack'."
+
+          RACK_MULTITHREAD     = 'rack.multithread'
+          RACK_MULTIPROCESS    = 'rack.multiprocess'
+          RACK_RUNONCE         = 'rack.run_once'
+          RACK_HIJACK_IO       = 'rack.hijack_io'
+          HTTP_VERSION         = 'HTTP_VERSION'
+
+          attr_accessor :app
+          attr :config
+          attr :environment
+          attr :post_cache_threshold
+          attr :available
+
+          def initialize
+            @post_cache_threshold = DEFAULT_POST_CACHE_THRESHOLD
+            @available = false
+          end
+
+          ######################################################
+          # Implements Docker
+          ######################################################
+
+          def init(elm, parent)
+            super
+
+            begin
+              require 'rack'
+            rescue LoadError => e
+              BayLog.error(RACK_ERR)
+              return
+            end
+
+            require 'rack/handler/bayserver'
+
+            if Rack::Handler::BayServer.app != nil
+              # rackup mode
+              @app = Rack::Handler::BayServer.app
+            else
+              if !StringUtil.set?(@config)
+                raise ConfigException.new(elm.file_name, elm.line_no, "Config not specified")
+              elsif not ::File.exist?(@config)
+                raise ConfigException.new(elm.file_name, elm.line_no, "Config not found: %s", @config)
+              end
+              if @environment == nil
+                @environment = "deployment"
+              end
+              options = {
+                :server => "terminal",
+                :config => @config,
+                :environment => @environment,
+                :docker => self,
+              }
+              Rack::Server.start options
+            end
+
+            @available = true
+          end
+
+          ######################################################
+          # Implements DockerBase
+          ######################################################
+
+          def init_key_val(kv)
+            case kv.key.downcase
+            when "config"
+              @config = Baykit::BayServer::BayServer.parse_path(kv.value)
+            when "environment"
+              @environment = kv.value
+            when "postcachethreshold"
+              @post_cache_threshold = kv.value.to_i
+            else
+              return super
+            end
+            return true
+          end
+
+          ######################################################
+          # Implements Club
+          ######################################################
+
+          def arrive(tur)
+
+            if not @available
+              tur.res.headers.set_content_type("text/plain")
+              tur.res.set_consume_listener(&ContentConsumeListener::DEV_NULL)
+              tur.res.send_headers(tur.id)
+              tur.res.send_content(tur.id, RACK_ERR, 0, RACK_ERR.length)
+              tur.res.end_content(tur.id)
+              return
+            end
+
+            if tur.req.uri.include? ".."
+              raise HttpException.new HttpStatus::FORBIDDEN, tur.req.uri
+            end
+
+            env = create_env tur
+            train = TerminalTrain.new(self, tur, @app, env)
+            train.start_tour()
+          end
+
+          def create_env(tur)
+            env = {}
+
+            cont_len = tur.req.headers.content_length()
+            if cont_len > 0
+              env["CONTENT_LENGTH"] = cont_len.to_s
+            end
+            cont_type = tur.req.headers.content_type()
+            if StringUtil.set? cont_type
+              env["CONTENT_TYPE"]      = cont_type
+            end
+
+
+            env["GATEWAY_INTERFACE"] = "CGI/1.1"
+            #env[Rack::PATH_INFO] = tur.req.path_info == nil ? "" : tur.req.path_info
+            pos = tur.req.uri.index('?')
+            if pos and pos > 0
+              env[Rack::PATH_INFO] = tur.req.uri[0 .. pos-1]
+            else
+              env[Rack::PATH_INFO] = tur.req.uri
+            end
+            env[Rack::QUERY_STRING] = tur.req.query_string == nil ? "" : tur.req.query_string
+            env["REMOTE_ADDR"] = tur.req.remote_address
+            env["REMOTE_HOST"] = tur.req.remote_address  # for performance reason
+            env["REMOTE_USER"] = tur.req.remote_user == nil ? "" : tur.req.remote_user
+            env[Rack::REQUEST_METHOD] = tur.req.method
+            env["REQUEST_URI"]  = tur.req.uri
+            #env[Rack::SCRIPT_NAME] = tur.req.script_name == nil ? "" : tur.req.script_name
+            env[Rack::SCRIPT_NAME] = ""
+            env[Rack::SERVER_NAME] = tur.req.server_name
+            env[Rack::SERVER_PORT]  = tur.req.server_port.to_s
+            env[Rack::SERVER_PROTOCOL] = tur.req.protocol
+            env["SERVER_SOFTWARE"] = Baykit::BayServer::BayServer.get_software_name
+
+            tur.req.headers.names.each do |name|
+              tur.req.headers.values(name).each do |val|
+                if /^content-type$/i =~ name || /^content-length$/i =~ name
+                  next
+                end
+                name = "HTTP_" + name
+                name.gsub!(/-/o, "_")
+                name.upcase!
+                env[name] = val
+              end
+            end
+
+            env[Rack::RACK_VERSION] = Rack::VERSION
+            env[Rack::RACK_ERRORS] = STDERR
+            env[Rack::RACK_INPUT] = nil
+            env[RACK_MULTITHREAD] = true
+            env[RACK_MULTIPROCESS] = BayServer.harbor.multi_core?
+            env[RACK_RUNONCE] = false
+            env[Rack::RACK_URL_SCHEME] = tur.is_secure ? "https" : "http"
+            env[Rack::RACK_IS_HIJACK] = true
+
+            env[Rack::RACK_HIJACK] = lambda do
+              pip = IO.pipe
+              env[RACK_TERMINAL_PIPE] = pip
+
+              w_pipe = pip[1]
+
+              env[RACK_HIJACK_IO] = w_pipe
+
+              yat = FullyHijackersYacht.new()
+              bufsize = tur.ship.protocol_handler.max_res_packet_data_size()
+              tp = PlainTransporter.new(false, bufsize)
+
+              yat.init(tur, pip[0], tp)
+              tp.init(tur.ship.agent.non_blocking_handler, pip[0], yat)
+              tur.ship.resume(tur.ship_id)
+
+              w_pipe
+            end
+
+            env[RACK_HIJACK_IO] = nil
+
+            env[HTTP_VERSION] = tur.req.protocol
+            env
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/docker/terminal/terminal_train.rb

@@ -0,0 +1,209 @@
+require 'baykit/bayserver/agent/transporter/plain_transporter'
+require 'baykit/bayserver/train/train'
+require 'baykit/bayserver/train/train_runner'
+require 'baykit/bayserver/tours/tour'
+require 'baykit/bayserver/tours/req_content_handler'
+
+require 'baykit/bayserver/util/string_util'
+require 'baykit/bayserver/util/http_status'
+
+require 'baykit/bayserver/docker/terminal/hijackers_yacht'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Terminal
+        class TerminalTrain < Baykit::BayServer::Train::Train
+          include Baykit::BayServer::Tours::ReqContentHandler   # implements
+
+          include Baykit::BayServer::Agent::Transporter
+          include Baykit::BayServer::Util
+          include Baykit::BayServer::Train
+          include Baykit::BayServer::Tours
+
+          attr :terminal_docker
+          attr :tour
+          attr :tour_id
+          attr :app
+          attr :env
+
+          attr :req_available
+          attr :lock
+          attr :tmpfile
+          attr :req_cont
+
+          def initialize(terminal_docker, tur, app, env)
+            BayLog.debug "%s New Rack Train", tur
+            @terminal_docker = terminal_docker
+            @tour = tur
+            @tour_id = tur.tour_id
+            @app = app
+            @env = env
+            @available = false
+            @tmpfile = nil
+            @req_cont = nil
+
+            @lock = Mutex.new
+          end
+
+          def start_tour()
+            @tour.req.set_content_handler(self)
+            @tmpfile = nil
+
+            if @env["CONTENT_LENGTH"]
+              req_cont_len = @env["CONTENT_LENGTH"].to_i
+            else
+              req_cont_len = 0
+            end
+
+            if req_cont_len <= @terminal_docker.post_cache_threshold
+              # Cache content in memory
+              @req_cont = StringUtil.alloc(0)
+            else
+              # Content save on disk
+              @tmpfile = Tempfile.new("terminal_upload")
+              @tmpfile.binmode
+            end
+
+          end
+
+          def depart
+
+            begin
+              if @tour.req.method.casecmp?("post")
+                BayLog.debug("%s Terminal: posted: content-length: %s", @tour, @env["CONTENT_LENGTH"])
+              end
+
+
+              if BayServer.harbor.trace_header?
+                @env.keys.each do |key|
+                  value = @env[key]
+                  BayLog.info("%s Terminal: env:%s=%s", @tour, key, value)
+                end
+              end
+
+              status, headers, body = @app.call(@env)
+
+              # Hijack check
+              pip = @env[TerminalDocker::RACK_TERMINAL_PIPE]
+
+              if pip != nil
+                # Fully hijacked (Do nothing)
+                BayLog.debug("%s Tour is fully hijacked", @tour)
+
+              else
+                @tour.res.headers.status = status
+
+                hijack = nil
+                headers.each do | key, value |
+                  if key == Rack::RACK_HIJACK
+                    hijack = value
+                  else
+                    @tour.res.headers.add key, value
+                  end
+                end
+
+                # Send headers
+                @tour.res.send_headers @tour_id
+
+                if hijack != nil
+                  # Partially hijacked
+                  BayLog.debug("%s Tour is partially hijacked", @tour)
+
+                  pip = IO.pipe
+                  yat = HijackersYacht.new()
+                  bufsize = @tour.ship.protocol_handler.max_res_packet_data_size()
+                  tp = PlainTransporter.new(false, bufsize)
+
+                  yat.init(@tour, pip[0], tp)
+                  tp.init(@tour.ship.agent.non_blocking_handler, pip[0], yat)
+                  @tour.ship.resume(@tour.ship_id)
+
+                  hijack.call pip[1]
+
+                else
+                  # Not hijacked
+
+                  # Setup consume listener
+                  @tour.res.set_consume_listener() do |len, resume|
+                    if(resume)
+                      @available = true
+                    end
+                  end
+
+                  # Send contents
+                  body.each do | str |
+                    bstr = StringUtil.to_bytes(str)
+                    BayLog.trace("%s TerminalTask: read body: len=%d", @tour, bstr.length)
+                    @available = @tour.res.send_content(@tour_id, bstr, 0, bstr.length)
+                    while !@available
+                      sleep 0.1
+                    end
+                  end
+
+                  @tour.res.end_content(@tour_id)
+
+                end
+              end
+            rescue HttpException => e
+              raise e
+            rescue => e
+              BayLog.error_e e
+              raise HttpException.new HttpStatus::INTERNAL_SERVER_ERROR, "Terminal error"
+            ensure
+              if @tmpfile
+                @tmpfile.close()
+              end
+            end
+          end
+
+          def on_read_content(tur, buf, start, len)
+            BayLog.trace("%s TerminalTask:onReadContent: len=%d", @tour, len)
+
+            if @req_cont != nil
+              # Cache content in memory
+              @req_cont << buf[start, len]
+            else
+              # Content save on disk
+              @tmpfile.write(buf[start, len])
+            end
+
+            tur.req.consumed(Tour::TOUR_ID_NOCHECK, len)
+            true
+          end
+
+          def on_end_content(tur)
+            BayLog.trace("%s TerminalTask:endContent", @tour)
+
+            if @req_cont != nil
+              # Cache content in memory
+              rack_input = StringIO.new(@req_cont)
+            else
+              # Content save on disk
+              @tmpfile.rewind()
+              rack_input = @tmpfile
+            end
+            env[Rack::RACK_INPUT] = rack_input
+
+            if !TrainRunner.post(self)
+              raise HttpException.new(HttpStatus::SERVICE_UNAVAILABLE, "TrainRunner is busy")
+            end
+          end
+
+          def on_abort(tur)
+            BayLog.trace("%s TerminalTask:abort", @tour)
+            if @tmpfile
+              @tmpfile.close()
+              @tmpfile = nil
+            end
+            return false
+          end
+
+          def inspect
+            "TerminalTask #{@tour}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/handler/bayserver.rb

@@ -0,0 +1,66 @@
+require 'rack/handler'
+require 'baykit/bayserver/bayserver'
+require 'baykit/bayserver/util/string_util'
+
+module Rack
+  module Handler
+    module BayServer
+      include Baykit::BayServer::Util
+
+      class << self
+        attr :app
+      end
+      @app = nil
+
+      ENV_BSERV_HOME = Baykit::BayServer::BayServer::ENV_BSERV_HOME
+      ENV_BSERV_PLAN = Baykit::BayServer::BayServer::ENV_BSERV_PLAN
+
+      def self.run(app, **options)
+
+        @app = app
+
+        port = options[:Port]
+        host = options[:Host]
+        config = options[:config]
+        environment = options[:environment]
+        access_log = options[:AccessLog]
+
+        # Get bayserver home from environment
+        if StringUtil.set? ENV[ENV_BSERV_HOME]
+          bserv_home = ENV[ENV_BSERV_HOME]
+        else
+          raise "Set #{ENV_BSERV_HOME} environment variable"
+        end
+
+        # Get bayserver plan from evironment
+        if StringUtil.set? ENV[ENV_BSERV_PLAN]
+          bserv_plan = ENV[ENV_BSERV_PLAN]
+        else
+          bserv_plan = "/tmp/rack.plan"
+          plan_str = <<EOF
+[harbor]
+ grandAgents 4
+
+[port #{port}]
+ docker http
+
+[city *]
+ [town /]
+  [club *]
+   docker terminal
+EOF
+          ::File.write(bserv_plan, plan_str)
+        end
+
+        Baykit::BayServer::BayServer.init bserv_home, bserv_plan
+        Baykit::BayServer::BayServer.start
+      end
+
+    end
+
+
+
+
+    register :bayserver, BayServer
+  end
+end

data/lib/rack/handler/terminal.rb

@@ -0,0 +1,17 @@
+require 'rack/handler'
+
+
+module Rack
+  module Handler
+    module Terminal
+
+      def self.run(app, **options)
+        dkr = options[:docker]
+        dkr.app = app
+      end
+    end
+
+    register :terminal, Terminal
+  end
+end
+

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: bayserver-docker-terminal
+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/terminal/fully_hijackers_yacht.rb
+- lib/baykit/bayserver/docker/terminal/hijacked_data_sender.rb
+- lib/baykit/bayserver/docker/terminal/hijackers_yacht.rb
+- lib/baykit/bayserver/docker/terminal/terminal_docker.rb
+- lib/baykit/bayserver/docker/terminal/terminal_train.rb
+- lib/rack/handler/bayserver.rb
+- lib/rack/handler/terminal.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: []