bayserver-docker-http 2.2.0

data/lib/baykit/bayserver/docker/http/h1/h1_warp_handler.rb

@@ -0,0 +1,228 @@
+require 'baykit/bayserver/tours/tour'
+require 'baykit/bayserver/protocol/protocol_exception'
+require 'baykit/bayserver/docker/warp/package'
+require 'baykit/bayserver/docker/http/h1/command/package'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Http
+        module H1
+          class H1WarpHandler < H1ProtocolHandler
+            include Baykit::BayServer::Docker::Warp::WarpHandler # implements
+
+            class WarpProtocolHandlerFactory
+              include Baykit::BayServer::Protocol::ProtocolHandlerFactory  # implements
+
+              def create_protocol_handler(pkt_store)
+                return H1WarpHandler.new(pkt_store)
+              end
+            end
+
+            include Baykit::BayServer::Protocol
+            include Baykit::BayServer::Tours
+            include Baykit::BayServer::Agent
+            include Baykit::BayServer::Util
+            include Baykit::BayServer::Docker::Warp
+            include Baykit::BayServer::Docker::Http::H1::Command
+
+            STATE_READ_HEADER = 1
+            STATE_READ_CONTENT = 2
+            STATE_FINISHED = 3
+
+            FIXED_WARP_ID = 1
+
+            attr :state
+
+            def initialize(pkt_store)
+              super(pkt_store, false)
+              reset()
+            end
+
+            ######################################################
+            # Implements Reusable
+            ######################################################
+
+            def reset()
+              super
+              change_state(STATE_FINISHED)
+            end
+
+
+            ######################################################
+            # Implements WarpHandler
+            ######################################################
+            def next_warp_id
+              return H1WarpHandler::FIXED_WARP_ID
+            end
+
+            def new_warp_data(warp_id)
+              return WarpData.new(@ship, warp_id)
+            end
+
+            def post_warp_headers(tur)
+              twn = tur.town
+
+              twn_path = twn.name
+              if !twn_path.end_with?("/")
+                twn_path += "/"
+              end
+
+              new_uri = @ship.docker.warp_base + tur.req.uri[twn_path.length .. -1]
+              cmd = CmdHeader.new_req_header(tur.req.method, new_uri, "HTTP/1.1")
+
+              tur.req.headers.names.each do |name|
+                tur.req.headers.values(name).each do |value|
+                  cmd.add_header(name, value)
+                end
+              end
+
+              if tur.req.headers.contains(Headers::X_FORWARDED_FOR)
+                cmd.set_header(Headers::X_FORWARDED_FOR, tur.req.headers.get(Headers::X_FORWARDED_FOR))
+              else
+                cmd.set_header(Headers::X_FORWARDED_FOR, tur.req.remote_address)
+              end
+
+              if tur.req.headers.contains(Headers::X_FORWARDED_PROTO)
+                cmd.set_header(Headers::X_FORWARDED_PROTO, tur.req.headers.get(Headers::X_FORWARDED_PROTO))
+              else
+                cmd.set_header(Headers::X_FORWARDED_PROTO, tur.is_secure ? "https" : "http")
+              end
+
+              if tur.req.headers.contains(Headers::X_FORWARDED_PORT)
+                cmd.set_header(Headers::X_FORWARDED_PORT, tur.req.headers.get(Headers::X_FORWARDED_PORT))
+              else
+                cmd.set_header(Headers::X_FORWARDED_PORT, tur.req.server_port.to_s)
+              end
+
+              if tur.req.headers.contains(Headers::X_FORWARDED_HOST)
+                cmd.set_header(Headers::X_FORWARDED_HOST, tur.req.headers.get(Headers::X_FORWARDED_HOST))
+              else
+                cmd.set_header(Headers::X_FORWARDED_HOST, tur.req.headers.get(Headers::HOST))
+              end
+
+              cmd.set_header(Headers::HOST, "#{@ship.docker.host}:#{@ship.docker.port}")
+              cmd.set_header(Headers::CONNECTION, "Keep-Alive")
+
+              if BayServer.harbor.trace_header?
+                cmd.headers.each do |kv|
+                  BayLog.info("%s warp_http reqHdr: %s=%s", tur, kv[0], kv[1])
+                end
+              end
+
+
+              @command_packer.post(@ship, cmd)
+            end
+
+            def post_warp_contents(tur, buf, start, len, &callback)
+              cmd = CmdContent.new(buf, start, len)
+              @command_packer.post(@ship, cmd, &callback)
+            end
+
+            def post_warp_end(tur)
+
+            end
+
+            def verify_protocol(proto)
+
+            end
+
+            ######################################################
+            # Implements H1CommandHandler
+            ######################################################
+
+            def handle_header(cmd)
+              tur = @ship.get_tour(FIXED_WARP_ID)
+              wdat = WarpData.get(tur)
+              BayLog.debug("%s handleHeader status=%d", wdat, cmd.status);
+              @ship.keeping = false
+
+              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 warp_http: resStatus: %d", wdat, cmd.status)
+              end
+
+              cmd.headers.each do |nv|
+                tur.res.headers.add(nv[0], nv[1])
+                if BayServer.harbor.trace_header?
+                  BayLog.info("%s warp_http: resHeader: %s=%s", wdat, nv[0], nv[1]);
+                end
+              end
+
+              tur.res.headers.status = cmd.status
+              res_cont_len = tur.res.headers.content_length
+              tur.res.send_headers(Tour::TOUR_ID_NOCHECK)
+
+              BayLog.debug("%s contLen in header: %d", wdat, res_cont_len)
+              if res_cont_len == 0 || cmd.status == HttpStatus::NOT_MODIFIED
+                end_res_content(tur)
+              else
+                change_state(STATE_READ_CONTENT)
+                sid = @ship.id()
+                tur.res.set_consume_listener do |len, resume|
+                  if resume
+                    @ship.resume(sid)
+                  end
+                end
+              end
+              return NextSocketAction::CONTINUE
+            end
+
+            def handle_content(cmd)
+              tur = @ship.get_tour(FIXED_WARP_ID)
+              wdat = WarpData.get(tur)
+              BayLog.debug("%s handleContent len=%d posted%d contLen=%d", wdat, cmd.len, tur.res.bytes_posted, tur.res.bytes_limit);
+
+              if @state != STATE_READ_CONTENT
+                raise ProtocolException.new("Content command not expected")
+              end
+
+              available = tur.res.send_content(Tour::TOUR_ID_NOCHECK, cmd.buf, cmd.start, cmd.len)
+              if tur.res.bytes_posted == tur.res.bytes_limit
+                end_res_content(tur)
+                return NextSocketAction::CONTINUE
+              elsif !available
+                return NextSocketAction::SUSPEND
+              else
+                NextSocketAction::CONTINUE
+              end
+            end
+
+            def handle_end_content(cmd)
+              raise Sink.new()
+            end
+
+            def finished()
+              return @state == STATE_FINISHED
+            end
+
+            def to_s
+              return @ship.to_s
+            end
+
+            private
+
+            def end_res_content(tur)
+              @ship.end_warp_tour(tur)
+              tur.res.end_content(Tour::TOUR_ID_NOCHECK)
+              reset()
+              @ship.keeping = true
+            end
+
+            def change_state(new_state)
+              @state = new_state
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/baykit/bayserver/docker/http/h1/package.rb

@@ -0,0 +1,11 @@
+require 'baykit/bayserver/docker/http/h1/h1_type'
+require 'baykit/bayserver/docker/http/h1/h1_packet'
+require 'baykit/bayserver/docker/http/h1/h1_packet_factory'
+require 'baykit/bayserver/docker/http/h1/h1_packet_unpacker'
+require 'baykit/bayserver/docker/http/h1/h1_command'
+require 'baykit/bayserver/docker/http/h1/h1_command_unpacker'
+require 'baykit/bayserver/docker/http/h1/h1_command_handler'
+require 'baykit/bayserver/docker/http/h1/h1_inbound_handler'
+require 'baykit/bayserver/docker/http/h1/h1_protocol_handler'
+require 'baykit/bayserver/docker/http/h1/h1_warp_handler'
+

data/lib/baykit/bayserver/docker/http/h2/command/cmd_data.rb

@@ -0,0 +1,65 @@
+require 'baykit/bayserver/docker/http/h2/package'
+
+#
+# HTTP/2 Data payload format
+#
+# +---------------+
+# |Pad Length? (8)|
+# +---------------+-----------------------------------------------+
+# |                            Data (*)                         ...
+# +---------------------------------------------------------------+
+# |                           Padding (*)                       ...
+# +---------------------------------------------------------------+
+#
+module Baykit
+  module BayServer
+    module Docker
+      module Http
+        module H2
+          module Command
+
+            class CmdData < Baykit::BayServer::Docker::Http::H2::H2Command
+              include Baykit::BayServer::Docker::Http::H2
+
+              #
+              # This class refers external byte array, so this IS NOT mutable
+              #
+              attr :start
+              attr :length
+              attr :data
+
+              def initialize(stream_id, flags, data=nil, start=nil, len=nil)
+                super(H2Type::DATA, stream_id, flags)
+                @data = data
+                @start = start
+                @length = len
+              end
+
+              def unpack(pkt)
+                super
+                @data = pkt.buf
+                @start = pkt.header_len
+                @length = pkt.data_len()
+              end
+
+              def pack(pkt)
+                acc = pkt.new_data_accessor()
+                if @flags.padded?
+                  raise RuntimeError.new("Padding not supported")
+                end
+                acc.put_bytes(@data, @start, @length)
+                super
+              end
+
+              def handle(cmd_handler)
+                return cmd_handler.handle_data(self)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/baykit/bayserver/docker/http/h2/command/cmd_go_away.rb

@@ -0,0 +1,67 @@
+require 'baykit/bayserver/docker/http/h2/package'
+
+require 'baykit/bayserver/util/string_util'
+
+#
+#  HTTP/2 GoAway payload format
+#
+#  +-+-------------------------------------------------------------+
+#  |R|                  Last-Stream-ID (31)                        |
+#  +-+-------------------------------------------------------------+
+#  |                      Error Code (32)                          |
+#  +---------------------------------------------------------------+
+#  |                  Additional Debug Data (*)                    |
+#  +---------------------------------------------------------------+
+#
+#
+module Baykit
+  module BayServer
+    module Docker
+      module Http
+        module H2
+          module Command
+
+            class CmdGoAway < Baykit::BayServer::Docker::Http::H2::H2Command
+              include Baykit::BayServer::Util
+              include Baykit::BayServer::Docker::Http::H2
+
+              attr_accessor :last_stream_id
+              attr_accessor :error_code
+              attr_accessor :debug_data
+              
+              def initialize(stream_id, flags=nil)
+                super(H2Type::GOAWAY, stream_id, flags)
+              end
+
+              def unpack(pkt)
+                super
+                acc = pkt.new_data_accessor
+                val = acc.get_int
+                @last_stream_id = H2Packet.extract_int31(val)
+                @error_code = acc.get_int
+                @debug_data = StringUtil.alloc(pkt.data_len() - acc.pos)
+                acc.get_bytes(@debug_data, 0, @debug_data.length)
+              end
+
+              def pack(pkt)
+                acc = pkt.new_data_accessor()
+                acc.put_int(@last_stream_id)
+                acc.put_int(@error_code)
+                if @debug_data != nil
+                  acc.put_bytes(@debug_data, 0, @debug_data.length)
+                end
+                super
+              end
+
+              def handle(cmd_handler)
+                return cmd_handler.handle_go_away(self)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/baykit/bayserver/docker/http/h2/command/cmd_headers.rb

@@ -0,0 +1,108 @@
+require 'baykit/bayserver/docker/http/h2/package'
+
+#
+#  HTTP/2 Header payload format
+#
+#  +---------------+
+#  |Pad Length? (8)|
+#  +-+-------------+-----------------------------------------------+
+#  |E|                 Stream Dependency? (31)                     |
+#  +-+-------------+-----------------------------------------------+
+#  |  Weight? (8)  |
+#  +-+-------------+-----------------------------------------------+
+#  |                   Header Block Fragment (*)                 ...
+#  +---------------------------------------------------------------+
+#  |                           Padding (*)                       ...
+#  +---------------------------------------------------------------+
+#
+module Baykit
+  module BayServer
+    module Docker
+      module Http
+        module H2
+          module Command
+
+            class CmdHeaders < Baykit::BayServer::Docker::Http::H2::H2Command
+              include Baykit::BayServer::Docker::Http::H2
+
+              attr :pad_length
+              attr_accessor :excluded
+              attr :stream_dependency
+              attr :weight
+              attr :header_blocks
+
+              def initialize(stream_id, flags=nil)
+                super(H2Type::HEADERS, stream_id, flags)
+                @pad_length = 0
+                @excluded = false
+                @stream_dependency = 0
+                @weight = 0
+                @header_blocks = []
+              end
+
+              def unpack(pkt)
+                super
+                acc = pkt.new_h2_data_accessor
+
+                if pkt.flags.padded?
+                  @pad_length = acc.get_byte
+                end
+                if pkt.flags.priority?
+                  val = acc.get_int
+                  @excluded = H2Packet.extract_flag(val) == 1
+                  @stream_dependency = H2Packet.extract_int31(val)
+                  @weight = acc.get_byte
+                end
+                read_header_block(acc, pkt.data_len())
+              end
+
+              def pack(pkt)
+                acc = pkt.new_h2_data_accessor
+
+                if @flags.padded?
+                  acc.put_byte(@pad_length)
+                end
+
+                if @flags.priority?
+                  acc.put_int(H2Packet.make_stream_dependency32(@excluded, @stream_dependency))
+                  acc.put_byte(@weight)
+                end
+                write_header_block(acc)
+                super
+              end
+
+              def handle(cmd_handler)
+                return cmd_handler.handle_headers(self)
+              end
+
+              def read_header_block(acc, len)
+                while acc.pos < len
+                  blk = HeaderBlock.unpack(acc)
+                  #if(BayLog.trace_mode?)
+                  #  BayLog.trace "h2: Read header block: #{blk}"
+                  #end
+                  @header_blocks << blk
+                end
+              end
+
+              def write_header_block(acc)
+                @header_blocks.each do |blk|
+                  #if(BayLog.trace_mode?)
+                  #  BayLog.trace "h2: Write header block: #{blk}"
+                  #end
+                  HeaderBlock.pack(blk, acc)
+                end
+              end
+
+              def add_header_block(blk)
+                @header_blocks.append(blk)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/baykit/bayserver/docker/http/h2/command/cmd_ping.rb

@@ -0,0 +1,50 @@
+require 'baykit/bayserver/docker/http/h2/package'
+
+#
+#
+module Baykit
+  module BayServer
+    module Docker
+      module Http
+        module H2
+          module Command
+
+            class CmdPing < Baykit::BayServer::Docker::Http::H2::H2Command
+              include Baykit::BayServer::Docker::Http::H2
+
+              attr :opaque_data
+
+              def initialize(stream_id, flags=nil, opaque_data=nil)
+                super(H2Type::PING, stream_id, flags)
+                if opaque_data == nil
+                  @opaque_data = [0, 0, 0, 0, 0, 0, 0, 0].pack("C*")
+                else
+                  @opaque_data = opaque_data
+                end
+              end
+
+              def unpack(pkt)
+                super
+                acc = pkt.new_data_accessor()
+
+                acc.get_bytes(@opaque_data, 0, 8)
+              end
+
+              def pack(pkt)
+                acc = pkt.new_data_accessor()
+                acc.put_bytes(@opaque_data)
+                super
+              end
+
+              def handle(cmd_handler)
+                return cmd_handler.handle_ping(self)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/baykit/bayserver/docker/http/h2/command/cmd_preface.rb

@@ -0,0 +1,51 @@
+require 'baykit/bayserver/docker/http/h2/package'
+require 'baykit/bayserver/util/string_util'
+
+#
+#
+#  Preface is dummy command and packet
+#
+#    packet is not in frame format but raw data: "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
+#
+module Baykit
+  module BayServer
+    module Docker
+      module Http
+        module H2
+          module Command
+
+            class CmdPreface < Baykit::BayServer::Docker::Http::H2::H2Command
+              include Baykit::BayServer::Docker::Http::H2
+              include Baykit::BayServer::Util
+
+              PREFACE_BYTES = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
+              attr :protocol
+
+              def initialize(stream_id, flags=nil)
+                super(H2Type::PREFACE, stream_id, flags)
+              end
+
+              def unpack(pkt)
+                acc = pkt.new_data_accessor()
+                preface_data = StringUtil.alloc(24)
+                acc.get_bytes(preface_data, 0, 24)
+                @protocol = preface_data[6, 8]
+              end
+
+              def pack(pkt)
+                acc = pkt.new_h2_data_accessor()
+                acc.put_bytes(PREFACE_BYTES)
+              end
+
+              def handle(cmd_handler)
+                return cmd_handler.handle_preface(self)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/baykit/bayserver/docker/http/h2/command/cmd_priority.rb

@@ -0,0 +1,59 @@
+require 'baykit/bayserver/docker/http/h2/package'
+
+#
+# HTTP/2 Priority payload format
+#
+#  +-+-------------------------------------------------------------+
+#  |E|                  Stream Dependency (31)                     |
+#  +-+-------------+-----------------------------------------------+
+#  |   Weight (8)  |
+#  +-+-------------+
+#
+#
+module Baykit
+  module BayServer
+    module Docker
+      module Http
+        module H2
+          module Command
+
+            class CmdPriority < Baykit::BayServer::Docker::Http::H2::H2Command
+              include Baykit::BayServer::Docker::Http::H2
+
+              attr :weight
+              attr :excluded
+              attr :stream_dependency
+
+              def initialize(stream_id, flags=nil)
+                super(H2Type::PRIORITY, stream_id, flags)
+              end
+
+              def unpack(pkt)
+                super
+                acc = pkt.new_data_accessor()
+
+                val = acc.get_int
+                @excluded = H2Packet.extract_flag(val) == 1
+                @stream_dependency = H2Packet.extract_int31(val)
+                @weight = acc.get_byte
+              end
+
+              def pack(pkt)
+                acc = pkt.new_data_accessor()
+                acc.put_int(H2Packet.make_stream_dependency32(@excluded, @stream_dependency))
+                acc.put_byte(@weight)
+                super
+             end
+
+              def handle(cmd_handler)
+                return cmd_handler.handle_priority(self)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/baykit/bayserver/docker/http/h2/command/cmd_rst_stream.rb

@@ -0,0 +1,50 @@
+require 'baykit/bayserver/docker/http/h2/package'
+
+#
+# HTTP/2 RstStream payload format
+#
+#  +---------------------------------------------------------------+
+#  |                        Error Code (32)                        |
+#  +---------------------------------------------------------------+
+#
+#
+module Baykit
+  module BayServer
+    module Docker
+      module Http
+        module H2
+          module Command
+
+            class CmdRstStream < Baykit::BayServer::Docker::Http::H2::H2Command
+              include Baykit::BayServer::Docker::Http::H2
+
+              attr :error_code
+
+              def initialize(stream_id, flags=nil)
+                super(H2Type::RST_STREAM, stream_id, flags)
+             end
+
+              def unpack(pkt)
+                super
+                acc = pkt.new_data_accessor
+                @error_code = acc.get_int
+              end
+
+              def pack(pkt)
+                acc = pkt.new_data_accessor
+                acc.put_int(@error_code)
+                super
+              end
+
+              def handle(cmd_handler)
+                return cmd_handler.handle_rst_stream(self)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+