bayserver-docker-ajp 2.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9f0897b0f990499668e38deec50e8c9426cb14c4a41e403bb08c7821a294f692
+  data.tar.gz: 527c1a81a6063b4079781c50e8efb8d2a0324418f6fbf55a4fad2a1fd3f1be73
+SHA512:
+  metadata.gz: f2c5f4a2373e576628a41326b018a301a0e51312068db3e8c16e849ede6e7bdd5c2ece680151c761c3d31ad8ebfd895e90ae14d77201420cd3858633a4c00d87
+  data.tar.gz: 13dab20d83962f56f704f312a4a49817be9689dfd5416646a253520f23876b61abbfa8a62bce73406dee3c07242ae2fd53d612ac21a11cf23399a7e6997755c0

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

@@ -0,0 +1,55 @@
+#
+#  AJP Protocol
+#  https://tomcat.apache.org/connectors-doc/ajp/ajpv13a.html
+#
+module Baykit
+  module BayServer
+    module Docker
+      module Ajp
+        class AjpCommand < Baykit::BayServer::Protocol::Command
+
+          attr_accessor :to_server
+
+          def initialize(type, to_server)
+            super type
+            @to_server = to_server
+          end
+
+          def unpack(pkt)
+            if pkt.type() != @type
+              raise RuntimeError.new("Illegal State")
+            end
+            @to_server = pkt.to_server
+          end
+
+          #
+          # Super class method must be called from last line of override method 
+          # since header cannot be packed before data is constructed.
+          # 
+          def pack(pkt)
+            if pkt.type() != @type
+              raise RuntimeError.new "Illegal State"
+            end
+            pkt.to_server = @to_server
+            pack_header(pkt)
+          end
+
+          def pack_header(pkt) 
+            acc = pkt.new_ajp_header_accessor
+            if pkt.to_server
+              acc.put_byte(0x12)
+              acc.put_byte(0x34)
+            else
+              acc.put_byte('A')
+              acc.put_byte('B')
+            end
+
+            acc.put_byte((pkt.data_len >> 8) & 0xff)
+            acc.put_byte(pkt.data_len & 0xff)
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,26 @@
+require 'baykit/bayserver/protocol/command_handler'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Ajp
+        module AjpCommandHandler
+          include Baykit::BayServer::Protocol::CommandHandler  # implements
+
+          # abstract method
+          #
+          # handle_data(cmd)
+          # handle_end_response(cmd)
+          # handle_forward_request(cmd)
+          # handle_send_body_chunk(cmd)
+          # handle_send_headers(cmd)
+          # handle_shutdown(cmd)
+          # handle_get_body_chunk(cmd)
+          # need_data()
+          #
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,66 @@
+require 'baykit/bayserver/protocol/command_unpacker'
+require 'baykit/bayserver/docker/ajp/ajp_type'
+require 'baykit/bayserver/docker/ajp/command/package'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Ajp
+        class AjpCommandUnPacker <Baykit::BayServer::Protocol::CommandUnPacker
+
+          include Baykit::BayServer::Docker::Ajp::Command
+
+          attr :cmd_handler
+
+          def initialize(handler)
+            @cmd_handler = handler
+            reset
+          end
+
+          def reset()
+          end
+
+          def packet_received(pkt)
+
+            BayLog.debug("ajp:  packet received: type=%d datalen=%d", pkt.type, pkt.data_len)
+
+            case pkt.type
+            when AjpType::DATA
+              cmd = CmdData.new
+
+            when AjpType::FORWARD_REQUEST
+              cmd = CmdForwardRequest.new
+
+            when AjpType::SEND_BODY_CHUNK
+              cmd = CmdSendBodyChunk.new(pkt.buf, pkt.header_len, pkt.data_len)
+
+            when AjpType::SEND_HEADERS
+              cmd = CmdSendHeaders.new
+
+            when AjpType::END_RESPONSE
+              cmd = CmdEndResponse.new
+
+            when AjpType::SHUTDOWN
+              cmd = CmdShutdown.new
+
+            when AjpType::GET_BODY_CHUNK
+              cmd = CmdGetBodyChunk.new
+
+            else
+              raise Sink.new()
+            end
+
+            cmd.unpack(pkt)
+            return cmd.handle(@cmd_handler)   # visit
+          end
+
+          def need_data()
+            return @cmd_handler.need_data()
+          end
+
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,15 @@
+module Baykit
+  module BayServer
+    module Docker
+      module Ajp
+        module AjpDocker
+          include Baykit::BayServer::Docker::Docker  # implements
+
+          PROTO_NAME = "ajp"
+
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,292 @@
+require 'baykit/bayserver/docker/base/inbound_handler'
+require 'baykit/bayserver/tours/req_content_handler'
+
+require 'baykit/bayserver/util/string_util'
+require 'baykit/bayserver/util/http_util'
+require 'baykit/bayserver/docker/ajp/ajp_protocol_handler'
+require 'baykit/bayserver/docker/ajp/command/package'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Ajp
+        class AjpInboundHandler < Baykit::BayServer::Docker::Ajp::AjpProtocolHandler
+
+          class InboundProtocolHandlerFactory
+            include Baykit::BayServer::Protocol::ProtocolHandlerFactory  # implements
+
+            def create_protocol_handler(pkt_store)
+              return AjpInboundHandler.new(pkt_store)
+            end
+          end
+
+          include Baykit::BayServer::Docker::Base::InboundHandler # implements
+          include Baykit::BayServer::Util
+          include Baykit::BayServer::Agent
+          include Baykit::BayServer::Protocol
+          include Baykit::BayServer::Tours
+          include Baykit::BayServer::Docker::Ajp::Command
+
+          STATE_READ_FORWARD_REQUEST = :FORWARD_REQUEST
+          STATE_READ_DATA = :READ_DATA
+
+          DUMMY_KEY = 1
+          attr :cur_tour_id
+          attr :req_command
+
+          attr :state
+          attr :keeping
+
+          def initialize(pkt_store)
+            super(pkt_store, true)
+            reset_state()
+          end
+
+          ######################################################
+          # implements Reusable
+          ######################################################
+          def reset()
+            super
+            reset_state()
+            @req_command = nil
+            @keeping = false
+            @cur_tour_id = 0
+          end
+
+          ######################################################
+          # implements InboundHandler
+          ######################################################
+          def send_res_headers(tur)
+            chunked = false
+            cmd = CmdSendHeaders.new()
+            tur.res.headers.names.each do |name|
+              tur.res.headers.values(name).each do |value|
+                cmd.add_header(name, value)
+              end
+            end
+            cmd.status = tur.res.headers.status
+            command_packer.post(@ship, cmd)
+
+            BayLog.debug("%s send header: content-length=%d", self, tur.res.headers.content_length())
+          end
+
+          def send_res_content(tur, bytes, ofs, len, &lis)
+            cmd = CmdSendBodyChunk.new(bytes, ofs, len);
+            @command_packer.post(ship, cmd, &lis);
+          end
+
+          def send_end_tour(tur, keep_alive, &callback)
+            BayLog.debug("%s endTour: tur=%s keep=%s", @ship, tur, keep_alive)
+            cmd = CmdEndResponse.new()
+            cmd.reuse = keep_alive
+
+            ensure_func = lambda do
+              if !keep_alive
+                command_packer.end(@ship)
+              end
+            end
+
+            begin
+              command_packer.post(@ship, cmd) do
+                BayLog.debug("%s call back in sendEndTour: tur=%s keep=%s", self, tur, keep_alive)
+                ensure_func.call()
+                callback.call()
+              end
+            rescue IOError => e
+              BayLog.debug("%s post failed in sendEndTour: tur=%s keep=%s", self, tur, keep_alive)
+              ensure_func.call()
+              raise e
+            end
+          end
+
+          def send_req_protocol_error(e)
+            tur = @ship.get_error_tour()
+            tur.res.send_error(Tour::TOUR_ID_NOCHECK, HttpStatus::BAD_REQUEST, e.message, e)
+            return true
+          end
+
+
+          ######################################################
+          # implements AjpCommandHandler
+          ######################################################
+          def handle_forward_request(cmd)
+            BayLog.debug("%s handleForwardRequest method=%s uri=%s", @ship, cmd.method, cmd.req_uri)
+            if @state != STATE_READ_FORWARD_REQUEST
+              raise ProtocolException.new("Invalid AJP command: #{cmd.type}")
+            end
+
+            @keeping = false
+            @req_command = cmd
+            tur = @ship.get_tour(DUMMY_KEY)
+            if tur == nil
+              BayLog.error(BayMessage.get(:INT_NO_MORE_TOURS))
+              tur = @ship.get_tour(AjpInboundHandler::DUMMY_KEY, true)
+              tur.res.send_error(Tour::TOUR_ID_NOCHECK, HttpStatus::SERVICE_UNAVAILABLE, "No available tours")
+              tur.res.end_content(Tour::TOUR_ID_NOCHECK)
+              @ship.agent.shutdown(false)
+              return NextSocketAction::CONTINUE
+            end
+
+            @cur_tour_id = tur.id
+            tur.req.uri = cmd.req_uri
+            tur.req.protocol = cmd.protocol
+            tur.req.method = cmd.method
+            cmd.headers.copy_to(tur.req.headers)
+            query_string = cmd.attributes["?query_string"]
+
+            if StringUtil.set?(query_string)
+              tur.req.uri += "?" + query_string
+            end
+
+            BayLog.debug("%s read header method=%s protocol=%s uri=%s contlen=%d",
+                         tur, tur.req.method, tur.req.protocol, tur.req.uri, tur.req.headers.content_length)
+
+            if BayServer.harbor.trace_header?
+              cmd.headers.names.each do |name|
+                cmd.headers.values(name).each do |value|
+                  BayLog.info("%s header: %s=%s", tur, name, value)
+                end
+              end
+            end
+
+            req_cont_len = cmd.headers.content_length
+            if req_cont_len > 0
+              sid = @ship.ship_id
+              tur.req.set_consume_listener(req_cont_len) do |len, resume|
+                if resume
+                  @ship.resume(sid)
+                end
+              end
+            end
+
+            begin
+              start_tour(tur)
+
+              if req_cont_len <= 0
+                end_req_content(tur)
+              else
+                change_state(STATE_READ_DATA)
+              end
+
+              return NextSocketAction::CONTINUE
+            rescue HttpException => e
+              if req_cont_len <= 0
+                tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, e)
+                reset_state()
+                return NextSocketAction::WRITE
+              else
+                # Delay send
+                change_state(STATE_READ_DATA)
+                tur.error = e
+                tur.req.set_content_handler(ReqContentHandler::DEV_NULL)
+                return NextSocketAction::CONTINUE
+              end
+            end
+          end
+
+          def handle_data(cmd)
+            BayLog.debug("%s handleData len=%s", @ship, cmd.length)
+
+            if @state != STATE_READ_DATA
+              raise RuntimeError.new("Invalid AJP command: #{cmd.type} state=#{@state}")
+            end
+
+            tur = @ship.get_tour(DUMMY_KEY)
+            success = tur.req.post_content(Tour::TOUR_ID_NOCHECK, cmd.data, cmd.start, cmd.length)
+
+            if tur.req.bytes_posted == tur.req.bytes_limit
+              # request content completed
+
+              if tur.error != nil
+                tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, tur.error)
+                reset_state()
+                return NextSocketAction::WRITE
+              else
+                begin
+                  end_req_content(tur)
+                  return NextSocketAction::CONTINUE
+                rescue HttpException => e
+                  tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, e)
+                  reset_state()
+                  return NextSocketAction::WRITE
+                end
+              end
+            else
+              bch = CmdGetBodyChunk.new()
+              bch.req_len = tur.req.bytes_limit - tur.req.bytes_posted
+              if bch.req_len > AjpPacket::MAX_DATA_LEN
+                bch.req_len = AjpPacket::MAX_DATA_LEN
+              end
+              command_packer.post(@ship, bch)
+
+              if !success
+                return NextSocketAction::SUSPEND
+              else
+                return NextSocketAction::CONTINUE
+              end
+            end
+          end
+
+          def handle_send_body_chunk(cmd)
+            raise RuntimeError.new "Invalid AJP command: #{cmd.type}"
+          end
+
+          def handle_send_headers(cmd)
+            raise RuntimeError.new "Invalid AJP command: #{cmd.type}"
+          end
+
+          def handle_shutdown(cmd)
+            BayLog.info("%s handle_shutdown", @ship)
+            BayServer.shutdown
+            NextSocketAction::CLOSE
+          end
+
+          def handle_end_response(cmd)
+            raise RuntimeError.new "Invalid AJP command: #{cmd.type}"
+          end
+
+          def handle_get_body_chunk(cmd)
+            raise RuntimeError.new "Invalid AJP command: #{cmd.type}"
+          end
+
+          def need_data()
+            return @state == STATE_READ_DATA
+          end
+
+          private
+          def reset_state
+            change_state(STATE_READ_FORWARD_REQUEST)
+          end
+
+          def change_state(new_state)
+            @state = new_state
+          end
+
+          def end_req_content(tur)
+            tur.req.end_content(Tour::TOUR_ID_NOCHECK)
+            reset_state()
+          end
+
+          def start_tour(tur)
+            HttpUtil.parse_host_port(tur, @req_command.is_ssl ? 443 : 80)
+            HttpUtil.parse_authorization(tur)
+
+            skt = @ship.socket
+            tur.req.remote_port = nil
+            tur.req.remote_address = @req_command.remote_addr
+            tur.req.remote_host_func = lambda { @req_command.remote_host }
+
+            tur.req.server_address = skt.local_address.ip_address
+            tur.req.server_port = @req_command.server_port
+            tur.req.server_name = @req_command.server_name
+            tur.is_secure = @req_command.is_ssl
+
+            tur.go()
+          end
+
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+require 'baykit/bayserver/protocol/packet_part_accessor'
+require 'baykit/bayserver/util/string_util'
+require 'baykit/bayserver/protocol/packet'
+
+#
+#  AJP Protocol
+#  https://tomcat.apache.org/connectors-doc/ajp/ajpv13a.html
+# 
+#  AJP packet spec
+# 
+#    packet:  preamble, length, body
+#    preamble:
+#         0x12, 0x34  (client->server)
+#      | 'A', 'B'     (server->client)
+#    length:
+#       2 byte
+#    body:
+#       $length byte
+# 
+# 
+#   Body format
+#     client->server
+#     Code     Type of Packet    Meaning
+#        2     Forward Request   Begin the request-processing cycle with the following data
+#        7     Shutdown          The web server asks the container to shut itself down.
+#        8     Ping              The web server asks the container to take control (secure login phase).
+#       10     CPing             The web server asks the container to respond quickly with a CPong.
+#     none     Data              Size (2 bytes) and corresponding body data.
+# 
+#     server->client
+#     Code     Type of Packet    Meaning
+#        3     Send Body Chunk   Send a chunk of the body from the servlet container to the web server (and presumably, onto the browser).
+#        4     Send Headers      Send the response headers from the servlet container to the web server (and presumably, onto the browser).
+#        5     End Response      Marks the end of the response (and thus the request-handling cycle).
+#        6     Get Body Chunk    Get further data from the request if it hasn't all been transferred yet.
+#        9     CPong Reply       The reply to a CPing request
+# 
+#
+
+module Baykit
+  module BayServer
+    module Docker
+      module Ajp
+        class AjpPacket < Baykit::BayServer::Protocol::Packet
+          class AjpAccessor < Baykit::BayServer::Protocol::PacketPartAccessor
+            include Baykit::BayServer::Util
+
+            def initialize(type, start, max_len)
+              super
+            end
+
+            def put_string(str)
+              if StringUtil.empty?(str)
+                put_short(0xffff)
+              else
+                put_short(str.length)
+                super str
+                put_byte(0) # null terminator
+              end
+            end
+
+            def get_string
+              get_string_by_len(get_short())
+            end
+
+            def get_string_by_len(len)
+
+              if len == 0xffff
+                return ""
+              end
+
+              buf = StringUtil.alloc(len)
+              get_bytes(buf, 0, len)
+              get_byte() # null terminator
+
+              buf
+            end
+          end
+
+          PREAMBLE_SIZE = 4
+          MAX_DATA_LEN = 8192 - PREAMBLE_SIZE
+          MIN_BUF_SIZE = 1024
+
+          attr_accessor :to_server
+
+          def initialize(type)
+            super(type, PREAMBLE_SIZE, MAX_DATA_LEN)
+          end
+
+          def reset()
+            @to_server = false
+            super
+          end
+
+          def new_ajp_header_accessor
+            AjpAccessor.new(self, 0, PREAMBLE_SIZE)
+          end
+
+          def new_ajp_data_accessor
+            AjpAccessor.new(self, PREAMBLE_SIZE, -1)
+          end
+
+          def to_s
+            "AjpPacket(#{@type})"
+          end
+
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,18 @@
+require 'baykit/bayserver/protocol/packet_factory'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Ajp
+        class AjpPacketFactory < Baykit::BayServer::Protocol::PacketFactory
+
+          def create_packet(type)
+            AjpPacket.new(type)
+          end
+
+        end
+      end
+    end
+  end
+end
+