http-2 0.6.1 → 0.6.3

data/lib/http/2/server.rb

@@ -0,0 +1,55 @@
+module HTTP2
+
+  # HTTP 2.0 server connection class that implements appropriate header
+  # compression / decompression algorithms and stream management logic.
+  #
+  # Your code is responsible for feeding request data to the server object,
+  # which in turn performs all of the necessary HTTP 2.0 decoding / encoding,
+  # state management, and the rest. A simple example:
+  #
+  # @example
+  #     socket = YourTransport.new
+  #
+  #     conn = HTTP2::Server.new
+  #     conn.on(:stream) do |stream|
+  #       ...
+  #     end
+  #
+  #     while bytes = socket.read
+  #       conn << bytes
+  #     end
+  #
+  class Server < Connection
+
+    # Initialize new HTTP 2.0 server object.
+    def initialize(*args)
+      @stream_id    = 2
+      @state        = :new
+      @compressor   = Header::Compressor.new(:response)
+      @decompressor = Header::Decompressor.new(:request)
+
+      super
+    end
+
+    private
+
+    # Handle locally initiated server-push event emitted by the stream.
+    #
+    # @param args [Array]
+    # @param callback [Proc]
+    def promise(*args, &callback)
+      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
+  end
+
+end

data/lib/http/2/stream.rb

@@ -467,7 +467,7 @@ module HTTP2
       close(error) if @state != :closed
 
       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/version.rb

@@ -1,3 +1,3 @@
 module HTTP2
-  VERSION = "0.6.1"
+  VERSION = "0.6.3"
 end

data/spec/buffer_spec.rb

@@ -0,0 +1,23 @@
+require "helper"
+
+describe HTTP2::Buffer do
+
+  let(:b) { Buffer.new("émalgré") }
+
+  it "should force 8-bit encoding" do
+    b.encoding.to_s.should eq "ASCII-8BIT"
+  end
+
+  it "should return bytesize of the buffer" do
+    b.size.should eq 9
+  end
+
+  it "should read single byte at a time" do
+    9.times { b.read(1).should_not be_nil }
+  end
+
+  it "should unpack an unsigned 32-bit int" do
+    Buffer.new([256].pack("N")).read_uint32.should eq 256
+  end
+
+end

data/spec/client_spec.rb

@@ -0,0 +1,93 @@
+require "helper"
+
+describe HTTP2::Client do
+  before(:each) do
+    @client = Client.new
+  end
+
+  let(:f) { Framer.new }
+
+  context "initialization and settings" do
+    it "should return odd stream IDs" do
+      @client.new_stream.id.should_not be_even
+    end
+
+    it "should emit connection header and SETTINGS on new client connection" do
+      frames = []
+      @client.on(:frame) { |bytes| frames << bytes }
+      @client.ping("12345678")
+
+      frames[0].should eq CONNECTION_HEADER
+      f.parse(frames[1])[:type].should eq :settings
+    end
+
+    it "should initialize client with custom connection settings" do
+      frames = []
+
+      @client = Client.new(streams: 200)
+      @client.on(:frame) { |bytes| frames << bytes }
+      @client.ping("12345678")
+
+      frame = f.parse(frames[1])
+      frame[:type].should eq :settings
+      frame[:payload][:settings_max_concurrent_streams].should eq 200
+    end
+  end
+
+  context "push" do
+    it "should disallow client initiated push" do
+      expect do
+        @client.promise({}) {}
+      end.to raise_error(Exception)
+    end
+
+    it "should raise error on PUSH_PROMISE against stream 0" do
+      expect {
+        @client << set_stream_id(f.generate(PUSH_PROMISE), 0)
+      }.to raise_error(ProtocolError)
+    end
+
+    it "should raise error on PUSH_PROMISE against bogus stream" do
+      expect {
+        @client << set_stream_id(f.generate(PUSH_PROMISE), 31415)
+      }.to raise_error(ProtocolError)
+    end
+
+    it "should raise error on PUSH_PROMISE against non-idle stream" do
+      expect {
+        s = @client.new_stream
+        s.send HEADERS
+
+        @client << set_stream_id(f.generate(PUSH_PROMISE), s.id)
+        @client << set_stream_id(f.generate(PUSH_PROMISE), s.id)
+     }.to raise_error(ProtocolError)
+    end
+
+    it "should emit stream object for received PUSH_PROMISE" do
+      s = @client.new_stream
+      s.send HEADERS
+
+      promise = nil
+      @client.on(:promise) {|s| promise = s }
+      @client << set_stream_id(f.generate(PUSH_PROMISE), s.id)
+
+      promise.id.should eq 2
+      promise.state.should eq :reserved_remote
+    end
+
+    it "should auto RST_STREAM promises against locally-RST stream" do
+      s = @client.new_stream
+      s.send HEADERS
+      s.close
+
+      @client.stub(:send)
+      @client.should_receive(:send) do |frame|
+        frame[:type].should eq :rst_stream
+        frame[:stream].should eq 2
+      end
+
+      @client << set_stream_id(f.generate(PUSH_PROMISE), s.id)
+    end
+  end
+
+end

data/spec/compressor_spec.rb

@@ -10,25 +10,25 @@ describe HTTP2::Header do
       it "should encode 10 using a 5-bit prefix" do
         buf = c.integer(10, 5)
         buf.should eq [10].pack('C')
-        d.integer(StringIO.new(buf), 5).should eq 10
+        d.integer(Buffer.new(buf), 5).should eq 10
       end
 
       it "should encode 10 using a 0-bit prefix" do
         buf = c.integer(10, 0)
         buf.should eq [10].pack('C')
-        d.integer(StringIO.new(buf), 0).should eq 10
+        d.integer(Buffer.new(buf), 0).should eq 10
       end
 
       it "should encode 1337 using a 5-bit prefix" do
         buf = c.integer(1337, 5)
         buf.should eq [31,128+26,10].pack('C*')
-        d.integer(StringIO.new(buf), 5).should eq 1337
+        d.integer(Buffer.new(buf), 5).should eq 1337
       end
 
       it "should encode 1337 using a 0-bit prefix" do
         buf = c.integer(1337,0)
         buf.should eq [128+57,10].pack('C*')
-        d.integer(StringIO.new(buf), 0).should eq 1337
+        d.integer(Buffer.new(buf), 0).should eq 1337
       end
     end
 
@@ -37,7 +37,7 @@ describe HTTP2::Header do
         ascii = "abcdefghij"
         str = c.string(ascii)
 
-        buf = StringIO.new(str+"trailer")
+        buf = Buffer.new(str+"trailer")
         d.string(buf).should eq ascii
       end
 
@@ -45,7 +45,7 @@ describe HTTP2::Header do
         utf8 = "éáűőúöüó€"
         str = c.string(utf8)
 
-        buf = StringIO.new(str+"trailer")
+        buf = Buffer.new(str+"trailer")
         d.string(buf).should eq utf8
       end
 
@@ -53,7 +53,7 @@ describe HTTP2::Header do
         utf8 = "éáűőúöüó€"*100
         str = c.string(utf8)
 
-        buf = StringIO.new(str+"trailer")
+        buf = Buffer.new(str+"trailer")
         d.string(buf).should eq utf8
       end
     end
@@ -62,120 +62,105 @@ describe HTTP2::Header do
   context "header representation" do
     it "should handle indexed representation" do
       h = {name: 10, type: :indexed}
-
-      indexed = StringIO.new(c.header(h))
-      d.header(indexed).should eq h
+      d.header(c.header(h)).should eq h
     end
 
     context "literal w/o indexing representation" do
       it "should handle indexed header" do
         h = {name: 10, value: "my-value", type: :noindex}
-
-        literal = StringIO.new(c.header(h))
-        d.header(literal).should eq h
+        d.header(c.header(h)).should eq h
       end
 
       it "should handle literal header" do
         h = {name: "x-custom", value: "my-value", type: :noindex}
-
-        literal = StringIO.new(c.header(h))
-        d.header(literal).should eq h
+        d.header(c.header(h)).should eq h
       end
     end
 
     context "literal w/ incremental indexing" do
       it "should handle indexed header" do
         h = {name: 10, value: "my-value", type: :incremental}
-
-        literal = StringIO.new(c.header(h))
-        d.header(literal).should eq h
+        d.header(c.header(h)).should eq h
       end
 
       it "should handle literal header" do
         h = {name: "x-custom", value: "my-value", type: :incremental}
-
-        literal = StringIO.new(c.header(h))
-        d.header(literal).should eq h
+        d.header(c.header(h)).should eq h
       end
     end
 
     context "literal w/ substitution indexing" do
       it "should handle indexed header" do
         h = {name: 1, value: "my-value", index: 10, type: :substitution}
-
-        literal = StringIO.new(c.header(h))
-        d.header(literal).should eq h
+        d.header(c.header(h)).should eq h
       end
 
       it "should handle literal header" do
         h = {name: "x-new", value: "my-value", index: 10, type: :substitution}
-
-        literal = StringIO.new(c.header(h))
-        d.header(literal).should eq h
+        d.header(c.header(h)).should eq h
       end
     end
   end
 
   context "differential coding" do
     context "shared compression context" do
-      before(:each) { @cc = CompressionContext.new(:request) }
+      before(:each) { @cc = EncodingContext.new(:request) }
 
       it "should be initialized with pre-defined headers" do
-        cc = CompressionContext.new(:request)
-        cc.table.size.should eq 38
+        cc = EncodingContext.new(:request)
+        cc.table.size.should eq 30
 
-        cc = CompressionContext.new(:response)
-        cc.table.size.should eq 35
+        cc = EncodingContext.new(:response)
+        cc.table.size.should eq 30
       end
 
       it "should be initialized with empty working set" do
-        @cc.workset.should be_empty
+        @cc.refset.should be_empty
       end
 
       it "should update working set based on prior state" do
-        @cc.update_sets
-        @cc.workset.should be_empty
+        @cc.refset.should be_empty
 
         @cc.process({name: 0, type: :indexed})
-        @cc.update_sets
-        @cc.workset.should eq [[0, [":scheme", "http"]]]
+        @cc.refset.should eq [[0, [":scheme", "http"]]]
 
         @cc.process({name: 0, type: :indexed})
-        @cc.update_sets
-        @cc.workset.should be_empty
+        @cc.refset.should be_empty
       end
 
       context "processing" do
         it "should toggle index representation headers in working set" do
           @cc.process({name: 0, type: :indexed})
-          @cc.workset.first.should eq [0, [":scheme", "http"]]
+          @cc.refset.first.should eq [0, [":scheme", "http"]]
 
           @cc.process({name: 0, type: :indexed})
-          @cc.workset.should be_empty
+          @cc.refset.should be_empty
         end
 
         context "no indexing" do
           it "should process indexed header with literal value" do
             original_table = @cc.table
 
-            @cc.process({name: 3, value: "/path", type: :noindex})
-            @cc.workset.first.should eq [3, [":path", "/path"]]
+            emit = @cc.process({name: 3, value: "/path", type: :noindex})
+            emit.should eq [":path", "/path"]
+            @cc.refset.should be_empty
             @cc.table.should eq original_table
           end
 
           it "should process indexed header with default value" do
             original_table = @cc.table
 
-            @cc.process({name: 3, type: :noindex})
-            @cc.workset.first.should eq [3, [":path", "/"]]
+            emit = @cc.process({name: 3, type: :noindex})
+            emit.should eq [":path", "/"]
             @cc.table.should eq original_table
           end
 
           it "should process literal header with literal value" do
             original_table = @cc.table
 
-            @cc.process({name: "x-custom", value: "random", type: :noindex})
-            @cc.workset.first.should eq [nil, ["x-custom", "random"]]
+            emit = @cc.process({name: "x-custom", value: "random", type: :noindex})
+            emit.should eq ["x-custom", "random"]
+            @cc.refset.should be_empty
             @cc.table.should eq original_table
           end
         end
@@ -185,7 +170,7 @@ describe HTTP2::Header do
             original_table = @cc.table.dup
 
             @cc.process({name: "x-custom", value: "random", type: :incremental})
-            @cc.workset.first.should eq [original_table.size, ["x-custom", "random"]]
+            @cc.refset.first.should eq [original_table.size, ["x-custom", "random"]]
             (@cc.table - original_table).should eq [["x-custom", "random"]]
           end
         end
@@ -200,9 +185,9 @@ describe HTTP2::Header do
               index: idx, type: :substitution
             })
 
-            @cc.workset.first.should eq [idx, ["x-custom", "random"]]
+            @cc.refset.first.should eq [idx, ["x-custom", "random"]]
             (@cc.table - original_table).should eq [["x-custom", "random"]]
-            (original_table - @cc.table).should eq [["warning", ""]]
+            (original_table - @cc.table).should eq [["via", ""]]
           end
 
           it "should raise error on invalid substitution index" do
@@ -217,7 +202,7 @@ describe HTTP2::Header do
 
         context "size bounds" do
           it "should drop headers from beginning of table" do
-            cc = CompressionContext.new(:request, 2048)
+            cc = EncodingContext.new(:request, 2048)
             original_table = cc.table.dup
             original_size = original_table.join.bytesize +
                             original_table.size * 32
@@ -233,7 +218,7 @@ describe HTTP2::Header do
            end
 
           it "should prepend on dropped substitution index" do
-            cc = CompressionContext.new(:request, 2048)
+            cc = EncodingContext.new(:request, 2048)
             original_table = cc.table.dup
             original_size = original_table.join.bytesize +
                             original_table.size * 32
@@ -248,39 +233,54 @@ describe HTTP2::Header do
             cc.table[1][0].should eq ":scheme"
           end
         end
+
+        it "should clear table if entry exceeds table size" do
+          cc = EncodingContext.new(:request, 2048)
+
+          h = { name: "x-custom", value: "a", index: 0, type: :incremental }
+          e = { name: "large", value: "a" * 2048, index: 0}
+
+          cc.process(h)
+          cc.process(e.merge({type: :substitution}))
+          cc.table.should be_empty
+
+          cc.process(h)
+          cc.process(e.merge({type: :incremental}))
+          cc.table.should be_empty
+        end
       end
     end
 
     context "integration" do
-      before (:all) { @cc = CompressionContext.new(:request) }
+      before (:all) { @cc = EncodingContext.new(:request) }
 
       it "should match first header set in spec appendix" do
         req_headers = [
           {name: 3, value: "/my-example/index.html"},
-          {name: 12, value: "my-user-agent"},
-          {name: "x-my-header", value: "first"}
+          {name: 11, value: "my-user-agent"},
+          {name: "mynewheader", value: "first"}
         ]
 
         req_headers.each {|h| @cc.process(h.merge({type: :incremental})) }
 
-        @cc.table[38].should eq [":path", "/my-example/index.html"]
-        @cc.table[39].should eq ["user-agent", "my-user-agent"]
-        @cc.table[40].should eq req_headers[2].values
+        @cc.table[30].should eq [":path", "/my-example/index.html"]
+        @cc.table[31].should eq ["user-agent", "my-user-agent"]
+        @cc.table[32].should eq req_headers[2].values
       end
 
       it "should match second header set in spec appendix" do
-        @cc.process({name: 38, type: :indexed})
-        @cc.process({name: 39, type: :indexed})
+        @cc.process({name: 30, type: :indexed})
+        @cc.process({name: 31, type: :indexed})
         @cc.process({
           name: 3, value: "/my-example/resources/script.js",
-          index: 38, type: :substitution
+          index: 30, type: :substitution
         })
-        @cc.process({name: 40, value: "second", type: :incremental})
+        @cc.process({name: 32, value: "second", type: :incremental})
 
-        @cc.table[38].should eq [":path", "/my-example/resources/script.js"]
-        @cc.table[39].should eq ["user-agent", "my-user-agent"]
-        @cc.table[40].should eq ["x-my-header", "first"]
-        @cc.table[41].should eq ["x-my-header", "second"]
+        @cc.table[30].should eq [":path", "/my-example/resources/script.js"]
+        @cc.table[31].should eq ["user-agent", "my-user-agent"]
+        @cc.table[32].should eq ["mynewheader", "first"]
+        @cc.table[33].should eq ["mynewheader", "second"]
       end
     end
   end
@@ -297,12 +297,12 @@ describe HTTP2::Header do
       0x44, # (literal header with incremental indexing, name index = 3)
       0x16, # (header value string length = 22)
       "/my-example/index.html".bytes,
-      0x4D, # (literal header with incremental indexing, name index = 12)
+      0x4C, # (literal header with incremental indexing, name index = 11)
       0x0D, # (header value string length = 13)
       "my-user-agent".bytes,
       0x40, # (literal header with incremental indexing, new name)
       0x0B, # (header name string length = 11)
-      "x-my-header".bytes,
+      "mynewheader".bytes,
       0x05, # (header value string length = 5)
       "first".bytes
     ].flatten
@@ -310,7 +310,7 @@ describe HTTP2::Header do
     E1_HEADERS = [
       [":path", "/my-example/index.html"],
       ["user-agent", "my-user-agent"],
-      ["x-my-header", "first"]
+      ["mynewheader", "first"]
     ]
 
     it "should match first header set in spec appendix" do
@@ -318,18 +318,18 @@ describe HTTP2::Header do
     end
 
     it "should decode first header set in spec appendix" do
-      @dc.decode(StringIO.new(E1_BYTES.pack("C*"))).should eq E1_HEADERS
+      @dc.decode(Buffer.new(E1_BYTES.pack("C*"))).should eq E1_HEADERS
     end
 
     E2_BYTES = [
-      0xa6, # (indexed header, index = 38: removal from reference set)
-      0xa8, # (indexed header, index = 40: removal from reference set)
+      0x9e, # (indexed header, index = 30: removal from reference set)
+      0xa0, # (indexed header, index = 32: removal from reference set)
       0x04, # (literal header, substitution indexing, name index = 3)
-      0x26, # (replaced entry index = 38)
+      0x1e, # (replaced entry index = 30)
       0x1f, # (header value string length = 31)
       "/my-example/resources/script.js".bytes,
       0x5f,
-      0x0a, # (literal header, incremental indexing, name index = 40)
+      0x02, # (literal header, incremental indexing, name index = 32)
       0x06, # (header value string length = 6)
       "second".bytes
     ].flatten
@@ -337,7 +337,7 @@ describe HTTP2::Header do
     E2_HEADERS = [
       [":path", "/my-example/resources/script.js"],
       ["user-agent", "my-user-agent"],
-      ["x-my-header", "second"]
+      ["mynewheader", "second"]
     ]
 
     it "should match second header set in spec appendix" do
@@ -356,15 +356,15 @@ describe HTTP2::Header do
     end
 
     it "should decode second header set in spec appendix" do
-      @dc.decode(StringIO.new(E2_BYTES.pack("C*"))).should match_array E2_HEADERS
+      @dc.decode(Buffer.new(E2_BYTES.pack("C*"))).should match_array E2_HEADERS
     end
 
     it "encode-decode should be invariant" do
       cc = Compressor.new(:request)
       dc = Decompressor.new(:request)
 
-      E1_HEADERS.should match_array dc.decode(StringIO.new(cc.encode(E1_HEADERS)))
-      E2_HEADERS.should match_array dc.decode(StringIO.new(cc.encode(E2_HEADERS)))
+      E1_HEADERS.should match_array dc.decode(cc.encode(E1_HEADERS))
+      E2_HEADERS.should match_array dc.decode(cc.encode(E2_HEADERS))
     end
 
     it "should encode-decode request set of headers" do
@@ -378,7 +378,16 @@ describe HTTP2::Header do
         ["accept", "*/*"]
       ]
 
-      dc.decode(StringIO.new(cc.encode(req))).should eq req
+      dc.decode(cc.encode(req)).should eq req
+    end
+
+    it "should downcase all request header names" do
+      cc = Compressor.new(:request)
+      dc = Decompressor.new(:request)
+
+      req = [["Accept", "IMAGE/PNG"]]
+      recv = dc.decode(cc.encode(req))
+      recv.should eq [["accept", "IMAGE/PNG"]]
     end
   end
 end