bayserver-docker-fcgi 2.2.0

data/lib/baykit/bayserver/docker/fcgi/fcg_inbound_handler.rb

@@ -0,0 +1,354 @@
+require 'baykit/bayserver/protocol/protocol_exception'
+require 'baykit/bayserver/docker/base/inbound_handler'
+require 'baykit/bayserver/tours/req_content_handler'
+require 'baykit/bayserver/util/cgi_util'
+
+require 'baykit/bayserver/docker/fcgi/fcg_protocol_handler'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Fcgi
+        class FcgInboundHandler < Baykit::BayServer::Docker::Fcgi::FcgProtocolHandler
+
+          class InboundProtocolHandlerFactory
+            include Baykit::BayServer::Protocol::ProtocolHandlerFactory  # implements
+
+            def create_protocol_handler(pkt_store)
+              return FcgInboundHandler.new(pkt_store)
+            end
+          end
+
+          include Baykit::BayServer::Docker::Base::InboundHandler # implements
+          include Baykit::BayServer::Agent
+          include Baykit::BayServer::Tours
+          include Baykit::BayServer::Protocol
+          include Baykit::BayServer::Util
+
+          STATE_BEGIN_REQUEST = 1
+          STATE_READ_PARAMS = 2
+          STATE_READ_STDIN = 3
+
+          attr :state
+          attr :cont_len
+
+          attr :env
+          attr :req_id
+          attr :req_keep_alive
+
+          def initialize(pkt_store)
+            super(pkt_store, true)
+            @env = {}
+            reset_state()
+          end
+
+          def to_s()
+            return ClassUtil.get_local_name(self.class)
+          end
+
+          ######################################################
+          # implements Reusable
+          ######################################################
+          def reset
+            super
+            @env.clear()
+            reset_state()
+          end
+
+          ######################################################
+          # implements InboundHandler
+          ######################################################
+
+          def send_res_headers(tur)
+            BayLog.debug("%s PH:sendHeaders: tur=%s", @ship, tur)
+
+            scode = tur.res.headers.status
+            status = "#{scode} #{HttpStatus.description(scode)}"
+            tur.res.headers.set(Headers::STATUS, status)
+
+            if BayServer.harbor.trace_header?
+              BayLog.info("%s resStatus:%d", tur, tur.res.headers.status)
+              tur.res.headers.names().each do |name|
+                tur.res.headers.values(name) do |value|
+                  BayLog.info("%s resHeader:%s=%s", tur, name, value)
+                end
+              end
+            end
+
+            buf = SimpleBuffer.new
+            HttpUtil.send_mime_headers(tur.res.headers, buf)
+            HttpUtil.send_new_line(buf)
+            cmd = CmdStdOut.new(tur.req.key, buf.buf, 0, buf.length)
+            @command_packer.post(@ship, cmd)
+          end
+
+          def send_res_content(tur, bytes, ofs, len, &callback)
+            cmd = CmdStdOut.new(tur.req.key, bytes, ofs, len);
+            @command_packer.post(@ship, cmd, &callback)
+          end
+
+          def send_end_tour(tur, keep_alive, &callback)
+            BayLog.debug("%s PH:endTour: tur=%s keep=%s", @ship, tur, keep_alive)
+
+            # Send empty stdout command
+            cmd = CmdStdOut.new(tur.req.key)
+            @command_packer.post(@ship, cmd)
+
+            # Send end request command
+            cmd = CmdEndRequest.new(tur.req.key)
+
+            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(err)
+            tur = @ship.get_error_tour()
+            tur.res.send_error(Tour::TOUR_ID_NOCHECK, HttpStatus::BAD_REQUEST, err.message, err)
+            true
+          end
+
+          ######################################################
+          # implements FcgCommandHandler
+          ######################################################
+          def handle_begin_request(cmd)
+            sip = ship()
+            BayLog.debug("%s handle_begin_request req_id=%d} keep=%s", sip, cmd.req_id, cmd.keep_conn)
+
+            if state != STATE_BEGIN_REQUEST
+              raise ProtocolException.new("Invalid FCGI command: %d state=%d", cmd.type, @state)
+            end
+
+            check_req_id(cmd.req_id)
+
+            @req_id = cmd.req_id
+            BayLog.debug("%s begin_req get_tour req_id=%d", sip, cmd.req_id)
+            tur = sip.get_tour(cmd.req_id)
+            if tur == nil
+              BayLog.error(BayMessage.get(:INT_NO_MORE_TOURS))
+              tur = sip.ship.get_tour(cmd.req_id, true)
+              tur.res.send_error(Tour::TOUR_ID_NOCHECK, HttpStatus.SERVICE_UNAVAILABLE, "No available tours")
+              sip.agent.shutdown(false)
+              return NextSocketAction::CONTINUE
+            end
+
+            @req_keep_alive = cmd.keep_conn
+            change_state(STATE_READ_PARAMS)
+            NextSocketAction::CONTINUE
+          end
+
+          def handle_end_request(cmd)
+            raise ProtocolException("Invalid FCGI command: %d", cmd.type)
+          end
+
+          def handle_params(cmd)
+            BayLog.debug("%s handle_params req_id=%d", @ship, cmd.req_id)
+
+            if state != STATE_READ_PARAMS
+              raise ProtocolException.new("Invalid FCGI command: %d state=%d", cmd.type, @state)
+            end
+
+            check_req_id(cmd.req_id)
+
+            BayLog.debug("%s handle_param get_tour req_id=%d", @ship, cmd.req_id)
+            tur = @ship.get_tour(cmd.req_id)
+
+            if cmd.params.empty?
+              # Header completed
+
+              # check keep-alive
+              #  keep-alive flag of BeginRequest has high priority
+              if @req_keep_alive
+                if !tur.req.headers.contains(Headers::CONNECTION)
+                  tur.req.headers.set(Headers::CONNECTION, "Keep-Alive")
+                else
+                  tur.req.headers.set(Headers::CONNECTION, "Close")
+                end
+              end
+
+              req_cont_len = tur.req.headers.content_length()
+
+              BayLog.debug("%s read header method=%s protocol=%s uri=%s contlen=%d",
+                           @ship, tur.req.method, tur.req.protocol, tur.req.uri, @cont_len)
+
+              if BayServer.harbor.trace_header?
+                cmd.params.each do |nv|
+                  BayLog.info("%s  reqHeader: %s=%s", tur, nv[0], nv[1])
+                end
+              end
+
+              if req_cont_len > 0
+                tur.req.set_consume_listener(req_cont_len) do |len, resume|
+                  sid = @ship.ship_id
+                  if resume
+                    @ship.resume(sid)
+                  end
+                end
+              end
+
+              change_state(STATE_READ_STDIN)
+              begin
+                start_tour(tur)
+              rescue HttpException => e
+                BayLog.debug("%s Http error occurred: %s", @ship, e)
+
+                if req_cont_len <= 0
+                  # no post data
+                  tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, e)
+                  change_state(STATE_READ_STDIN)
+                  return NextSocketAction::CONTINUE
+                else
+                  # Delay send
+                  change_state(STATE_READ_STDIN)
+                  tur.error = e
+                  tur.req.set_content_handler(ReqContentHandler.dev_null())
+                  return NextSocketAction::CONTINUE
+                end
+              end
+
+            else
+              if BayServer.harbor.trace_header?
+                BayLog.info("%s Read FcgiParam", tur)
+              end
+
+              cmd.params.each do |nv|
+                name = nv[0]
+                value = nv[1]
+                if BayServer.harbor.trace_header?
+                  BayLog.info("%s  param: %s=%s", tur, name, value);
+                end
+                @env[name] = value
+
+                if name.start_with?("HTTP_")
+                  hname = name[5 .. -1]
+                  tur.req.headers.add(hname, value)
+                elsif name == "CONTENT_TYPE"
+                  tur.req.headers.add(Headers::CONTENT_TYPE, value)
+                elsif name == "CONTENT_LENGTH"
+                  tur.req.headers.add(Headers::CONTENT_LENGTH, value)
+                elsif name == "HTTPS"
+                  tur.is_secure = value.downcase.casecmp? "on"
+                end
+              end
+
+              tur.req.uri = @env["REQUEST_URI"]
+              tur.req.protocol  = @env["SERVER_PROTOCOL"]
+              tur.req.method = @env["REQUEST_METHOD"]
+
+              return NextSocketAction::CONTINUE
+            end
+          end
+
+          def handle_stderr(cmd)
+            raise ProtocolException.new("Invalid FCGI command: %d", cmd.type)
+          end
+
+          def handle_stdin(cmd)
+            BayLog.debug("%s handle_stdin req_id=%d len=%d", @ship, cmd.req_id, cmd.length)
+
+            if @state != STATE_READ_STDIN
+              raise ProtocolException.new("Invalid FCGI command: %d state=%d", cmd.type, @state)
+            end
+
+            check_req_id(cmd.req_id)
+
+            tur = @ship.get_tour(cmd.req_id)
+            if cmd.length == 0
+              #  request content completed
+              if tur.error != nil
+                # Error has occurred on header completed
+                tur.res.set_consume_listener do |len, resume|
+                end
+                tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, tur.error)
+                reset_state()
+                return NextSocketAction::WRITE
+              else
+                begin
+                  end_req_content(Tour::TOUR_ID_NOCHECK, tur)
+                  return NextSocketAction::CONTINUE
+                rescue HttpException => e
+                  tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, e)
+                  return NextSocketAction::WRITE
+                end
+              end
+            else
+              success = tur.req.post_content(Tour::TOUR_ID_NOCHECK, cmd.data, cmd.start, cmd.length)
+
+              if !success
+                return NextSocketAction::SUSPEND
+              else
+                return NextSocketAction::CONTINUE
+              end
+            end
+          end
+
+          def handle_stdout(cmd)
+            raise ProtocolException.new("Invalid FCGI command: %d", cmd.type)
+          end
+
+          private
+          def check_req_id(received_id)
+            if received_id == FcgPacket::FCGI_NULL_REQUEST_ID
+              raise ProtocolException.new("Invalid request id: %d", received_id)
+            end
+
+            if @req_id == FcgPacket::FCGI_NULL_REQUEST_ID
+              @req_id = received_id
+            end
+
+            if @req_id != received_id
+              BayLog.error("%s invalid request id: received=%d reqId=%d", @ship, received_id, req_id)
+              raise ProtocolException.new("Invalid request id: %d", received_id)
+            end
+          end
+
+          def change_state(new_state)
+            @state = new_state
+          end
+
+          def reset_state
+            change_state(STATE_BEGIN_REQUEST)
+            @req_id = FcgPacket::FCGI_NULL_REQUEST_ID
+            @cont_len = 0
+          end
+
+          def end_req_content(check_id, tur)
+            tur.req.end_content(check_id)
+            reset_state()
+          end
+
+          def start_tour(tur)
+            HttpUtil.parse_host_port(tur, tur.is_secure ? 443 : 80)
+            HttpUtil.parse_authorization(tur)
+
+            tur.req.remote_port = @env[CgiUtil::REMOTE_PORT].to_i
+            tur.req.remote_address = @env[CgiUtil::REMOTE_ADDR]
+            tur.req.remote_host_func = lambda { @req_command.remote_host }
+
+            tur.req.server_name = @env[CgiUtil::SERVER_NAME]
+            tur.req.server_address = @env[CgiUtil::SERVER_ADDR]
+            tur.req.server_port = @env[CgiUtil::SERVER_PORT].to_i
+
+
+            tur.go
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/docker/fcgi/fcg_packet.rb

@@ -0,0 +1,56 @@
+require 'baykit/bayserver/protocol/packet'
+
+#
+#  FCGI spec
+#    http://www.mit.edu/~yandros/doc/specs/fcgi-spec.html
+#    
+#  FCGI Packet (Record) format
+#          typedef struct {
+#              unsigned char version;
+#              unsigned char type;
+#              unsigned char requestIdB1;
+#              unsigned char requestIdB0;
+#              unsigned char contentLengthB1;
+#              unsigned char contentLengthB0;
+#              unsigned char paddingLength;
+#              unsigned char reserved;
+#              unsigned char contentData[contentLength];
+#              unsigned char paddingData[paddingLength];
+#          } FCGI_Record;
+#
+module Baykit
+  module BayServer
+    module Docker
+      module Fcgi
+        class FcgPacket < Baykit::BayServer::Protocol::Packet
+
+          PREAMBLE_SIZE = 8
+
+          VERSION = 1
+          MAXLEN = 65535
+
+          FCGI_NULL_REQUEST_ID = 0
+
+          attr :version
+          attr_accessor :req_id
+
+          def initialize(type)
+            super(type, PREAMBLE_SIZE, MAXLEN)
+            @version = VERSION
+          end
+
+          def reset()
+            super
+            @version = VERSION
+            @req_id = 0
+          end
+
+          def to_s
+            "FcgPacket(#{@type}) id=#{@req_id}"
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/baykit/bayserver/docker/fcgi/fcg_packet_factory.rb

@@ -0,0 +1,17 @@
+require 'baykit/bayserver/protocol/packet_factory'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Fcgi
+        class FcgPacketFactory < Baykit::BayServer::Protocol::PacketFactory
+
+          def create_packet(type)
+            FcgPacket.new(type)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/docker/fcgi/fcg_packet_unpacker.rb

@@ -0,0 +1,201 @@
+require 'baykit/bayserver/protocol/packet_unpacker'
+require 'baykit/bayserver/util/simple_buffer'
+require 'baykit/bayserver/agent/next_socket_action'
+
+
+module Baykit
+  module BayServer
+    module Docker
+      module Fcgi
+        class FcgPacketUnPacker < Baykit::BayServer::Protocol::PacketUnPacker
+          include Baykit::BayServer::Util
+          include Baykit::BayServer::Agent
+
+          attr :header_buf
+          attr :data_buf
+
+          attr :version
+          attr :type
+          attr :req_id
+          attr :length
+          attr :padding
+          attr :padding_read_bytes
+
+          STATE_REQD_PREAMBLE = 1  # #state for reading first 8 bytes (from version to reserved)
+          STATE_READ_CONTENT = 2   #state for reading content data
+          STATE_READ_PADDING = 3   # state for reading padding data
+          STATE_END = 4            # End
+
+          attr :state
+
+          attr :cmd_unpacker
+          attr :pkt_store
+          attr :cont_len
+          attr :read_bytes
+
+          def initialize(pkt_store, cmd_unpacker)
+            @cmd_unpacker = cmd_unpacker
+            @pkt_store = pkt_store
+            @header_buf = SimpleBuffer.new
+            @data_buf = SimpleBuffer.new
+            reset()
+          end
+
+          def reset
+            @state = STATE_REQD_PREAMBLE
+            @version = 0
+            @type = nil
+            @req_id = 0
+            @length = 0
+            @padding = 0
+            @padding_read_bytes = 0
+            @cont_len = 0
+            @read_bytes = 0
+            @header_buf.reset
+            @data_buf.reset
+          end
+
+          def bytes_received(buf)
+            next_suspend = false
+            next_write = false
+            pos = 0
+
+            while pos < buf.length
+              while @state != STATE_END && pos < buf.length
+
+                case @state
+
+                when STATE_REQD_PREAMBLE
+                  # preamble read mode
+                  len = FcgPacket::PREAMBLE_SIZE - @header_buf.length
+                  if buf.length - pos < len
+                    len = buf.length - pos
+                  end
+
+                  @header_buf.put(buf, pos, len)
+                  pos += len
+
+                  if @header_buf.length == FcgPacket::PREAMBLE_SIZE
+                    header_read_done()
+                    if @length == 0
+                      if @padding == 0
+                        change_state(STATE_END)
+                      else
+                        change_state(STATE_READ_PADDING)
+                      end
+                    else
+                      change_state(STATE_READ_CONTENT)
+                    end
+                  end
+
+                when STATE_READ_CONTENT
+                  # content read mode
+                  len = @length - @data_buf.length
+                  if len > buf.length - pos
+                    len = buf.length - pos
+                  end
+
+                  if len > 0
+                    @data_buf.put(buf, pos, len)
+                    pos += len
+
+                    if @data_buf.length == @length
+                      if @padding == 0
+                        change_state(STATE_END)
+                      else
+                        change_state(STATE_READ_PADDING)
+                      end
+                    end
+                  end
+
+                when STATE_READ_PADDING
+                  # padding read mode
+                  len = @padding - @padding_read_bytes
+
+                  if len > buf.length - pos
+                    len = buf.length - pos
+                  end
+
+                  #@data_buf.put(buf, pos, len)
+                  pos += len
+
+                  if len > 0
+                    @padding_read_bytes += len
+
+                    if @padding_read_bytes == @padding
+                      change_state(STATE_END)
+                    end
+                  end
+
+                else
+                  raise RuntimeError.new("IllegalState")
+                end
+
+              end
+
+              if state == STATE_END
+                pkt = @pkt_store.rent(@type)
+                pkt.req_id = @req_id
+                pkt.new_header_accessor.put_bytes(@header_buf.buf, 0, @header_buf.length)
+                pkt.new_data_accessor.put_bytes(@data_buf.buf, 0, @data_buf.length)
+
+                begin
+                  state = @cmd_unpacker.packet_received(pkt)
+                ensure
+                  @pkt_store.Return(pkt)
+                end
+
+                reset()
+
+                case state
+                when NextSocketAction::SUSPEND
+                  next_suspend = true
+                when NextSocketAction::CONTINUE
+                  nil
+                when NextSocketAction::WRITE
+                  next_write = true
+                when NextSocketAction::CLOSE
+                  return state
+                end
+
+              end
+            end
+
+            if next_write
+              return NextSocketAction::WRITE
+            elsif next_suspend
+              return NextSocketAction::SUSPEND
+            else
+              return NextSocketAction::CONTINUE
+            end
+          end
+
+          def change_state(new_state)
+            @state = new_state
+          end
+
+          def header_read_done
+            pre = @header_buf.buf.codepoints
+            @version = byte_to_int(pre[0])
+            @type = byte_to_int(pre[1])
+            @req_id = bytes_to_int(pre[2], pre[3])
+            @length = bytes_to_int(pre[4], pre[5])
+            @padding = byte_to_int(pre[6])
+            reserved = byte_to_int(pre[7])
+            BayLog.debug("fcg: read packet header: version=%s type=%d reqId=%d length=%d padding=%d",
+                          @version, @type, @req_id, @length, @padding)
+          end
+
+          def byte_to_int(b)
+            return b & 0xff
+          end
+
+          def bytes_to_int(b1, b2)
+            return byte_to_int(b1) << 8 | byte_to_int(b2)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/docker/fcgi/fcg_params.rb

@@ -0,0 +1,46 @@
+module Baykit
+  module BayServer
+    module Docker
+      module Fcgi
+        class FcgParams
+          PATH = "PATH"
+          CONTEXT_DOCUMENT_ROOT = "CONTEXT_DOCUMENT_ROOT"
+          CONTEXT_PREFIX = "CONTEXT_PREFIX"
+          CONTENT_TYPE = "CONTENT_TYPE"
+          CONTENT_LENGTH = "CONTENT_LENGTH"
+          DOCUMENT_ROOT = "DOCUMENT_ROOT"
+          GATEWAY_INTERFACE = "GATEWAY_INTERFACE"
+          HTTP_ACCEPT = "HTTP_ACCEPT"
+          HTTP_ACCEPT_ENCODING = "HTTP_ACCEPT_ENCODING"
+          HTTP_ACCEPT_LANGUAGE = "HTTP_ACCEPT_LANGUAGE"
+          HTTP_CACHE_CONTROL = "HTTP_CACHE_CONTROL"
+          HTTP_COOKIE = "HTTP_COOKIE"
+          HTTP_CONNECTION = "HTTP_CONNECTION"
+          HTTP_HOST= "HTTP_HOST"
+          HTTP_USER_AGENT = "HTTP_USER_AGENT"
+          HTTP_UPGRADE_INSECURE_REQUESTS = "HTTP_UPGRADE_INSECURE_REQUESTS"
+          QUERY_STRING = "QUERY_STRING"
+          REMOTE_ADDR = "REMOTE_ADDR"
+          REQUEST_SCHEME = "REQUEST_SCHEME"
+          REQUEST_URI = "REQUEST_URI"
+          REMOTE_PORT = "REMOTE_PORT"
+          REQUEST_METHOD = "REQUEST_METHOD"
+          SCRIPT_NAME = "SCRIPT_NAME"
+          SCRIPT_FILENAME = "SCRIPT_FILENAME"
+          SERVER_ADDR = "SERVER_ADDR"
+          SERVER_ADMIN = "SERVER_ADMIN"
+          SERVER_NAME = "SERVER_NAME"
+          SERVER_PORT = "SERVER_PORT"
+          SERVER_PROTOCOL = "SERVER_PROTOCOL"
+          SERVER_SIGNATURE = "SERVER_SIGNATURE"
+          SERVER_SOFTWARE = "SERVER_SOFTWARE"
+          UNIQUE_ID = "UNIQUE_ID"
+          X_FORWARDED_FOR = "X-Forwarded-For"
+          X_FORWARDED_PROTO = "X-Forwarded-Proto"
+          X_FORWARDED_PORT = "X-Forwarded-Port"
+
+        end
+      end
+    end
+  end
+end