bayserver-docker-http 2.3.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ac8ae113853e42ea44b42f459d91cd55c337e02bcb5726de6481febf07444e2
-  data.tar.gz: '0992bd7b3b0d38c3e0ecbd5d0f81e16035a09e5b7485fc0a0f85a86acfc4cdb3'
+  metadata.gz: 5a10c4b80275616d87322d82542025717b59c82bc6aadc73098f69ca63f63563
+  data.tar.gz: d26694ce403eb65e1a7b365d4905a116ab7d93b4b2c2dea7946476bc0258d2f9
 SHA512:
-  metadata.gz: d8c20c52306a2edeb7b05f860d4a4d44e8bd6e4a619007632f38731a107dd8eddfdcb0bf8f08898417690dff9b8e9b015c9e38c425d0c176037dd4349580e470
-  data.tar.gz: a797d4f137a00a9d7f8c643bc51dfbcf1be6c55a8d44afde1a827a4cb709f31356c18b98f2de9732c9b40017d3d7cf6d6871e48c0fe7c7ac0f05907a5d46c416
+  metadata.gz: 780e7922748b59d7a426d9aa4d6d89db81fe68ccd58dd09a43b620c504500fe14a5a5344ffd05d28fefc2f64df46374a3210eb2b96416ef0982a9ae4ccbc3c5b
+  data.tar.gz: 48b2750d675a6a8df7a11f60f4e9d43c45c17970360d47a2c90cb66aa1fc5f3f00f346bb7bad9dfd27b4db8b46cc34807231194b7ea316ab85c6424177cc7067

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

@@ -46,7 +46,7 @@ module Baykit
             end
 
             def finished()
-              return @cmd_handler.finished()
+              return @cmd_handler.req_finished()
             end
           end
         end

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

@@ -0,0 +1,16 @@
+
+module Baykit
+  module BayServer
+    module Docker
+      module Http
+        module H1
+          module H1Handler  # interface
+            def on_protocol_error(e)
+              raise NotImplementedError.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,7 @@
+require 'openssl'
 require 'baykit/bayserver/agent/upgrade_exception'
 
-require 'baykit/bayserver/docker/base/inbound_handler'
+require 'baykit/bayserver/common/inbound_handler'
 
 require 'baykit/bayserver/protocol/package'
 require 'baykit/bayserver/tours/req_content_handler'
@@ -10,7 +11,13 @@ require 'baykit/bayserver/util/url_encoder'
 require 'baykit/bayserver/util/http_util'
 require 'baykit/bayserver/util/headers'
 
+require 'baykit/bayserver/protocol/packet_packer'
+require 'baykit/bayserver/protocol/command_packer'
+
+require 'baykit/bayserver/docker/http/h1/h1_handler'
 require 'baykit/bayserver/docker/http/h1/h1_command_handler'
+require 'baykit/bayserver/docker/http/h1/h1_command_unpacker'
+require 'baykit/bayserver/docker/http/h1/h1_packet_unpacker'
 require 'baykit/bayserver/docker/http/h1/h1_protocol_handler'
 require 'baykit/bayserver/docker/http/h2/package'
 
@@ -19,22 +26,36 @@ module Baykit
     module Docker
       module Http
         module H1
-          class H1InboundHandler < Baykit::BayServer::Docker::Http::H1::H1ProtocolHandler
+          class H1InboundHandler
 
             class InboundProtocolHandlerFactory
               include Baykit::BayServer::Protocol::ProtocolHandlerFactory  # implements
 
+              include Baykit::BayServer::Protocol
+
               def create_protocol_handler(pkt_store)
-                return H1InboundHandler.new(pkt_store)
+                ib_handler = H1InboundHandler.new
+                cmd_unpacker = H1CommandUnPacker.new(ib_handler, true)
+                pkt_unpacker = H1PacketUnPacker.new(cmd_unpacker, pkt_store)
+                pkt_packer = PacketPacker.new
+                cmd_packer = CommandPacker.new(pkt_packer, pkt_store)
+
+                proto_handler = H1ProtocolHandler.new(ib_handler, pkt_unpacker, pkt_packer, cmd_unpacker, cmd_packer, true)
+                ib_handler.init(proto_handler)
+                return proto_handler
               end
             end
 
-            include Baykit::BayServer::Docker::Base::InboundHandler # implements
+            include Baykit::BayServer::Common::InboundHandler # implements
+            include H1Handler # implements
+
             include Baykit::BayServer::Agent
             include Baykit::BayServer::Protocol
             include Baykit::BayServer::Tours
             include Baykit::BayServer::Util
+            include Baykit::BayServer::Docker::Http::H1::Command
             include Baykit::BayServer::Docker::Http::H2
+            include OpenSSL
 
             STATE_READ_HEADER = 1
             STATE_READ_CONTENT = 2
@@ -42,6 +63,7 @@ module Baykit
 
             FIXED_REQ_ID = 1
 
+            attr :protocol_handler
             attr :header_read
             attr :state
             attr :cur_req_id
@@ -49,17 +71,19 @@ module Baykit
             attr :cur_tour_id
             attr :http_protocol
 
-            def initialize(pkt_store)
-              super(pkt_store, true)
-              reset()
+            def initialize
+              super
+              reset
+            end
+
+            def init(proto_handler)
+              @protocol_handler = proto_handler
             end
 
             ######################################################
             # implements Reusable
             ######################################################
             def reset()
-              super
-              @cur_req_id = 1
               reset_state()
 
               @header_read = false
@@ -96,7 +120,7 @@ module Baykit
 
               tur.res.headers.set(Headers::CONNECTION, res_con)
 
-              if BayServer.harbor.trace_header?
+              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).each do |value|
@@ -106,34 +130,34 @@ module Baykit
               end
 
               cmd = CmdHeader.new_res_header(tur.res.headers, tur.req.protocol)
-              @command_packer.post(@ship, cmd)
+              @protocol_handler.post(cmd)
             end
 
             def send_res_content(tur, bytes, ofs, len, &callback)
               BayLog.debug("%s H1 send_res_content len=%d", self, len)
               cmd = CmdContent.new(bytes, ofs, len)
-              @command_packer.post(@ship, cmd, &callback)
+              @protocol_handler.post(cmd, &callback)
             end
 
             def send_end_tour(tur, keep_alive, &callback)
-              BayLog.trace("%s sendEndTour: tur=%s keep=%s", @ship, tur, keep_alive)
+              BayLog.trace("%s sendEndTour: tur=%s keep=%s", ship, tur, keep_alive)
 
               # Send dummy end request command
               cmd = CmdEndContent.new()
 
-              sid = @ship.ship_id
+              sid = ship.ship_id
               ensure_func = lambda do
-                if keep_alive && !@ship.postman.zombie?
-                  @ship.keeping = true
-                  @ship.resume(sid)
+                if keep_alive
+                  ship.keeping = true
+                  ship.resume_read(sid)
                 else
-                  @command_packer.end(@ship)
+                  ship.post_close
                 end
               end
 
               begin
-                @command_packer.post(@ship, cmd) do
-                  BayLog.debug("%s call back of end content command: tur=%s", @ship, tur)
+                @protocol_handler.post(cmd) do
+                  BayLog.debug("%s call back of end content command: tur=%s", ship, tur)
                   ensure_func.call()
                   callback.call()
                 end
@@ -143,9 +167,9 @@ module Baykit
               end
             end
 
-            def send_req_protocol_error(err)
+            def on_protocol_error(err)
               if @cur_tour == nil
-                tur = @ship.get_error_tour()
+                tur = ship.get_error_tour()
               else
                 tur = @cur_tour
               end
@@ -158,7 +182,8 @@ module Baykit
             # implements H1CommandHandler
             ######################################################
             def handle_header(cmd)
-              BayLog.debug("%s handleHeader: method=%s uri=%s proto=", @ship, cmd.method, cmd.uri, cmd.version);
+              BayLog.debug("%s handleHeader: method=%s uri=%s proto=", ship, cmd.method, cmd.uri, cmd.version);
+              sip = ship
 
               if @state == STATE_FINISHED
                 change_state(STATE_READ_HEADER)
@@ -174,10 +199,10 @@ module Baykit
               # Check HTTP2
               protocol = cmd.version.upcase
               if protocol == "HTTP/2.0"
-                if @ship.port_docker.support_h2
-                  @ship.port_docker.return_protocol_handler(@ship.agent, self)
-                  new_hnd = ProtocolHandlerStore.get_store(HtpDocker::H2_PROTO_NAME, true, @ship.agent.agent_id).rent()
-                  @ship.set_protocol_handler(new_hnd)
+                if ship.port_docker.support_h2
+                  ship.port_docker.return_protocol_handler(ship.agent_id, @protocol_handler)
+                  new_hnd = ProtocolHandlerStore.get_store(HtpDocker::H2_PROTO_NAME, true, sip.agent_id).rent()
+                  sip.set_protocol_handler(new_hnd)
                   raise UpgradeException.new()
                 else
                   raise ProtocolException.new(
@@ -185,11 +210,11 @@ module Baykit
                 end
               end
 
-              tur = @ship.get_tour(@cur_req_id)
+              tur = sip.get_tour(@cur_req_id)
 
               if tur == nil
                 BayLog.error(BayMessage.get(:INT_NO_MORE_TOURS))
-                tur = @ship.get_tour(self.cur_req_id, true)
+                tur = sip.get_tour(self.cur_req_id, true)
                 tur.res.send_error(Tour::TOUR_ID_NOCHECK, HttpStatus::SERVICE_UNAVAILABLE, "No available tours")
                 return NextSocketAction::CONTINUE
               end
@@ -198,7 +223,7 @@ module Baykit
               @cur_tour_id = tur.id()
               @cur_req_id += 1
 
-              @ship.keeping = false
+              ship.keeping = false
 
               @http_protocol = protocol
 
@@ -219,21 +244,16 @@ module Baykit
 
               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, tur.req.headers.content_length)
+                           ship, tur.req.method, tur.req.protocol, tur.req.uri, tur.req.headers.content_length)
 
-              if BayServer.harbor.trace_header?
+              if BayServer.harbor.trace_header
                 cmd.headers.each do |item|
                   BayLog.info("%s h1: reqHeader: %s=%s", tur, item[0], item[1])
                 end
               end
 
               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
+                tur.req.set_limit(req_cont_len)
               end
 
               begin
@@ -247,9 +267,10 @@ module Baykit
                   return NextSocketAction::CONTINUE
                 end
               rescue HttpException => e
-                BayLog.debug("%s Http error occurred: %s", self, e)
+                BayLog.debug_e(e, "%s Http error occurred: %s", self, e)
                 if req_cont_len <= 0
                   # no post data
+                  tur.req.abort
                   tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, e)
 
                   reset_state() # next: read empty stdin command
@@ -266,7 +287,7 @@ module Baykit
             end
 
             def handle_content(cmd)
-              BayLog.debug("%s handleContent: len=%s", @ship, cmd.len)
+              BayLog.debug("%s handleContent: len=%s", ship, cmd.len)
 
               if @state != STATE_READ_CONTENT
                 s = @state
@@ -276,30 +297,38 @@ module Baykit
 
               tur = @cur_tour
               tur_id = @cur_tour_id
-              success = tur.req.post_content(tur_id, cmd.buf, cmd.start, cmd.len)
-
-              if tur.req.bytes_posted == tur.req.bytes_limit
-                if tur.error != nil
-                  # Error has occurred on header completed
-                  tur.res.send_http_exception(tur_id, tur.error)
-                  reset_state()
-                  return NextSocketAction::WRITE
-                else
-                  begin
+              begin
+                sid = ship.ship_id
+                success = tur.req.post_req_content(tur_id, cmd.buf, cmd.start, cmd.len) do |len, resume|
+                  if resume
+                    tur.ship.resume_read(sid)
+                  end
+                end
+
+                if tur.req.bytes_posted == tur.req.bytes_limit
+                  if tur.error != nil
+                    # Error has occurred on header completed
+                    #tur.res.send_http_exception(tur_id, tur.error)
+                    #reset_state()
+                    #return NextSocketAction::WRITE
+                    BayLog.debug("%s Delay report error", tur)
+                    raise tur.error
+                  else
                     end_req_content(tur_id, tur)
-                    return NextSocketAction::SUSPEND # end reading
-                  rescue HttpException => e
-                    tur.res.send_http_exception(tur_id, e)
-                    reset_state()
-                    return NextSocketAction::WRITE
+                    return NextSocketAction::CONTINUE
                   end
                 end
-              end
 
-              if !success
-                return NextSocketAction::SUSPEND
-              else
-                return NextSocketAction::CONTINUE
+                if !success
+                  return NextSocketAction::SUSPEND  # end reading
+                else
+                  return NextSocketAction::CONTINUE
+                end
+
+              rescue HttpException => e
+                tur.res.send_http_exception(tur_id, e)
+                reset_state()
+                return NextSocketAction::WRITE
               end
             end
 
@@ -307,13 +336,15 @@ module Baykit
               raise Sink.new()
             end
 
-            def finished()
+            def req_finished()
               return @state == STATE_FINISHED
             end
 
-
-
             private
+            def ship
+              return @protocol_handler.ship
+            end
+
             def change_state(new_state)
               @state = new_state
             end
@@ -325,16 +356,19 @@ module Baykit
             end
 
             def end_req_content(chk_tur_id, tur)
-              tur.req.end_content(chk_tur_id)
+              tur.req.end_req_content(chk_tur_id)
               reset_state()
             end
 
             def start_tour(tur)
-              secure = @ship.port_docker.secure
+              secure = ship.port_docker.secure
               HttpUtil.parse_host_port(tur, secure ? 443 : 80)
               HttpUtil.parse_authorization(tur)
 
-              skt = @ship.socket
+              skt = ship.rudder.io
+              if skt.kind_of? SSL::SSLSocket
+                skt = skt.io
+              end
 
               client_adr = tur.req.headers.get(Headers::X_FORWARDED_FOR)
               if client_adr

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

@@ -10,7 +10,6 @@ module Baykit
       module Http
         module H1
           class H1ProtocolHandler < Baykit::BayServer::Protocol::ProtocolHandler
-            include Baykit::BayServer::Docker::Http::H1::H1CommandHandler # implements
 
             include Baykit::BayServer::Agent
             include Baykit::BayServer::Protocol
@@ -20,17 +19,8 @@ module Baykit
 
             attr :keeping
 
-            def initialize(pkt_store, svr_mode)
-              @command_unpacker = H1CommandUnPacker.new(self, svr_mode)
-              @packet_unpacker = H1PacketUnPacker.new(@command_unpacker, pkt_store)
-              @packet_packer = PacketPacker.new()
-              @command_packer = CommandPacker.new(@packet_packer, pkt_store)
-              @server_mode = svr_mode
-              @keeping = false
-            end
-
-            def inspect()
-              return @ship.inspect()
+            def initialize(h1_handler, pkt_unpacker, pkt_packer, cmd_unpacker, cmd_packer, svr_mode)
+              super(pkt_unpacker, pkt_packer, cmd_unpacker, cmd_packer, h1_handler, svr_mode)
             end
 
             ######################################################

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

@@ -1,6 +1,6 @@
 require 'baykit/bayserver/tours/tour'
 require 'baykit/bayserver/protocol/protocol_exception'
-require 'baykit/bayserver/docker/warp/package'
+require 'baykit/bayserver/common/warp_handler'
 require 'baykit/bayserver/docker/http/h1/command/package'
 
 module Baykit
@@ -8,14 +8,25 @@ module Baykit
     module Docker
       module Http
         module H1
-          class H1WarpHandler < H1ProtocolHandler
-            include Baykit::BayServer::Docker::Warp::WarpHandler # implements
+          class H1WarpHandler
+            include Baykit::BayServer::Common::WarpHandler # implements
+            include H1Handler # implements
+            include Baykit::BayServer::Protocol
 
             class WarpProtocolHandlerFactory
               include Baykit::BayServer::Protocol::ProtocolHandlerFactory  # implements
+              include Baykit::BayServer::Protocol
 
               def create_protocol_handler(pkt_store)
-                return H1WarpHandler.new(pkt_store)
+                ib_handler = H1WarpHandler.new
+                cmd_unpacker = H1CommandUnPacker.new(ib_handler, false)
+                pkt_unpacker = H1PacketUnPacker.new(cmd_unpacker, pkt_store)
+                pkt_packer = PacketPacker.new
+                cmd_packer = CommandPacker.new(pkt_packer, pkt_store)
+
+                proto_handler = H1ProtocolHandler.new(ib_handler, pkt_unpacker, pkt_packer, cmd_unpacker, cmd_packer, true)
+                ib_handler.init(proto_handler)
+                return proto_handler
               end
             end
 
@@ -23,7 +34,7 @@ module Baykit
             include Baykit::BayServer::Tours
             include Baykit::BayServer::Agent
             include Baykit::BayServer::Util
-            include Baykit::BayServer::Docker::Warp
+            include Baykit::BayServer::Common
             include Baykit::BayServer::Docker::Http::H1::Command
 
             STATE_READ_HEADER = 1
@@ -32,35 +43,35 @@ module Baykit
 
             FIXED_WARP_ID = 1
 
+            attr :protocol_handler
             attr :state
 
-            def initialize(pkt_store)
-              super(pkt_store, false)
+            def initialize()
               reset()
             end
 
-            ######################################################
-            # Implements Reusable
-            ######################################################
+            def init(proto_handler)
+              @protocol_handler = proto_handler
+            end
 
-            def reset()
-              super
-              change_state(STATE_FINISHED)
+            def to_s
+              return ship.to_s
             end
 
 
             ######################################################
-            # Implements WarpHandler
+            # Implements Reusable
             ######################################################
-            def next_warp_id
-              return H1WarpHandler::FIXED_WARP_ID
-            end
 
-            def new_warp_data(warp_id)
-              return WarpData.new(@ship, warp_id)
+            def reset
+              reset_state
             end
 
-            def post_warp_headers(tur)
+            ######################################################
+            # Implements TourHandler
+            ######################################################
+
+            def send_res_headers(tur)
               twn = tur.town
 
               twn_path = twn.name
@@ -68,7 +79,7 @@ module Baykit
                 twn_path += "/"
               end
 
-              new_uri = @ship.docker.warp_base + tur.req.uri[twn_path.length .. -1]
+              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|
@@ -101,31 +112,39 @@ module Baykit
                 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::HOST, "#{ship.docker.host}:#{ship.docker.port}")
               cmd.set_header(Headers::CONNECTION, "Keep-Alive")
 
-              if BayServer.harbor.trace_header?
+              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
 
 
-              @ship.post(cmd)
+              ship.post(cmd)
             end
 
-            def post_warp_contents(tur, buf, start, len, &callback)
+            def send_res_content(tur, buf, start, len, &callback)
               cmd = CmdContent.new(buf, start, len)
-              @ship.post(cmd, callback)
+              ship.post(cmd, &callback)
             end
 
-            def post_warp_end(tur)
+            def send_end_tour(tur, keep_alive, &lis)
               cmd = CmdEndContent.new()
-              callback = lambda do
-                @ship.agent.non_blocking_handler.ask_to_read(@ship.socket)
-              end
+              ship.post(cmd, &lis)
+            end
 
-              @ship.post(cmd, callback)
+
+            ######################################################
+            # 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 verify_protocol(proto)
@@ -137,26 +156,26 @@ module Baykit
             ######################################################
 
             def handle_header(cmd)
-              tur = @ship.get_tour(FIXED_WARP_ID)
+              tur = ship.get_tour(FIXED_WARP_ID)
               wdat = WarpData.get(tur)
               BayLog.debug("%s handleHeader status=%d", wdat, cmd.status);
-              @ship.keeping = false
+              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)
+                raise ProtocolException.new("Header command not expected: state=%d", @state)
               end
 
-              if BayServer.harbor.trace_header?
+              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?
+                if BayServer.harbor.trace_header
                   BayLog.info("%s warp_http: resHeader: %s=%s", wdat, nv[0], nv[1]);
                 end
               end
@@ -170,10 +189,10 @@ module Baykit
                 end_res_content(tur)
               else
                 change_state(STATE_READ_CONTENT)
-                sid = @ship.id()
+                sid = ship.id()
                 tur.res.set_consume_listener do |len, resume|
                   if resume
-                    @ship.resume(sid)
+                    ship.resume_read(sid)
                   end
                 end
               end
@@ -181,7 +200,7 @@ module Baykit
             end
 
             def handle_content(cmd)
-              tur = @ship.get_tour(FIXED_WARP_ID)
+              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);
 
@@ -189,7 +208,7 @@ module Baykit
                 raise ProtocolException.new("Content command not expected")
               end
 
-              available = tur.res.send_content(Tour::TOUR_ID_NOCHECK, cmd.buf, cmd.start, cmd.len)
+              available = tur.res.send_res_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
@@ -204,26 +223,30 @@ module Baykit
               raise Sink.new()
             end
 
-            def finished()
+            def req_finished
               return @state == STATE_FINISHED
             end
 
-            def to_s
-              return @ship.to_s
-            end
-
             private
 
+            def reset_state
+              change_state(STATE_FINISHED)
+            end
+
             def end_res_content(tur)
-              @ship.end_warp_tour(tur)
-              tur.res.end_content(Tour::TOUR_ID_NOCHECK)
-              reset()
-              @ship.keeping = true
+              ship.end_warp_tour(tur)
+              tur.res.end_res_content(Tour::TOUR_ID_NOCHECK)
+              reset_state
+              ship.keeping = true
             end
 
             def change_state(new_state)
               @state = new_state
             end
+
+            def ship
+              return @protocol_handler.ship
+            end
           end
         end
       end

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

@@ -22,7 +22,6 @@ module Baykit
 
               def initialize(stream_id, flags=nil)
                 super(H2Type::WINDOW_UPDATE, stream_id, flags)
-                @items = []
               end
 
               def unpack(pkt)

data/lib/baykit/bayserver/docker/http/h2/h2_command_handler.rb

@@ -6,19 +6,41 @@ module Baykit
           module H2CommandHandler
             include Baykit::BayServer::Protocol::CommandHandler # implements
 
-            #
-            # abstract methods
-            #
-            # handle_preface(cmd)
-            # handle_data(cmd)
-            # handle_headers(cmd)
-            # handle_priority(cmd)
-            # handle_settings(cmd)
-            # handle_window_update(cmd)
-            # handle_go_away(cmd)
-            # handle_ping(cmd)
-            # handle_rst_stream(cmd)
-            #
+            def handle_preface(cmd)
+              raise NotImplementedError.new
+            end
+
+            def handle_data(cmd)
+              raise NotImplementedError.new
+            end
+
+            def handle_headers(cmd)
+              raise NotImplementedError.new
+            end
+
+            def handle_priority(cmd)
+              raise NotImplementedError.new
+            end
+
+            def handle_settings(cmd)
+              raise NotImplementedError.new
+            end
+
+            def handle_window_update(cmd)
+              raise NotImplementedError.new
+            end
+
+            def handle_go_away(cmd)
+              raise NotImplementedError.new
+            end
+
+            def handle_ping(cmd)
+              raise NotImplementedError.new
+            end
+
+            def handle_rst_stream(cmd)
+              raise NotImplementedError.new
+            end
           end
         end
       end

data/lib/baykit/bayserver/docker/http/h2/h2_handler.rb

@@ -0,0 +1,15 @@
+module Baykit
+  module BayServer
+    module Docker
+      module Http
+        module H2
+          module H2Handler  # interface
+            def on_protocol_error(e)
+              raise NotImplementedError.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/docker/http/h2/h2_inbound_handler.rb

@@ -1,7 +1,11 @@
-require 'baykit/bayserver/docker/base/inbound_handler'
+require 'baykit/bayserver/common/inbound_handler'
+
+require 'baykit/bayserver/protocol/packet_packer'
+require 'baykit/bayserver/protocol/command_packer'
 
 require 'baykit/bayserver/docker/http/h2/package'
 require 'baykit/bayserver/docker/http/h2/h2_protocol_handler'
+require 'baykit/bayserver/docker/http/h2/h2_handler'
 require 'baykit/bayserver/docker/http/h2/command/package'
 require 'baykit/bayserver/protocol/package'
 require 'baykit/bayserver/tours/req_content_handler'
@@ -15,17 +19,30 @@ module Baykit
     module Docker
       module Http
         module H2
-          class H2InboundHandler < Baykit::BayServer::Docker::Http::H2::H2ProtocolHandler
+          class H2InboundHandler
 
             class InboundProtocolHandlerFactory
               include Baykit::BayServer::Protocol::ProtocolHandlerFactory  # implements
 
+              include Baykit::BayServer::Protocol
+
               def create_protocol_handler(pkt_store)
-                return H2InboundHandler.new(pkt_store)
+
+                ib_handler = H2InboundHandler.new
+                cmd_unpacker = H2CommandUnPacker.new(ib_handler)
+                pkt_unpacker = H2PacketUnPacker.new(cmd_unpacker, pkt_store, true)
+                pkt_packer = PacketPacker.new()
+                cmd_packer = CommandPacker.new(pkt_packer, pkt_store)
+
+                proto_handler = H2ProtocolHandler.new(ib_handler, pkt_unpacker, pkt_packer, cmd_unpacker, cmd_packer, true)
+                ib_handler.init(proto_handler)
+                return proto_handler
               end
             end
 
-            include Baykit::BayServer::Docker::Base::InboundHandler  # implements
+            include Baykit::BayServer::Common::InboundHandler  # implements
+            include H2Handler # implements
+
             include Baykit::BayServer::Agent
             include Baykit::BayServer::Protocol
             include Baykit::BayServer::WaterCraft
@@ -33,6 +50,7 @@ module Baykit
             include Baykit::BayServer::Util
             include Baykit::BayServer::Docker::Http::H2::Command
 
+            attr :protocol_handler
             attr :req_cont_len
             attr :req_cont_read
             attr :header_read
@@ -40,12 +58,15 @@ module Baykit
             attr :settings
             attr :analyzer
             attr :http_protocol
+            attr :req_header_tbl
+            attr :res_header_tbl
 
-            def initialize(pkt_store)
-              super(pkt_store, true)
+            def initialize
               @window_size = BayServer.harbor.tour_buffer_size
               @settings = H2Settings.new
               @analyzer = HeaderBlockAnalyzer.new
+              @req_header_tbl = HeaderTable.create_dynamic_table()
+              @res_header_tbl = HeaderTable.create_dynamic_table()
             end
 
             ######################################################
@@ -53,12 +74,15 @@ module Baykit
             ######################################################
 
             def reset()
-              super
               @header_read = false
               @req_cont_len = 0
               @req_cont_read = 0
             end
 
+            def init(proto_handler)
+              @protocol_handler = proto_handler
+            end
+
             ######################################################
             # implements InboundHandler
             ######################################################
@@ -70,7 +94,7 @@ module Baykit
               cmd.header_blocks << blk
 
               # headers
-              if BayServer.harbor.trace_header?
+              if BayServer.harbor.trace_header
                 BayLog.info("%s res status: %d", tur, tur.res.headers.status)
               end
               tur.res.headers.names.each do |name|
@@ -78,7 +102,7 @@ module Baykit
                   BayLog.trace("%s Connection header is discarded", tur)
                 else
                   tur.res.headers.values(name).each do |value|
-                    if BayServer.harbor.trace_header?
+                    if BayServer.harbor.trace_header
                       BayLog.info("%s H2 res header: %s=%s", tur, name, value)
                     end
                     blk = bld.build_header_block(name, value, @res_header_tbl)
@@ -90,21 +114,23 @@ module Baykit
               cmd.flags.set_end_headers(true)
               cmd.excluded = true
               cmd.flags.set_padded(false)
-              @command_packer.post(@ship, cmd)
+              @protocol_handler.post(cmd)
             end
 
-            def send_res_content(tur, bytes, ofs, len, &lis)
+            def send_res_content(tur, bytes, ofs, len, &callback)
+              BayLog.debug("%s send_res_content len=%d", self, len)
               cmd = CmdData.new(tur.req.key, nil, bytes, ofs, len);
-              @command_packer.post(@ship, cmd, &lis)
+              @protocol_handler.post(cmd, &callback)
             end
 
             def send_end_tour(tur, keep_alive, &callback)
+              BayLog.debug("%s send_end_tour. keep=%s", self, keep_alive)
               cmd = CmdData.new(tur.req.key, nil, [], 0, 0)
               cmd.flags.set_end_stream(true)
-              @command_packer.post(@ship, cmd, &callback)
+              @protocol_handler.post(cmd, &callback)
             end
 
-            def send_req_protocol_error(err)
+            def on_protocol_error(err)
               BayLog.error_e err
               cmd = CmdGoAway.new(CTL_STREAM_ID)
               cmd.stream_id = CTL_STREAM_ID
@@ -112,8 +138,8 @@ module Baykit
               cmd.error_code = H2ErrorCode::PROTOCOL_ERROR
               cmd.debug_data = "Thank you!"
               begin
-                @command_packer.post(@ship, cmd)
-                @command_packer.end(@ship)
+                @protocol_handler.post(cmd)
+                @protocol_handler.end(ship)
               rescue IOError => e
                 BayLog.error_e(e)
               end
@@ -126,7 +152,7 @@ module Baykit
             ######################################################
 
             def handle_preface(cmd)
-              BayLog.debug("%s h2: handle_preface: proto=%s", @ship, cmd.protocol)
+              BayLog.debug("%s h2: handle_preface: proto=%s", ship, cmd.protocol)
 
               @http_protocol = cmd.protocol
 
@@ -134,7 +160,7 @@ module Baykit
               set.stream_id = 0
               set.items.append(CmdSettings::Item.new(CmdSettings::MAX_CONCURRENT_STREAMS, TourStore::MAX_TOURS))
               set.items.append(CmdSettings::Item.new(CmdSettings::INITIAL_WINDOW_SIZE, @window_size))
-              @command_packer.post(@ship, set)
+              @protocol_handler.post(set)
 
               set = CmdSettings.new(H2ProtocolHandler::CTL_STREAM_ID)
               set.stream_id = 0
@@ -145,12 +171,12 @@ module Baykit
 
 
             def handle_headers(cmd)
-              BayLog.debug("%s handle_headers: stm=%d dep=%d weight=%d", @ship, cmd.stream_id, cmd.stream_dependency, cmd.weight)
+              BayLog.debug("%s handle_headers: stm=%d dep=%d weight=%d", ship, cmd.stream_id, cmd.stream_dependency, cmd.weight)
 
               tur = get_tour(cmd.stream_id)
               if tur == nil
                 BayLog.error(BayMessage.get(:INT_NO_MORE_TOURS))
-                tur = @ship.get_tour(cmd.stream_id, true)
+                tur = ship.get_tour(cmd.stream_id, true)
                 tur.res.send_error(Tour::TOUR_ID_NOCHECK, HttpStatus::SERVICE_UNAVAILABLE, "No available tours")
                 return NextSocketAction::CONTINUE
               end
@@ -162,7 +188,7 @@ module Baykit
                   next
                 end
                 @analyzer.analyze_header_block(blk, @req_header_tbl)
-                if BayServer.harbor.trace_header?
+                if BayServer.harbor.trace_header
                   BayLog.info("%s req header: %s=%s :%s", tur, @analyzer.name, @analyzer.value, blk);
                 end
 
@@ -188,33 +214,12 @@ module Baykit
               if cmd.flags.end_headers?
                 tur.req.protocol = "HTTP/2.0"
                 BayLog.debug("%s H2 read header method=%s protocol=%s uri=%s contlen=%d",
-                             @ship, tur.req.method, tur.req.protocol, tur.req.uri, tur.req.headers.content_length)
+                             ship, tur.req.method, tur.req.protocol, tur.req.uri, tur.req.headers.content_length)
 
                 req_cont_len = tur.req.headers.content_length()
 
                 if req_cont_len > 0
-                  sid = @ship.ship_id
-                  tur.req.set_consume_listener(req_cont_len) do |len, resume|
-                    @ship.check_ship_id(sid)
-                    if len > 0
-                      upd = CmdWindowUpdate.new(cmd.stream_id)
-                      upd.window_size_increment = len
-                      upd2 = CmdWindowUpdate.new( 0)
-                      upd2.window_size_increment = len
-                      cmd_packer = @command_packer
-                      begin
-                        cmd_packer.post(@ship, upd)
-                        cmd_packer.post(@ship, upd2)
-                      rescue IOError => e
-                        BayLog.error_e(e)
-                      end
-                    end
-
-                    if resume
-                      @ship.resume(Ship::SHIP_ID_NOCHECK)
-                    end
-                  end
-
+                  tur.req.set_limit(req_cont_len)
                 end
 
                 begin
@@ -227,6 +232,7 @@ module Baykit
                   BayLog.debug("%s Http error occurred: %s", self, e);
                   if req_cont_len <= 0
                     # no post data
+                    tur.req.abort
                     tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, e)
 
                     return NextSocketAction::CONTINUE
@@ -244,7 +250,7 @@ module Baykit
             end
 
             def handle_data(cmd)
-              BayLog.debug("%s handle_data: stm=%d len=%d", @ship, cmd.stream_id, cmd.length)
+              BayLog.debug("%s handle_data: stm=%d len=%d", ship, cmd.stream_id, cmd.length)
 
               tur = get_tour(cmd.stream_id)
               if tur == nil
@@ -254,29 +260,51 @@ module Baykit
                 raise ProtocolException.new("Post content not allowed")
               end
 
-              success = false
-              if cmd.length > 0
-                success = tur.req.post_content(Tour::TOUR_ID_NOCHECK, cmd.data, cmd.start, cmd.length)
-                if tur.req.bytes_posted >= tur.req.headers.content_length
-                  if tur.error != nil
-                    # Error has occurred on header completed
+              begin
+                success = false
+                if cmd.length > 0
+                  tid = tur.tour_id
 
-                    tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, tur.error)
-                    return NextSocketAction::CONTINUE
-                  else
-                    begin
+                  success = tur.req.post_req_content(Tour::TOUR_ID_NOCHECK, cmd.data, cmd.start, cmd.length) do |len, resume|
+                    tur.check_tour_id(tid)
+                    if len > 0
+                      upd = CmdWindowUpdate.new(cmd.stream_id)
+                      upd.window_size_increment = len
+                      upd2 = CmdWindowUpdate.new( 0)
+                      upd2.window_size_increment = len
+                      begin
+                        @protocol_handler.post(upd)
+                        @protocol_handler.post(upd2)
+                      rescue IOError => e
+                        BayLog.error_e(e)
+                      end
+                    end
+
+                    if resume
+                      tur.ship.resume_read(Ship::SHIP_ID_NOCHECK)
+                    end
+                  end
+
+                  if tur.req.bytes_posted >= tur.req.headers.content_length
+                    if tur.error != nil
+                      # Error has occurred on header completed
+                      BayLog.debug("%s Delay report error", tur)
+                      raise tur.error
+                    else
                       end_req_content(tur.id(), tur)
-                    rescue HttpException => e
-                      tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, e)
-                      return NextSocketAction::CONTINUE
                     end
                   end
                 end
-              end
 
-              if !success
-                return NextSocketAction::SUSPEND
-              else
+                if !success
+                  return NextSocketAction::SUSPEND
+                else
+                  return NextSocketAction::CONTINUE
+                end
+
+              rescue HttpException => e
+                tur.req.abort
+                tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, e)
                 return NextSocketAction::CONTINUE
               end
 
@@ -288,20 +316,20 @@ module Baykit
               end
 
               BayLog.debug("%s handlePriority: stmid=%d dep=%d, wgt=%d",
-                           @ship, cmd.stream_id, cmd.stream_dependency, cmd.weight);
+                           ship, cmd.stream_id, cmd.stream_dependency, cmd.weight);
 
               return NextSocketAction::CONTINUE
             end
 
             def handle_settings(cmd)
-              BayLog.debug("%s handleSettings: stmid=%d", @ship, cmd.stream_id);
+              BayLog.debug("%s handleSettings: stmid=%d", ship, cmd.stream_id);
 
               if cmd.flags.ack?
                 return NextSocketAction::CONTINUE
               end
 
               cmd.items.each do |item|
-                BayLog.debug("%s handle: Setting id=%d, value=%d", @ship, item.id, item.value);
+                BayLog.debug("%s handle: Setting id=%d, value=%d", ship, item.id, item.value);
                 case item.id
                 when CmdSettings::HEADER_TABLE_SIZE
                   @settings.header_table_size = item.value
@@ -328,12 +356,12 @@ module Baykit
               end
 
               res = CmdSettings.new(0, H2Flags.new(H2Flags::FLAGS_ACK))
-              @command_packer.post(@ship, res)
+              @protocol_handler.post(res)
               return NextSocketAction::CONTINUE
             end
 
             def handle_window_update(cmd)
-              BayLog.debug("%s handleWindowUpdate: stmid=%d siz=%d", @ship,  cmd.stream_id, cmd.window_size_increment);
+              BayLog.debug("%s handleWindowUpdate: stmid=%d siz=%d", ship,  cmd.stream_id, cmd.window_size_increment);
 
               if cmd.window_size_increment == 0
                 raise ProtocolException.new("Invalid increment value")
@@ -345,40 +373,54 @@ module Baykit
 
             def handle_go_away(cmd)
               BayLog.debug("%s received GoAway: lastStm=%d code=%d desc=%s debug=%s",
-                           @ship, cmd.last_stream_id, cmd.error_code, H2ErrorCode.msg.get(cmd.error_code.to_s.to_sym), cmd.debug_data);
+                           ship, cmd.last_stream_id, cmd.error_code, H2ErrorCode.msg.get(cmd.error_code.to_s.to_sym), cmd.debug_data);
               return NextSocketAction::CLOSE
             end
 
             def handle_ping(cmd)
-              BayLog.debug("%s handle_ping: stm=%d", @ship, cmd.stream_id)
+              BayLog.debug("%s handle_ping: stm=%d", ship, cmd.stream_id)
 
               res = CmdPing.new(cmd.stream_id, H2Flags.new(H2Flags::FLAGS_ACK), cmd.opaque_data)
-              @command_packer.post(@ship, res)
+              @protocol_handler.post(res)
               return NextSocketAction::CONTINUE
             end
 
             def handle_rst_stream(cmd)
-              BayLog.debug("%s received RstStream: stmid=%d code=%d desc=%s",
-                           @ship, cmd.stream_id, cmd.error_code, H2ErrorCode.msg.get(cmd.error_code.to_s.to_sym))
-              return NextSocketAction::CONTINUE
+              BayLog.warn("%s received RstStream: stmid=%d code=%d desc=%s",
+                           ship, cmd.stream_id, cmd.error_code, H2ErrorCode.msg.get(cmd.error_code.to_s.to_sym))
+              tur = get_tour(cmd.stream_id)
+              if tur == nil
+                BayLog.warn("%s stream not found id=%d", ship, cmd.stream_id)
+              else
+                tur.req.abort
+                return NextSocketAction::CONTINUE
+              end
             end
 
             private
+
+            def ship
+              return @protocol_handler.ship
+            end
+
             def get_tour(key)
-              @ship.get_tour(key)
+              ship.get_tour(key)
             end
 
             def end_req_content(check_id, tur)
-              tur.req.end_content check_id
+              tur.req.end_req_content check_id
             end
 
             def start_tour(tur)
-              HttpUtil.parse_host_port(tur, @ship.port_docker.secure ? 443 : 80)
+              HttpUtil.parse_host_port(tur, ship.port_docker.secure ? 443 : 80)
               HttpUtil.parse_authorization(tur)
 
               tur.req.protocol = @http_protocol
 
-              skt = @ship.socket
+              skt = ship.rudder.io
+              if skt.kind_of? OpenSSL::SSL::SSLSocket
+                skt = skt.io
+              end
 
               client_adr = tur.req.headers.get(Headers::X_FORWARDED_FOR)
               if client_adr
@@ -399,12 +441,12 @@ module Baykit
                 server_port, tur.req.server_address = Socket.unpack_sockaddr_in(server_addr)
               rescue => e
                 BayLog.error_e(e)
-                BayLog.debug("%s Caught error (Continue)", @ship)
+                BayLog.debug("%s Caught error (Continue)", ship)
               end
 
               tur.req.server_port = tur.req.req_port
               tur.req.server_name = tur.req.req_host
-              tur.is_secure = @ship.port_docker.secure
+              tur.is_secure = ship.port_docker.secure
 
               tur.go
             end

data/lib/baykit/bayserver/docker/http/h2/h2_protocol_handler.rb

@@ -20,17 +20,9 @@ module Baykit
 
             CTL_STREAM_ID = 0
 
-            attr :req_header_tbl
-            attr :res_header_tbl
-
-            def initialize(pkt_store, svr_mode)
-              @command_unpacker = H2CommandUnPacker.new(self)
-              @packet_unpacker = H2PacketUnPacker.new(@command_unpacker, pkt_store, svr_mode)
-              @packet_packer = PacketPacker.new()
-              @command_packer = CommandPacker.new(@packet_packer, pkt_store)
-              @server_mode = svr_mode
-              @req_header_tbl = HeaderTable.create_dynamic_table()
-              @res_header_tbl = HeaderTable.create_dynamic_table()
+
+            def initialize(h2_handler, pkt_unpacker, pkt_packer, cmd_unpacker, cmd_packer, svr_mode)
+              super(pkt_unpacker, pkt_packer, cmd_unpacker, cmd_packer, h2_handler, svr_mode)
             end
 
             ######################################################

data/lib/baykit/bayserver/docker/http/h2/h2_warp_handler.rb

@@ -1,4 +1,4 @@
-require 'baykit/bayserver/docker/warp/package'
+require 'baykit/bayserver/common/warp_handler'
 require 'baykit/bayserver/protocol/protocol_exception'
 
 module Baykit
@@ -7,7 +7,7 @@ module Baykit
       module Http
         module H2
           class H2WarpHandler < H2ProtocolHandler
-            include Baykit::BayServer::Docker::Warp::WarpHandler # implements
+            include Baykit::BayServer::Common::WarpHandler # implements
 
             class WarpProtocolHandlerFactory
               include Baykit::BayServer::Protocol::ProtocolHandlerFactory  # implements

data/lib/baykit/bayserver/docker/http/htp_docker.rb

@@ -1,6 +1,5 @@
 require 'baykit/bayserver/agent/transporter/package'
 require 'baykit/bayserver/docker/base/port_base'
-require 'baykit/bayserver/docker/warp/package'
 require 'baykit/bayserver/docker/http/h1/package'
 
 

data/lib/baykit/bayserver/docker/http/htp_warp_docker.rb

@@ -2,8 +2,8 @@ require 'openssl'
 
 require 'baykit/bayserver/agent/transporter/package'
 require 'baykit/bayserver/docker/base/port_base'
+require 'baykit/bayserver/docker/base/warp_base'
 require 'baykit/bayserver/protocol/packet_store'
-require 'baykit/bayserver/docker/warp/package'
 require 'baykit/bayserver/docker/http/h1/package'
 require 'baykit/bayserver/docker/http/h2/package'
 
@@ -12,7 +12,7 @@ module Baykit
   module BayServer
     module Docker
       module Http
-        class HtpWarpDocker < Baykit::BayServer::Docker::Warp::WarpDocker
+        class HtpWarpDocker < Baykit::BayServer::Docker::Base::WarpBase
           include Baykit::BayServer::Docker::Http::HtpDocker # implements
 
           include OpenSSL
@@ -89,12 +89,25 @@ module Baykit
             return H1_PROTO_NAME
           end
 
-          def new_transporter(agt, skt)
+          def new_transporter(agt, rd, sip)
             if @secure
-              return SecureTransporter.new(@ssl_ctx, false, IOUtil.get_sock_recv_buf_size(skt), @trace_ssl)
+              tp =  SecureTransporter.new(
+                agt.net_multiplexer,
+                sip,
+                false,
+                false, IOUtil.get_sock_recv_buf_size(rd.io),
+                @trace_ssl,
+                @ssl_ctx)
             else
-              return PlainTransporter.new(false, IOUtil.get_sock_recv_buf_size(skt))
+              tp = PlainTransporter.new(
+                agt.net_multiplexer,
+                sip,
+                false,
+                IOUtil.get_sock_recv_buf_size(rd.io),
+                false)
             end
+            tp.init
+            return tp
           end
 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bayserver-docker-http
 version: !ruby/object:Gem::Version
-  version: 2.3.2
+  version: 3.0.0
 platform: ruby
 authors:
 - Michisuke-P
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-12-23 00:00:00.000000000 Z
+date: 2024-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bayserver-core
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.3.2
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.3.2
+        version: 3.0.0
 description: BayServer is one of the high-speed web servers. It operates as a single-threaded,
   asynchronous server, which makes it exceptionally fast. It also supports multi-core
   processors, harnessing the full potential of the CPU's capabilities.
@@ -41,6 +41,7 @@ files:
 - lib/baykit/bayserver/docker/http/h1/h1_command.rb
 - lib/baykit/bayserver/docker/http/h1/h1_command_handler.rb
 - lib/baykit/bayserver/docker/http/h1/h1_command_unpacker.rb
+- lib/baykit/bayserver/docker/http/h1/h1_handler.rb
 - lib/baykit/bayserver/docker/http/h1/h1_inbound_handler.rb
 - lib/baykit/bayserver/docker/http/h1/h1_packet.rb
 - lib/baykit/bayserver/docker/http/h1/h1_packet_factory.rb
@@ -64,6 +65,7 @@ files:
 - lib/baykit/bayserver/docker/http/h2/h2_command_unpacker.rb
 - lib/baykit/bayserver/docker/http/h2/h2_error_code.rb
 - lib/baykit/bayserver/docker/http/h2/h2_flags.rb
+- lib/baykit/bayserver/docker/http/h2/h2_handler.rb
 - lib/baykit/bayserver/docker/http/h2/h2_inbound_handler.rb
 - lib/baykit/bayserver/docker/http/h2/h2_packet.rb
 - lib/baykit/bayserver/docker/http/h2/h2_packet_factory.rb