http-2 0.6.1 → 0.6.3

data/lib/http/2/connection.rb

@@ -11,36 +11,15 @@ module HTTP2
 
   # Connection encapsulates all of the connection, stream, flow-control,
   # error management, and other processing logic required for a well-behaved
-  # HTTP 2.0 client.
-  #
-  # When the connection object is instantiated you must specify its role
-  # (:client or :server) to initialize appropriate header compression
-  # and decompression algorithms and stream management logic.
-  #
-  # Your code is responsible for feeding data to connection object, which
-  # performs all of the necessary HTTP 2.0 decoding, state management and
-  # the rest, and vice versa, the parser will emit bytes (encoded HTTP 2.0
-  # frames) that you can then route to the destination. Roughly, this works
-  # as follows:
-  #
-  # @example
-  #     socket = YourTransport.new
-  #
-  #     conn = HTTP2::Connection.new(:client)
-  #     conn.on(:frame) {|bytes| socket << bytes }
-  #
-  #     while bytes = socket.read
-  #       conn << bytes
-  #     end
+  # HTTP 2.0 endpoint.
   #
+  # Note that this class should not be used directly. Instead, you want to
+  # use either Client or Server class to drive the HTTP 2.0 exchange.
   class Connection
     include FlowBuffer
     include Emitter
     include Error
 
-    # Type of connection (:server, :client).
-    attr_reader :type
-
     # Connection state (:new, :closed).
     attr_reader :state
 
@@ -59,34 +38,20 @@ module HTTP2
     # are not counted towards the stream limit).
     attr_reader :active_stream_count
 
-    # Initializes new client or server connection object.
+    # Initializes new connection object.
     #
-    # @param type [Symbol]
-    def initialize(type = :client)
-      @type = type
-
-      if @type == :server
-        @stream_id    = 2
-        @compressor   = Header::Compressor.new(:response)
-        @decompressor = Header::Decompressor.new(:request)
-      else
-        @stream_id    = 1
-        @compressor   = Header::Compressor.new(:request)
-        @decompressor = Header::Decompressor.new(:response)
-      end
-
-      @stream_limit = Float::INFINITY
+    def initialize(streams: 100, window: DEFAULT_FLOW_WINDOW)
+      @stream_limit = streams
       @active_stream_count = 0
       @streams = {}
 
       @framer = Framer.new
-      @window = DEFAULT_FLOW_WINDOW
-      @window_limit = DEFAULT_FLOW_WINDOW
+      @window = window
+      @window_limit = window
 
       @recv_buffer = Buffer.new
       @send_buffer = []
       @continuation = []
-      @state = :new
       @error = nil
     end
 
@@ -95,11 +60,11 @@ module HTTP2
     # @param priority [Integer]
     # @param window [Integer]
     # @param parent [Stream]
-    def new_stream(priority: DEFAULT_PRIORITY, window: @window_limit, parent: nil)
+    def new_stream(priority: DEFAULT_PRIORITY, parent: nil)
       raise ConnectionClosed.new if @state == :closed
       raise StreamLimitExceeded.new if @active_stream_count == @stream_limit
 
-      stream = activate_stream(@stream_id, priority, window, parent)
+      stream = activate_stream(@stream_id, priority, parent)
       @stream_id += 2
 
       stream
@@ -132,13 +97,19 @@ module HTTP2
       @state = :closed
     end
 
-    # Sends a connection SETTINGS frame to the peer.
+    # Sends a connection SETTINGS frame to the peer. Setting window size
+    # to Float::INFINITY disables flow control.
     #
-    # @param payload [Hash]
-    # @option payload [Symbol] :settings_max_concurrent_streams
-    # @option payload [Symbol] :settings_flow_control_options
-    # @option payload [Symbol] :settings_initial_window_size
-    def settings(payload)
+    # @param stream_limit [Integer] maximum number of concurrent streams
+    # @param window_limit [Float] maximum flow window size
+    def settings(stream_limit: @stream_limit, window_limit: @window_limit)
+      payload = { settings_max_concurrent_streams: stream_limit }
+      if window_limit.to_f.infinite?
+        payload[:settings_flow_control_options] = 1
+      else
+        payload[:settings_initial_window_size] = window_limit
+      end
+
       send({type: :settings, stream: 0, payload: payload})
     end
 
@@ -150,6 +121,29 @@ module HTTP2
     def receive(data)
       @recv_buffer << data
 
+      # Upon establishment of a TCP connection and determination that
+      # HTTP/2.0 will be used by both peers, each endpoint MUST send a
+      # connection header as a final confirmation and to establish the
+      # initial settings for the HTTP/2.0 connection.
+      #
+      # Client connection header is 24 byte connection header followed by
+      # SETTINGS frame. Server connection header is SETTINGS frame only.
+      if @state == :new
+        if @recv_buffer.size < 24
+          if !CONNECTION_HEADER.start_with? @recv_buffer
+            raise HandshakeError.new
+          else
+            return
+          end
+
+        elsif @recv_buffer.read(24) != CONNECTION_HEADER
+          raise HandshakeError.new
+        else
+          @state = :connection_header
+          settings(stream_limit: @stream_limit, window_limit: @window_limit)
+        end
+      end
+
       while frame = @framer.parse(@recv_buffer) do
         # Header blocks MUST be transmitted as a contiguous sequence of frames
         # with no interleaved frames of any other type, or from any other stream.
@@ -207,8 +201,7 @@ module HTTP2
             stream = @streams[frame[:stream]]
             if stream.nil?
               stream = activate_stream(frame[:stream],
-                                       frame[:priority] || DEFAULT_PRIORITY,
-                                       @window_limit)
+                                       frame[:priority] || DEFAULT_PRIORITY)
               emit(:stream, stream)
             end
 
@@ -255,7 +248,7 @@ module HTTP2
               end
             end
 
-            stream = activate_stream(pid, DEFAULT_PRIORITY, @window_limit, parent)
+            stream = activate_stream(pid, DEFAULT_PRIORITY, parent)
             emit(:promise, stream)
             stream << frame
           else
@@ -269,6 +262,9 @@ module HTTP2
           end
         end
       end
+
+    rescue
+      connection_error
     end
     alias :<< :receive
 
@@ -300,7 +296,7 @@ module HTTP2
     # Applies HTTP 2.0 binary encoding to the frame.
     #
     # @param frame [Hash]
-    # @return [String] encoded frame
+    # @return [Buffer] encoded frame
     def encode(frame)
       if frame[:type] == :headers ||
          frame[:type] == :push_promise
@@ -331,7 +327,7 @@ module HTTP2
     # @param frame [Hash]
     def connection_management(frame)
       case @state
-      when :new
+      when :connection_header
         # SETTINGS frames MUST be sent at the start of a connection.
         connection_settings(frame)
         @state = :connected
@@ -419,7 +415,7 @@ module HTTP2
     # @param frame [Hash]
     def decode_headers(frame)
       if frame[:payload].is_a? String
-        frame[:payload] = @decompressor.decode(StringIO.new(frame[:payload]))
+        frame[:payload] = @decompressor.decode(frame[:payload])
       end
 
     rescue Exception => e
@@ -453,46 +449,24 @@ module HTTP2
     # @param priority [Integer]
     # @param window [Integer]
     # @param parent [Stream]
-    def activate_stream(id, priority, window, parent = nil)
+    def activate_stream(id, priority, parent = nil)
       if @streams.key?(id)
         connection_error(msg: 'Stream ID already exists')
       end
 
-      stream = Stream.new(id, priority, window, parent)
+      stream = Stream.new(id, priority, @window_limit, parent)
 
       # Streams that are in the "open" state, or either of the "half closed"
       # states count toward the maximum number of streams that an endpoint is
       # permitted to open.
       stream.once(:active) { @active_stream_count += 1 }
       stream.once(:close)  { @active_stream_count -= 1 }
-      stream.on(:promise, &method(:promise))
+      stream.on(:promise, &method(:promise)) if self.is_a? Server
       stream.on(:frame,   &method(:send))
 
       @streams[id] = stream
     end
 
-    # Handle locally initiated server-push event emitted by the stream.
-    #
-    # @param args [Array]
-    # @param callback [Proc]
-    def promise(*args, &callback)
-      if @type == :client
-        raise ProtocolError.new("client cannot initiate promise")
-      end
-
-      parent, headers, flags = *args
-      promise = new_stream(parent: parent)
-      promise.send({
-        type: :push_promise,
-        flags: flags,
-        stream: parent.id,
-        promise_stream: promise.id,
-        payload: headers.to_a
-      })
-
-      callback.call(promise)
-    end
-
     # Emit GOAWAY error indicating to peer that the connection is being
     # aborted, and once sent, raise a local exception.
     #
@@ -509,7 +483,7 @@ module HTTP2
 
       @state, @error = :closed, error
       klass = error.to_s.split('_').map(&:capitalize).join
-      raise Kernel.const_get(klass).new(msg)
+      raise Error.const_get(klass).new(msg)
     end
 
   end

data/lib/http/2/emitter.rb

@@ -20,8 +20,8 @@ module HTTP2
     # @param event [Symbol]
     # @param block [Proc] callback function
     def once(event, &block)
-      add_listener(event) do |*args|
-        block.call(*args)
+      add_listener(event) do |*args, &callback|
+        block.call(*args, &callback)
         :delete
       end
     end

data/lib/http/2/error.rb

@@ -3,6 +3,11 @@ module HTTP2
   # Stream, connection, and compressor exceptions.
   module Error
 
+    # Raised if connection header is missing or invalid indicating that
+    # this is an invalid HTTP 2.0 request - no frames are emitted and the
+    # connection must be aborted.
+    class HandshakeError < Exception; end
+
     # Raised by stream or connection handlers, results in GOAWAY frame
     # which signals termination of the current connection. You *cannot*
     # recover from this exception, or any exceptions subclassed from it.

data/lib/http/2/framer.rb

@@ -71,8 +71,8 @@ module HTTP2
 
     RBIT  = 0x7fffffff
     RBYTE = 0x0fffffff
-    HEADERPACK = "SCCL"
-    UINT32 = "L"
+    HEADERPACK = "nCCN"
+    UINT32 = "N"
 
     private_constant :RBIT, :RBYTE, :HEADERPACK, :UINT32
 
@@ -118,7 +118,7 @@ module HTTP2
 
     # Decodes common 8-byte header.
     #
-    # @param buf [String]
+    # @param buf [Buffer]
     def readCommonHeader(buf)
       frame = {}
       frame[:length], type, flags, stream = buf.slice(0,8).unpack(HEADERPACK)
@@ -138,7 +138,7 @@ module HTTP2
     #
     # @param frame [Hash]
     def generate(frame)
-      bytes  = ''
+      bytes  = Buffer.new
       length = 0
 
       frame[:flags]  ||= []
@@ -146,7 +146,7 @@ module HTTP2
 
       case frame[:type]
       when :data
-        bytes  += frame[:payload]
+        bytes  << frame[:payload]
         length += frame[:payload].bytesize
 
       when :headers
@@ -155,19 +155,19 @@ module HTTP2
         end
 
         if frame[:flags].include? :priority
-          bytes  += [frame[:priority] & RBIT].pack(UINT32)
+          bytes  << [frame[:priority] & RBIT].pack(UINT32)
           length += 4
         end
 
-        bytes  += frame[:payload]
+        bytes  << frame[:payload]
         length += frame[:payload].bytesize
 
       when :priority
-        bytes  += [frame[:priority] & RBIT].pack(UINT32)
+        bytes  << [frame[:priority] & RBIT].pack(UINT32)
         length += 4
 
       when :rst_stream
-        bytes  += pack_error frame[:error]
+        bytes  << pack_error(frame[:error])
         length += 4
 
       when :settings
@@ -184,14 +184,14 @@ module HTTP2
             end
           end
 
-          bytes  += [k & RBYTE].pack(UINT32)
-          bytes  += [v].pack(UINT32)
+          bytes  << [k & RBYTE].pack(UINT32)
+          bytes  << [v].pack(UINT32)
           length += 8
         end
 
       when :push_promise
-        bytes  += [frame[:promise_stream] & RBIT].pack(UINT32)
-        bytes  += frame[:payload]
+        bytes  << [frame[:promise_stream] & RBIT].pack(UINT32)
+        bytes  << frame[:payload]
         length += 4 + frame[:payload].bytesize
 
       when :ping
@@ -199,36 +199,36 @@ module HTTP2
           raise CompressionError.new("Invalid payload size \
                                     (#{frame[:payload].size} != 8 bytes)")
         end
-        bytes  += frame[:payload]
+        bytes  << frame[:payload]
         length += 8
 
       when :goaway
-        bytes  += [frame[:last_stream] & RBIT].pack(UINT32)
-        bytes  += pack_error frame[:error]
+        bytes  << [frame[:last_stream] & RBIT].pack(UINT32)
+        bytes  << pack_error(frame[:error])
         length += 8
 
         if frame[:payload]
-          bytes  += frame[:payload]
+          bytes  << frame[:payload]
           length += frame[:payload].bytesize
         end
 
       when :window_update
-        bytes  += [frame[:increment] & RBIT].pack(UINT32)
+        bytes  << [frame[:increment] & RBIT].pack(UINT32)
         length += 4
 
       when :continuation
-        bytes  += frame[:payload]
+        bytes  << frame[:payload]
         length += frame[:payload].bytesize
       end
 
       frame[:length] = length
-      commonHeader(frame) + bytes
+      bytes.prepend(commonHeader(frame))
     end
 
     # Decodes complete HTTP 2.0 frame from provided buffer. If the buffer
     # does not contain enough data, no further work is performed.
     #
-    # @param buf [String]
+    # @param buf [Buffer]
     def parse(buf)
       return nil if buf.size < 8
       frame = readCommonHeader(buf)
@@ -242,36 +242,37 @@ module HTTP2
         frame[:payload] = payload.read(frame[:length])
       when :headers
         if frame[:flags].include? :priority
-          frame[:priority] = payload.read(4).unpack(UINT32).first & RBIT
+          frame[:priority] = payload.read_uint32 & RBIT
         end
         frame[:payload] = payload.read(frame[:length])
       when :priority
-        frame[:priority] = payload.read(4).unpack(UINT32).first & RBIT
+        frame[:priority] = payload.read_uint32 & RBIT
       when :rst_stream
-        frame[:error] = unpack_error payload.read(4).unpack(UINT32).first
+        frame[:error] = unpack_error payload.read_uint32
 
       when :settings
         frame[:payload] = {}
         (frame[:length] / 8).times do
-          id  = payload.read(4).unpack(UINT32).first & RBYTE
-          val = payload.read(4).unpack(UINT32).first
+          id  = payload.read_uint32 & RBYTE
+          val = payload.read_uint32
 
+          # Unsupported or unrecognized settings MUST be ignored.
           name, _ = DEFINED_SETTINGS.select { |name, v| v == id }.first
-          frame[:payload][name || id] = val
+          frame[:payload][name] = val if name
         end
       when :push_promise
-        frame[:promise_stream] = payload.read(4).unpack(UINT32).first & RBIT
+        frame[:promise_stream] = payload.read_uint32 & RBIT
         frame[:payload] = payload.read(frame[:length])
       when :ping
         frame[:payload] = payload.read(frame[:length])
       when :goaway
-        frame[:last_stream] = payload.read(4).unpack(UINT32).first & RBIT
-        frame[:error] = unpack_error payload.read(4).unpack(UINT32).first
+        frame[:last_stream] = payload.read_uint32 & RBIT
+        frame[:error] = unpack_error payload.read_uint32
 
         size = frame[:length] - 8
         frame[:payload] = payload.read(size) if size > 0
       when :window_update
-        frame[:increment] = payload.read(4).unpack(UINT32).first & RBIT
+        frame[:increment] = payload.read_uint32 & RBIT
       when :continuation
         frame[:payload] = payload.read(frame[:length])
       end