bayserver-docker-ajp 2.2.0

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

@@ -0,0 +1,150 @@
+require 'baykit/bayserver/util/simple_buffer'
+require 'baykit/bayserver/agent/next_socket_action'
+require 'baykit/bayserver/protocol/packet_unpacker'
+
+#
+#  AJP Protocol
+#  https://tomcat.apache.org/connectors-doc/ajp/ajpv13a.html
+#
+module Baykit
+  module BayServer
+    module Docker
+      module Ajp
+        class AjpPacketUnPacker < Baykit::BayServer::Protocol::PacketUnPacker
+
+          include Baykit::BayServer::Util
+          include Baykit::BayServer::Agent
+
+          attr :preamble_buf
+          attr :body_buf
+
+          STATE_READ_PREAMBLE = 1
+          STATE_READ_BODY = 2
+          STATE_END = 3
+
+          attr :state
+
+          attr :pkt_store
+          attr :cmd_unpacker
+          attr :body_len
+          attr :read_bytes
+          attr :type
+          attr :to_server
+          attr :need_data
+
+          def initialize(pkt_store, cmd_unpacker)
+            @pkt_store = pkt_store
+            @cmd_unpacker = cmd_unpacker
+            @preamble_buf = SimpleBuffer.new
+            @body_buf = SimpleBuffer.new
+            reset
+          end
+
+          def reset
+            @state = STATE_READ_PREAMBLE
+            @body_len = 0
+            @read_bytes = 0
+            @need_data = false
+            @preamble_buf.reset
+            @body_buf.reset
+          end
+
+          def bytes_received(buf)
+            suspend = false
+            pos = 0
+
+            while pos < buf.length
+              if @state == STATE_READ_PREAMBLE
+                len = AjpPacket::PREAMBLE_SIZE - @preamble_buf.length
+                if buf.length - pos < len
+                  len = buf.length - pos
+                end
+                @preamble_buf.put(buf, pos, len)
+                pos += len
+
+                if @preamble_buf.length == AjpPacket::PREAMBLE_SIZE
+                  preamble_read()
+                  change_state(STATE_READ_BODY)
+                end
+              end
+
+              if @state == STATE_READ_BODY
+                len = @body_len - @body_buf.length
+                if len > buf.length - pos
+                  len = buf.length - pos
+                end
+
+                @body_buf.put(buf, pos, len)
+                pos += len
+
+                if @body_buf.length == @body_len
+                  body_read()
+                  change_state(STATE_END)
+                end
+              end
+
+              if @state == STATE_END
+                #BayLog.debug "AJP PacketUnpacker parse end: preamblelen=#{@preamble_buf.length} bodyLen=#{@body_buf.length}"
+
+                pkt = @pkt_store.rent(@type)
+                pkt.to_server = @to_server
+                pkt.new_ajp_header_accessor.put_bytes(@preamble_buf.buf, 0, @preamble_buf.length)
+                pkt.new_ajp_data_accessor.put_bytes(@body_buf.buf, 0, @body_buf.length)
+
+                begin
+                  next_action = @cmd_unpacker.packet_received(pkt)
+                ensure
+                  @pkt_store.Return(pkt)
+                end
+                reset
+                @need_data = @cmd_unpacker.need_data
+
+                if next_action == NextSocketAction::SUSPEND
+                  suspend = true
+                elsif next_action != NextSocketAction::CONTINUE
+                  return next_action
+                end
+              end
+            end
+
+            #BayLog.debug("ajp: next action=read")
+            if suspend
+              return NextSocketAction::SUSPEND
+            else
+              return NextSocketAction::CONTINUE
+            end
+          end
+
+          def change_state(new_state)
+            @state = new_state
+          end
+
+          def preamble_read
+            data = @preamble_buf.buf
+
+            if data[0].codepoints[0] == 0x12 && data[1].codepoints[0] == 0x34
+              @to_server = true
+            elsif data[0] == 'A' && data[1] == 'B'
+              @to_server = false
+            else
+              raise RuntimeError.new("Must be start with 0x1234 or 'AB'")
+            end
+
+            @body_len =  ((data[2].codepoints[0] << 8) | (data[3].codepoints[0] & 0xff)) & 0xffff
+            BayLog.trace("ajp: read packet preamble: bodyLen=%d", @body_len)
+          end
+
+          def body_read()
+            if @need_data
+               @type = AjpType::DATA
+            else
+               @type =@body_buf.buf[0].codepoints[0] & 0xff
+            end
+          end
+
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,52 @@
+require 'baykit/bayserver/protocol/packet_store'
+require 'baykit/bayserver/docker/base/port_base'
+require 'baykit/bayserver/docker/ajp/package'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Ajp
+        class AjpPortDocker < Baykit::BayServer::Docker::Base::PortBase
+          include Baykit::BayServer::Docker::Ajp::AjpDocker  # implements
+
+          include Baykit::BayServer::Protocol
+          include Baykit::BayServer::WaterCraft
+          include Baykit::BayServer::Docker::Base
+
+          ######################################################
+          # Implements Port
+          ######################################################
+          def protocol()
+            return PROTO_NAME
+          end
+
+          ######################################################
+          # Implements PortBase
+          ######################################################
+          def support_anchored()
+            return true
+          end
+
+          def support_unanchored()
+            return false
+          end
+
+          ######################################################
+          # Class initializer
+          ######################################################
+          begin
+            PacketStore.register_protocol(
+              PROTO_NAME,
+              AjpPacketFactory.new()
+            )
+            ProtocolHandlerStore.register_protocol(
+              PROTO_NAME,
+              true,
+              AjpInboundHandler::InboundProtocolHandlerFactory.new())
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,55 @@
+require 'baykit/bayserver/protocol/protocol_handler'
+require 'baykit/bayserver/protocol/packet_store'
+require 'baykit/bayserver/util/http_status'
+require 'baykit/bayserver/tours/package'
+require 'baykit/bayserver/docker/ajp/package'
+require 'baykit/bayserver/docker/ajp/command/package'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Ajp
+        class AjpProtocolHandler < Baykit::BayServer::Protocol::ProtocolHandler
+          include Baykit::BayServer::Docker::Ajp::AjpCommandHandler # implements
+
+          include Baykit::BayServer::Protocol
+          include Baykit::BayServer::Agent
+          include Baykit::BayServer::Util
+          include Baykit::BayServer::Docker::Ajp::Command
+
+
+          def initialize(pkt_store, svr_mode)
+            @command_unpacker = AjpCommandUnPacker.new(self)
+            @packet_unpacker = AjpPacketUnPacker.new(pkt_store, @command_unpacker)
+            @packet_packer = PacketPacker.new()
+            @command_packer = CommandPacker.new(@packet_packer, pkt_store)
+            @server_mode = svr_mode
+          end
+
+          def to_s
+            "pch[#{@ship}]"
+          end
+
+          ######################################################
+          # Implements ProtocolHandler
+          ######################################################
+
+          def protocol()
+            return AjpDocker::PROTO_NAME
+          end
+
+          def max_req_packet_data_size()
+            return CmdData::MAX_DATA_LEN
+          end
+
+          def max_res_packet_data_size()
+            return CmdSendBodyChunk::MAX_CHUNKLEN
+          end
+
+
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,22 @@
+#
+# Ajp packet type
+#
+module Baykit
+  module BayServer
+    module Docker
+      module Ajp
+        class AjpType
+          DATA = 0
+          FORWARD_REQUEST = 2
+          SEND_BODY_CHUNK = 3
+          SEND_HEADERS = 4
+          END_RESPONSE = 5
+          GET_BODY_CHUNK = 6
+          SHUTDOWN = 7
+          PING = 8
+          CPING = 10
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'baykit/bayserver/docker/warp/warp_docker'
+require 'baykit/bayserver/docker/ajp/package'
+require 'baykit/bayserver/agent/transporter/plain_transporter'
+require 'baykit/bayserver/protocol/packet_store'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Ajp
+        class AjpWarpDocker < Baykit::BayServer::Docker::Warp::WarpDocker
+          include Baykit::BayServer::Docker::Ajp::AjpDocker  # implements
+
+          include Baykit::BayServer::Agent
+          include Baykit::BayServer::Protocol
+          include Baykit::BayServer::Agent::Transporter
+
+          ######################################################
+          # Implements WarpDocker
+          ######################################################
+          def secure()
+            return false
+          end
+
+          ######################################################
+          # Implements WarpDockerBase
+          ######################################################
+          private
+          def protocol()
+            return PROTO_NAME
+          end
+
+          def new_transporter(agt, skt)
+            PlainTransporter.new(false, IOUtil.get_sock_recv_buf_size(skt))
+          end
+
+          ######################################################
+          # Class initializer
+          ######################################################
+          begin
+            PacketStore.register_protocol(
+              PROTO_NAME,
+              AjpPacketFactory.new()
+            )
+            ProtocolHandlerStore.register_protocol(
+              PROTO_NAME,
+              false,
+              AjpWarpHandler::WarpProtocolHandlerFactory.new())
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,258 @@
+require 'baykit/bayserver/agent/next_socket_action'
+require 'baykit/bayserver/protocol/protocol_exception'
+require 'baykit/bayserver/docker/ajp/command/package'
+require 'baykit/bayserver/util/string_util'
+
+require 'baykit/bayserver/docker/ajp/ajp_protocol_handler'
+
+
+module Baykit
+  module BayServer
+    module Docker
+      module Ajp
+        class AjpWarpHandler < Baykit::BayServer::Docker::Ajp::AjpProtocolHandler
+          include Baykit::BayServer::Docker::Warp::WarpHandler # implements
+
+          class WarpProtocolHandlerFactory
+            include Baykit::BayServer::Protocol::ProtocolHandlerFactory  # implements
+
+            def create_protocol_handler(pkt_store)
+              return AjpWarpHandler.new(pkt_store)
+            end
+          end
+
+
+          include Baykit::BayServer::Agent
+          include Baykit::BayServer::Protocol
+          include Baykit::BayServer::Tours
+          include Baykit::BayServer::Docker::Warp
+          include Baykit::BayServer::Docker::Ajp::Command
+          include Baykit::BayServer::Util
+
+          FIXED_WARP_ID = 1
+
+          STATE_READ_HEADER = 1
+          STATE_READ_CONTENT = 2
+
+          attr :state
+
+          attr :cont_read_len
+
+          def initialize(pkt_store)
+            super(pkt_store, false)
+            reset()
+          end
+
+          def reset()
+            super
+            reset_state()
+            @cont_read_len = 0
+          end
+
+          def to_s()
+            return ship().to_s()
+          end
+
+          ######################################################
+          # Implements WarpHandler
+          ######################################################
+          def next_warp_id()
+            return 1
+          end
+
+          def new_warp_data(warp_id)
+            return WarpData.new(ship, warp_id)
+          end
+
+          def post_warp_headers(tur)
+            send_forward_request(tur)
+          end
+
+          def post_warp_contents(tur, buf, start, len, &callback)
+            send_data(tur, buf, start, len, &callback)
+          end
+
+          def post_warp_end(tur)
+          end
+
+          def verify_protocol(proto)
+          end
+
+          ######################################################
+          # Implements AjpCommandHandler
+          ######################################################
+          def handle_data(cmd)
+            raise ProtocolException.new("Invalid AJP command: %d", cmd.type)
+          end
+
+          def handle_end_response(cmd)
+            BayLog.debug("%s handle_end_response reuse=%s", @ship, cmd.reuse)
+            tur = @ship.get_tour(FIXED_WARP_ID)
+
+            if @state == STATE_READ_HEADER
+              end_res_header(tur)
+            end
+
+            end_res_content(tur)
+            if cmd.reuse
+              return NextSocketAction::CONTINUE
+            else
+              return NextSocketAction::CLOSE
+            end
+
+          end
+
+          def handle_forward_request(cmd)
+            raise ProtocolException.new("Invalid AJP command: #{cmd.type}")
+          end
+
+          def handle_send_body_chunk(cmd)
+            BayLog.debug("%s handle_send_body_chunk: len=%d", @ship, cmd.length)
+            tur = @ship.get_tour(FIXED_WARP_ID)
+
+            if @state == STATE_READ_HEADER
+
+              sid = @ship.ship_id
+              tur.res.set_consume_listener do |len, resume|
+                if resume
+                  @ship.resume(sid)
+                end
+              end
+
+              end_res_header(tur)
+            end
+
+            available = tur.res.send_content(tur.tour_id, cmd.chunk, 0, cmd.length)
+            @cont_read_len += cmd.length
+
+            if available
+              return NextSocketAction::CONTINUE
+            else
+              return NextSocketAction::SUSPEND
+            end
+          end
+
+          def handle_send_headers(cmd)
+            BayLog.debug("%s handle_send_headers", @ship)
+
+            tur = @ship.get_tour(FIXED_WARP_ID)
+
+            if @state != STATE_READ_HEADER
+              raise ProtocolException.new("Invalid AJP command: %d state=%s", cmd.type, @state)
+            end
+
+            wdat = WarpData.get(tur)
+
+            if BayServer.harbor.trace_header?
+              BayLog.info("%s recv res status: %d", wdat, cmd.status)
+            end
+
+            wdat.res_headers.status = cmd.status
+            cmd.headers.keys.each do |name|
+              cmd.headers[name].each do |value|
+                if BayServer.harbor.trace_header?
+                  BayLog.info("%s recv res header: %s=%s", wdat, name, value)
+                end
+                wdat.res_headers.add(name, value)
+              end
+            end
+
+            return NextSocketAction::CONTINUE
+          end
+
+          def handle_shutdown(cmd)
+            raise ProtocolException.new("Invalid AJP command: %d", cmd.type)
+          end
+
+          def handle_get_body_chunk(cmd)
+            BayLog.debug("%s handle_get_body_chunk", self)
+            return NextSocketAction::CONTINUE
+          end
+
+          def handle_eof
+            raise EOFError.new()
+          end
+
+          def need_data
+            return false
+          end
+
+          private
+          def end_res_header(tur)
+            wdat = WarpData.get(tur)
+            wdat.res_headers.copy_to(tur.res.headers)
+            tur.res.send_headers(Tour::TOUR_ID_NOCHECK)
+            change_state(STATE_READ_CONTENT)
+          end
+
+          def end_res_content(tur)
+            @ship.end_warp_tour(tur)
+            tur.res.end_content(Tour::TOUR_ID_NOCHECK)
+            reset_state()
+          end
+
+          def change_state(new_state)
+            @state = new_state
+          end
+
+          def reset_state
+            change_state(STATE_READ_HEADER)
+          end
+
+
+          def send_forward_request(tur)
+            BayLog.debug("%s construct header", tur)
+
+            cmd = CmdForwardRequest.new()
+            cmd.to_server = true
+            cmd.method = tur.req.method
+            cmd.protocol = tur.req.protocol
+            rel_uri = tur.req.rewritten_uri != nil ? tur.req.rewritten_uri : tur.req.uri
+            town_path = tur.town.name
+            if !town_path.end_with?("/")
+              town_path += "/"
+            end
+
+            rel_uri = rel_uri[town_path.length .. -1]
+            req_uri = @ship.docker.warp_base + rel_uri
+
+            pos = req_uri.index('?')
+            if pos != nil
+              cmd.req_uri = req_uri[0 .. pos - 1]
+              cmd.attributes["?query_string"] = req_uri[pos + 1 .. -1]
+            else
+              cmd.req_uri = req_uri
+            end
+
+            cmd.remote_addr = tur.req.remote_address
+            cmd.remote_host = tur.req.remote_host()
+            cmd.server_name = tur.req.server_name
+            cmd.server_port = @ship.docker.port
+            cmd.is_ssl = tur.is_secure
+            cmd.headers = tur.req.headers
+            if BayServer.harbor.trace_header?
+              cmd.headers.names.each do |name|
+                cmd.headers.values(name).each do |value|
+                  BayLog.info("%s sendWarpHeader: %s=%s", WarpData.get(tur), name, value)
+                end
+              end
+            end
+
+            command_packer.post(@ship, cmd)
+          end
+
+          def send_data(tur, data, ofs, len, &callback)
+            BayLog.debug("%s construct contents", tur)
+
+            cmd = CmdData.new(data, ofs, len)
+            cmd.to_server = true
+
+            command_packer.post(@ship, cmd, &callback)
+          end
+
+        end
+      end
+    end
+  end
+end
+

data/lib/baykit/bayserver/docker/ajp/command/cmd_data.rb

@@ -0,0 +1,59 @@
+require 'baykit/bayserver/docker/ajp/ajp_command'
+require 'baykit/bayserver/docker/ajp/ajp_type'
+require 'baykit/bayserver/docker/ajp/ajp_packet'
+
+#
+#  Data command format
+#
+#  AJP13_DATA :=
+#    len, raw data
+#
+module Baykit
+  module BayServer
+    module Docker
+      module Ajp
+        module Command
+          class CmdData < Baykit::BayServer::Docker::Ajp::AjpCommand
+            LENGTH_OF_SIZE = 2
+            MAX_DATA_LEN = AjpPacket::MAX_DATA_LEN - LENGTH_OF_SIZE
+
+            attr :start
+            attr_accessor :length
+            attr_accessor :data
+
+            def initialize(data = nil, start = 0, length = 0)
+              super(AjpType::DATA, true)
+              @data = data
+              @start = start
+              @length = length
+            end
+
+            def unpack(pkt)
+              super
+              acc = pkt.new_ajp_data_accessor
+              @length = acc.get_short
+              @data = pkt.buf
+              @start = pkt.header_len + 2
+            end
+
+            def pack(pkt)
+              acc = pkt.new_ajp_data_accessor
+              acc.put_short(@length)
+              acc.put_bytes(@data, @start, @length)
+
+              #BayLog.debug "pack AJP command data: #{pkt.data.bytes}"
+
+              #  must be called from last line
+              super
+            end
+
+            def handle(handler)
+              return handler.handle_data(self)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/baykit/bayserver/docker/ajp/command/cmd_end_response.rb

@@ -0,0 +1,48 @@
+require 'baykit/bayserver/docker/ajp/ajp_command'
+require 'baykit/bayserver/docker/ajp/ajp_type'
+
+#
+#  End response body format
+# 
+#  AJP13_END_RESPONSE :=
+#    prefix_code       5
+#    reuse             (boolean)
+#
+module Baykit
+  module BayServer
+    module Docker
+      module Ajp
+        module Command
+          class CmdEndResponse < Baykit::BayServer::Docker::Ajp::AjpCommand
+            attr_accessor :reuse
+
+            def initialize
+              super(AjpType::END_RESPONSE, false)
+            end
+
+            def pack(pkt)
+              acc = pkt.new_ajp_data_accessor
+              acc.put_byte(@type)
+              acc.put_byte(@reuse ? 1 : 0)
+
+              #  must be called from last line
+              super
+            end
+
+            def unpack(pkt)
+              super
+              acc = pkt.new_ajp_data_accessor()
+              acc.get_byte()   # prefix code
+              @reuse = acc.get_byte() != 0
+            end
+
+            def handle(handler)
+              return handler.handle_end_response(self)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+