spdy 0.0.2 → 0.0.3

data/.gitignore

@@ -3,3 +3,4 @@
 Gemfile.lock
 pkg/*
 misc.md
+.rvmrc

data/README.md

@@ -4,39 +4,40 @@ SPDY was developed at Google as part of the "let's make the web faster" initiati
 
 Today, SPDY is built into Chrome + Google web-server infrastructure and is currently serving over 90% of all the SSL traffic. Yes, you read that right.. If you're using Chrome, and you're using Google products, chances are, you are fetching the content from Google servers over SPDY, not HTTP.
 
-See: [Life beyond HTTP 1.1: Google's SPDY](http://www.igvita.com/2011/04/07/life-beyond-http-11-googles-spdy)
+* [Life beyond HTTP 1.1: Google's SPDY](http://www.igvita.com/2011/04/07/life-beyond-http-11-googles-spdy)
+* [How to set up ruby, eventmachine and spdy to use NPN](https://gist.github.com/944386)
 
 ## Protocol Parser
 
 SPDY specification (Draft 2) defines its own framing and message exchange protocol which is layered on top of a raw TCP/SSL connection. This gem implements a basic, pure Ruby parser for the SPDY protocol:
 
-    s = SPDY::Parser.new
+```ruby
+s = SPDY::Parser.new
 
-    s.on_headers_complete { |stream_id, associated_stream, priority, headers| ... }
-    s.on_body             { |stream_id, data| ... }
-    s.on_message_complete { |stream_id| ... }
+s.on_headers_complete { |stream_id, associated_stream, priority, headers| ... }
+s.on_body             { |stream_id, data| ... }
+s.on_message_complete { |stream_id| ... }
 
-    s << recieved_data
+s << recieved_data
+```
 
 However, parsing the data is not enough, to do the full exchange you also have to respond to a SPDY client with appropriate 'control' and 'data' frames:
 
-    sr = SPDY::Protocol::Control::SynReply.new
-    headers = {'Content-Type' => 'text/plain', 'status' => '200 OK', 'version' => 'HTTP/1.1'}
-    sr.create(:stream_id => 1, :headers => headers)
-    send_data sr.to_binary_s
+```ruby
+sr = SPDY::Protocol::Control::SynReply.new
+headers = {'Content-Type' => 'text/plain', 'status' => '200 OK', 'version' => 'HTTP/1.1'}
+sr.create(:stream_id => 1, :headers => headers)
+send_data sr.to_binary_s
 
-    # or, to send a data frame
+# or, to send a data frame
 
-    d = SPDY::Protocol::Data::Frame.new
-    d.create(:stream_id => 1, :data => "This is SPDY.")
-    send_data d.to_binary_s
+d = SPDY::Protocol::Data::Frame.new
+d.create(:stream_id => 1, :data => "This is SPDY.")
+send_data d.to_binary_s
+```
 
 See example eventmachine server in *examples/spdy_server.rb* for a minimal SPDY "hello world" server.
 
-## Todo:
-
-- implement support for all [control frames](https://sites.google.com/a/chromium.org/dev/spdy/spdy-protocol/spdy-protocol-draft2#TOC-Control-frames1)
-
 ### License
 
-(MIT License) - Copyright (c) 2011 Ilya Grigorik
+MIT License - Copyright (c) 2011 Ilya Grigorik

data/examples/spdy_server.rb

@@ -9,21 +9,21 @@ class SPDYHandler < EM::Connection
     @parser.on_headers_complete do |stream_id, associated_stream, priority, headers|
       p [:SPDY_HEADERS, headers]
 
-      sr = SPDY::Protocol::Control::SynReply.new
+      sr = SPDY::Protocol::Control::SynReply.new({:zlib_session => @parser.zlib_session})
       h = {'Content-Type' => 'text/plain', 'status' => '200 OK', 'version' => 'HTTP/1.1'}
-      sr.create(:stream_id => 1, :headers => h)
+      sr.create({:stream_id => stream_id, :headers => h})
       send_data sr.to_binary_s
 
       p [:SPDY, :sent, :SYN_REPLY]
 
       d = SPDY::Protocol::Data::Frame.new
-      d.create(:stream_id => 1, :data => "This is SPDY.")
+      d.create(:stream_id => stream_id, :data => "This is SPDY.")
       send_data d.to_binary_s
 
       p [:SPDY, :sent, :DATA]
 
       d = SPDY::Protocol::Data::Frame.new
-      d.create(:stream_id => 1, :flags => 1)
+      d.create(:stream_id => stream_id, :flags => 1)
       send_data d.to_binary_s
 
       p [:SPDY, :sent, :DATA_FIN]
@@ -38,6 +38,7 @@ class SPDYHandler < EM::Connection
 
   def unbind
     p [:SPDY, :connection_closed]
+    @parser.zlib_session.reset
   end
 end
 
@@ -51,4 +52,4 @@ end
 # (2) start Chrome and force it to use SPDY over SSL.. on OSX:
 # > /Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --use-spdy=ssl
 #
-# (3) visit https://localhost:1000/
+# (3) visit https://localhost:10000/

data/lib/spdy.rb

@@ -1,6 +1,7 @@
 require 'bindata'
 require 'ffi/zlib'
 
+require 'spdy/compat'
 require 'spdy/protocol'
 require 'spdy/compressor'
-require 'spdy/parser'
+require 'spdy/parser'

data/lib/spdy/compat.rb

@@ -0,0 +1,17 @@
+if Object.instance_methods.include? "type"
+  class BinData::DSLMixin::DSLParser
+    def name_is_reserved_in_1_8?(name)
+      return false if name == "type"
+      name_is_reserved_in_1_9?(name)
+    end
+    alias_method :name_is_reserved_in_1_9?, :name_is_reserved?
+    alias_method :name_is_reserved?, :name_is_reserved_in_1_8?
+
+    def name_shadows_method_in_1_8?(name)
+      return false if name == "type"
+      name_shadows_method_in_1_9?(name)
+    end
+    alias_method :name_shadows_method_in_1_9?, :name_shadows_method?
+    alias_method :name_shadows_method?, :name_shadows_method_in_1_8?
+  end
+end

data/lib/spdy/compressor.rb

@@ -1,5 +1,5 @@
 module SPDY
-  module Zlib
+  class Zlib
 
     DICT = \
       "optionsgetheadpostputdeletetraceacceptaccept-charsetaccept-encodingaccept-" \
@@ -18,51 +18,62 @@ module SPDY
 
     CHUNK = 10*1024 # this is silly, but it'll do for now
 
-    def self.inflate(data)
-      in_buf  = FFI::MemoryPointer.from_string(data)
-      out_buf = FFI::MemoryPointer.new(CHUNK)
-
-      zstream = FFI::Zlib::Z_stream.new
-      zstream[:avail_in]  = in_buf.size
-      zstream[:avail_out] = CHUNK
-      zstream[:next_in]   = in_buf
-      zstream[:next_out]  = out_buf
-
-      result = FFI::Zlib.inflateInit(zstream)
+    def initialize
+      @inflate_zstream = FFI::Zlib::Z_stream.new
+      result = FFI::Zlib.inflateInit(@inflate_zstream)
       raise "invalid stream" if result != FFI::Zlib::Z_OK
 
-      result = FFI::Zlib.inflate(zstream, FFI::Zlib::Z_SYNC_FLUSH)
-      raise "invalid stream" if result != FFI::Zlib::Z_NEED_DICT
+      @deflate_zstream = FFI::Zlib::Z_stream.new
+      result = FFI::Zlib.deflateInit(@deflate_zstream, FFI::Zlib::Z_DEFAULT_COMPRESSION)
+      raise "invalid stream" if result != FFI::Zlib::Z_OK
 
-      result = FFI::Zlib.inflateSetDictionary(zstream, DICT, DICT.size)
+      result = FFI::Zlib.deflateSetDictionary(@deflate_zstream, DICT, DICT.size)
       raise "invalid dictionary" if result != FFI::Zlib::Z_OK
+    end
 
-      result = FFI::Zlib.inflate(zstream, FFI::Zlib::Z_SYNC_FLUSH)
-      raise "cannot inflate" if result != FFI::Zlib::Z_OK
+    def reset
+      result = FFI::Zlib.inflateReset(@inflate_zstream)
+      raise "invalid stream" if result != FFI::Zlib::Z_OK
 
-      out_buf.get_bytes(0, zstream[:total_out])
+      result = FFI::Zlib.deflateReset(@deflate_zstream)
+      raise "invalid stream" if result != FFI::Zlib::Z_OK
     end
 
-    def self.deflate(data)
+    def inflate(data)
       in_buf  = FFI::MemoryPointer.from_string(data)
       out_buf = FFI::MemoryPointer.new(CHUNK)
 
-      zstream = FFI::Zlib::Z_stream.new
-      zstream[:avail_in]  = in_buf.size-1
-      zstream[:avail_out] = CHUNK
-      zstream[:next_in]   = in_buf
-      zstream[:next_out]  = out_buf
+      @inflate_zstream[:avail_in]  = in_buf.size-1
+      @inflate_zstream[:avail_out] = CHUNK
+      @inflate_zstream[:next_in]   = in_buf
+      @inflate_zstream[:next_out]  = out_buf
 
-      result = FFI::Zlib.deflateInit(zstream, -1)
-      raise "invalid stream" if result != FFI::Zlib::Z_OK
+      result = FFI::Zlib.inflate(@inflate_zstream, FFI::Zlib::Z_SYNC_FLUSH)
+      if result == FFI::Zlib::Z_NEED_DICT
+        result = FFI::Zlib.inflateSetDictionary(@inflate_zstream, DICT, DICT.size)
+        raise "invalid dictionary" if result != FFI::Zlib::Z_OK
+  
+        result = FFI::Zlib.inflate(@inflate_zstream, FFI::Zlib::Z_SYNC_FLUSH)
+      end
 
-      result = FFI::Zlib.deflateSetDictionary(zstream, DICT, DICT.size)
-      raise "invalid dictionary" if result != FFI::Zlib::Z_OK
+      raise "cannot inflate" if result != FFI::Zlib::Z_OK && result != FFI::Zlib::Z_STREAM_END
+
+      out_buf.get_bytes(0, CHUNK - @inflate_zstream[:avail_out])
+    end
+
+    def deflate(data)
+      in_buf  = FFI::MemoryPointer.from_string(data)
+      out_buf = FFI::MemoryPointer.new(CHUNK)
+
+      @deflate_zstream[:avail_in]  = in_buf.size-1
+      @deflate_zstream[:avail_out] = CHUNK
+      @deflate_zstream[:next_in]   = in_buf
+      @deflate_zstream[:next_out]  = out_buf
 
-      result = FFI::Zlib.deflate(zstream, FFI::Zlib::Z_SYNC_FLUSH)
+      result = FFI::Zlib.deflate(@deflate_zstream, FFI::Zlib::Z_SYNC_FLUSH)
       raise "cannot deflate" if result != FFI::Zlib::Z_OK
 
-      out_buf.get_bytes(0, zstream[:total_out])
+      out_buf.get_bytes(0, CHUNK - @deflate_zstream[:avail_out])
     end
   end
 end

data/lib/spdy/parser.rb

@@ -2,8 +2,11 @@ module SPDY
   class Parser
     include Protocol
 
+    attr :zlib_session
+
     def initialize
       @buffer = ''
+      @zlib_session = Zlib.new
     end
 
     def <<(data)
@@ -30,7 +33,7 @@ module SPDY
 
         headers = {}
         if pckt.data.size > 0
-          data = Zlib.inflate(pckt.data.to_s)
+          data = @zlib_session.inflate(pckt.data.to_s)
           headers = NV.new.read(data).to_h
         end
 
@@ -53,19 +56,21 @@ module SPDY
 
             case pckt.type.to_i
               when 1 then # SYN_STREAM
-                pckt = Control::SynStream.new
+                pckt = Control::SynStream.new({:zlib_session => @zlib_session})
                 unpack_control(pckt, @buffer)
 
+                @on_message_complete.call(pckt.header.stream_id) if @on_message_complete && fin?(pckt.header)
+
               when 2 then # SYN_REPLY
-                pckt = Control::SynReply.new
+                pckt = Control::SynReply.new({:zlib_session => @zlib_session})
                 unpack_control(pckt, @buffer)
 
+                @on_message_complete.call(pckt.header.stream_id) if @on_message_complete && fin?(pckt.header)
+
               else
                 raise 'invalid control frame'
             end
 
-            @on_message_complete.call(pckt.header.stream_id) if @on_message_complete && fin?(pckt.header)
-
           when DATA_BIT
             return if @buffer.size < 8
 

data/lib/spdy/protocol.rb

@@ -5,13 +5,24 @@ module SPDY
     DATA_BIT    = 0
     VERSION     = 2
 
+    SETTINGS_UPLOAD_BANDWIDTH = 1
+    SETTINGS_DOWNLOAD_BANDWIDTH = 2
+    SETTINGS_ROUND_TRIP_TIME = 3
+    SETTINGS_MAX_CONCURRENT_STREAMS = 4
+    SETTINGS_CURRENT_CWND = 5
+
     module Control
       module Helpers
+        def initialize_instance
+          super
+          @zlib_session = @params[:zlib_session]
+        end
+
         def parse(chunk)
           head = Control::Header.new.read(chunk)
           self.read(chunk)
 
-          data = Zlib.inflate(self.data.to_s)
+          data = @zlib_session.inflate(self.data.to_s)
           self.uncompressed_data = NV.new.read(data)
           self
         end
@@ -26,7 +37,7 @@ module SPDY
           nv = SPDY::Protocol::NV.new
           nv.create(opts[:headers])
 
-          nv = SPDY::Zlib.deflate(nv.to_binary_s)
+          nv = @zlib_session.deflate(nv.to_binary_s)
           self.header.len = self.header.len.to_i + nv.size
 
           self.data = nv
@@ -82,6 +93,121 @@ module SPDY
           build({:type => 2, :len => 6}.merge(opts))
         end
       end
+
+      class RstStream < BinData::Record
+        hide :u1
+
+        bit1 :frame, :initial_value => CONTROL_BIT
+        bit15 :version, :initial_value => VERSION
+        bit16 :type, :value => 3
+
+        bit8 :flags, :value => 0
+        bit24 :len, :value => 8
+
+        bit1  :u1
+        bit31 :stream_id
+
+        bit32 :status_code
+
+        def parse(chunk)
+          self.read(chunk)
+          self
+        end
+
+        def create(opts = {})
+          self.stream_id = opts.fetch(:stream_id, 1)
+          self.status_code = opts.fetch(:status_code, 5)
+          self
+        end
+      end
+
+      class Settings < BinData::Record
+        bit1 :frame, :initial_value => CONTROL_BIT
+        bit15 :version, :initial_value => VERSION
+        bit16 :type, :value => 4
+
+        bit8 :flags
+        bit24 :len, :value => lambda { pairs * 8 }
+        bit32 :pairs
+
+        array :headers, :initial_length => :pairs do
+          bit32 :id_data
+          bit32 :value_data
+        end
+
+        def parse(chunk)
+          self.read(chunk)
+          self
+        end
+
+        def create(opts = {})
+          opts.each do |k, v|
+            key = SPDY::Protocol.const_get(k.to_s.upcase)
+            self.headers << { :id_data =>  key , :value_data => v }
+          end
+          self.pairs = opts.size
+          self
+        end
+      end
+
+      class Ping < BinData::Record
+        bit1 :frame, :initial_value => CONTROL_BIT
+        bit15 :version, :initial_value => VERSION
+        bit16 :type, :value => 6
+
+        bit8 :flags, :value => 0
+        bit24 :len, :value => 4
+
+        bit32 :ping_id
+
+        def parse(chunk)
+          self.read(chunk)
+          self
+        end
+
+        def create(opts = {})
+          self.ping_id = opts.fetch(:ping_id, 1)
+          self
+        end
+      end
+
+      class Goaway < BinData::Record
+        hide :u1
+
+        bit1 :frame, :initial_value => CONTROL_BIT
+        bit15 :version, :initial_value => VERSION
+        bit16 :type, :value => 7
+
+        bit8 :flags, :value => 0
+        bit24 :len, :value => 4
+
+        bit1 :u1
+        bit31 :stream_id
+
+        def parse(chunk)
+          self.read(chunk)
+          self
+        end
+
+        def create(opts = {})
+          self.stream_id = opts.fetch(:stream_id, 1)
+          self
+        end
+      end
+
+
+      class Headers < BinData::Record
+        attr_accessor :uncompressed_data
+        include Helpers
+
+        header :header
+        bit16 :unused
+        string :data, :read_length => lambda { header.len - 6 }
+
+        def create(opts = {})
+          build({:type => 8, :len => 6}.merge(opts))
+        end
+      end
     end
 
     module Data

data/lib/spdy/version.rb

@@ -1,3 +1,3 @@
 module Spdy
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/compressor_spec.rb

@@ -2,13 +2,24 @@ require 'helper'
 
 describe SPDY::Zlib do
   it "should inflate header with custom dictionary" do
-    SPDY::Zlib.inflate(COMPRESSED_HEADER).should match('HTTP/1.1')
+    zlib_session = SPDY::Zlib.new
+    zlib_session.inflate(COMPRESSED_HEADER).should match('HTTP/1.1')
   end
 
   it "should deflate header with custom dictionary" do
-    orig = SPDY::Zlib.inflate(COMPRESSED_HEADER)
-    rinse = SPDY::Zlib.inflate(SPDY::Zlib.deflate(orig))
+    zlib_session = SPDY::Zlib.new
 
+    orig = zlib_session.inflate(COMPRESSED_HEADER)
+    zlib_session.reset
+
+    rinse = zlib_session.inflate(zlib_session.deflate(orig))
     orig.should == rinse
   end
-end
+
+  it "can deflate multiple packets" do
+    zlib_session = SPDY::Zlib.new
+
+    zlib_session.inflate(COMPRESSED_HEADER_1)
+    zlib_session.inflate(COMPRESSED_HEADER_2).should == UNCOMPRESSED_HEADER_2
+  end
+end

data/spec/helper.rb

@@ -3,13 +3,29 @@ require 'spdy'
 
 COMPRESSED_HEADER = "8\xEA\xDF\xA2Q\xB2b\xE0f`\x83\xA4\x17\x86(4\xDBu0\xAC\xD7\x06\x89\xC2\xFDa]hk\xA0g\xA9\x83p\x13X\xC0B\a\xEE?\x1D-}-\xB0\x98)\x03\x1Fjff\x90\xF3\f\xF6\x87:U\a\xECV\xB0:s\x1D\x88zc\x06~\xB4\xEC\xCE \b\xF2\x8C\x0E\xD47:\xC5)\xC9\x19p5\xB0\x14\xC2\xC0\x97\x9A\xA7\e\x1A\xAC\x93\nu\b\x03\e$V\x19Z\x8A\x8D\x8C\xD3\xD2u\x8D\v\x8C\xCC\x8D\x92\v,\xCB\r\xE2\x8Bl\xCD\xAD\x15\f\xB3\xCD\v\xCDu3\rR\xCC\xD3\x8B\v\r-\xCC\x81\xA2\x06\xD6\n\xF1 '\x96$\xA5&\x96\x18\x01d[\x9Cj\x9CUQ\x92dT\x99e\x9C\x9A\x93\x93j\f\x94\x8D//)\x8F/\xCB,\x8E\afy[k\x85\xB2\xC4\xBC\xCC\x92\xCA\xF8\xCC\x14\xDB4c#\x8B\xE4$3\x13c\x93d`\xFEM12N154OI32O\x03\x16\x04\xA6\x96I\f,\xA0\xC2\x88\x81\x0F\x94bs@L+K\x03\x03\x03\x06\xB6\\`!\x98\x9F\xC2\xC0\xEC\xEE\x1A\xC2\xC0V\f\xCC7\xB9\xA9\f\xAC\x19%%\x05\xC5\f\xCC\xA0\bb\xD4g\xE0B\x94*\fe\xBE\xF9U\x9999\x89\xFA\xA6z\x06\x00)h\xF8&&g\xE6\x95\xE4\x17gX+x\x02\x13z\x8E\x02P@\xC1?X!B\xC1\xD0 \xDE,\xDE\\S\xC1\x11\x18\x87\xA9\xE1\xA9I\xDE\x99%\xFA\xA6\xC6&zF&\n\x1A\xDE\x1E!\xBE>:\n9\x99\xD9\xA9\n\xEE\xA9\xC9\xD9\xF9\x9A\n\xCE\x19\xC0\xD22U\xDF\xD0P\xCF@\xCF\xCC\xD2L\xCF\xC8B!81-\xB1(\x13\xAA\x89\x81\x1D\x9Af\x188`I\t\x00\x00\x00\xFF\xFF"
 
+COMPRESSED_HEADER_1 = "8\xEA\xDF\xA2Q\xB2b\xE0b`\x83\xA4\x17\x06{\xB8\vu0,\xD6\xAE@\x17\xCD\xCD\xB1.\xB45\xD0\xB3\xD4\xD1\xD2\xD7\x02\xB3,\x18\xF8Ps,\x83\x9Cg\xB0?\xD4=:`\a\x81\xD5\x99\xEB@\xD4\e3\xF0\xA3\xE5i\x06A\x90\x8Bu\xA0N\xD6)NI\xCE\x80\xAB\x81%\x03\x06\xBE\xD4<\xDD\xD0`\x9D\xD4<\xA8\xA5,\xA0<\xCE\xC0\x0FJ\b9 \xA6\x150\xE3\x19\x180\xB0\xE5\x02\v\x97\xFC\x14\x06fw\xD7\x10\x06\xB6b`z\xCCMe`\xCD())(f`\x06y\x9CQ\x9F\x81\v\x91[\x19\xD2}\xF3\xAB2sr\x12\xF5M\xF5\f\x144\x00\x8A04\xB4V\xF0\xC9\xCC+\xADP\xA8\xB00\x8B73\xD1Tp\x04z>5<5\xC9;\xB3D\xDF\xD4\xD8D\xCF\x18\xA8\xCC\xDB#\xC4\xD7GG!'3;U\xC1=59;_S\xC19\x03X\xEC\xA4\xEA\e\x1A\xE9\x01}jb\x04R\x16\x9C\x98\x96X\x94\t\xD5\xC4\xC0\x0E\r|\x06\x0EX\x9C\x00\x00\x00\x00\xFF\xFF"
+
+COMPRESSED_HEADER_2 = "B\x8A\x02f``\x0E\xAD`\xE4\xD1OK,\xCB\x04f3= 1XB\x14\x00\x00\x00\xFF\xFF"
+
+UNCOMPRESSED_HEADER_1 = "\x00\n\x00\x06accept\x00?text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\x00\x0eaccept-charset\x00\x1eISO-8859-1,utf-8;q=0.7,*;q=0.3\x00\x0faccept-encoding\x00\x11gzip,deflate,sdch\x00\x0faccept-language\x00\x0een-US,en;q=0.8\x00\x04host\x00\x0flocalhost:10000\x00\x06method\x00\x03GET\x00\x06scheme\x00\x05https\x00\x03url\x00\x01/\x00\nuser-agent\x00gMozilla/5.0 (X11; Linux x86_64) AppleWebKit/534.30 (KHTML, like Gecko) Chrome/12.0.742.30 Safari/534.30\x00\x07version\x00\x08HTTP/1.1"
+
+UNCOMPRESSED_HEADER_2 = "\x00\n\x00\x06accept\x00\x03*/*\x00\x0eaccept-charset\x00\x1eISO-8859-1,utf-8;q=0.7,*;q=0.3\x00\x0faccept-encoding\x00\x11gzip,deflate,sdch\x00\x0faccept-language\x00\x0een-US,en;q=0.8\x00\x04host\x00\x0flocalhost:10000\x00\x06method\x00\x03GET\x00\x06scheme\x00\x05https\x00\x03url\x00\x0c/favicon.ico\x00\nuser-agent\x00gMozilla/5.0 (X11; Linux x86_64) AppleWebKit/534.30 (KHTML, like Gecko) Chrome/12.0.742.30 Safari/534.30\x00\x07version\x00\x08HTTP/1.1"
+
 SYN_STREAM = "\x80\x02\x00\x01\x01\x00\x01E\x00\x00\x00\x01\x00\x00\x00\x00\x00\x008\xEA\xDF\xA2Q\xB2b\xE0f`\x83\xA4\x17\x86(4\xDBu0\xAC\xD7\x06\x89\xC2\xFDa]hk\xA0g\xA9\x83p\x13X\xC0B\a\xEE?\x1D-}-\xB0\x98)\x03\x1Fjff\x90\xF3\f\xF6\x87:U\a\xECV\xB0:s\x1D\x88zc\x06~\xB4\xEC\xCE \b\xF2\x8C\x0E\xD47:\xC5)\xC9\x19p5\xB0\x14\xC2\xC0\x97\x9A\xA7\e\x1A\xAC\x93\nu\b\x03/J:d\xE0\x84\x86\x96\xAD\x01\x03\v\xA8``\xE0342\xD73\x00BC+K\x03\x03\x03\x06\xB6\\`\x81\x94\x9F\xC2\xC0\xEC\xEE\x1A\xC2\xC0V\f\xD4\x9B\x9B\xCA\xC0\x9AQRRP\xCC\xC0\f\n,\x11}{\x80\x80a\x9Do\x9B\xA8\x06,\x10\x80\xC5\x86mVq~\x1E\x03\x17\"\xD33\x94\xF9\xE6We\xE6\xE4$\xEA\x9B\xEA\x19(h\xF8&&g\xE6\x95\xE4\x17gX+x\x02\xD3a\x8E\x02P@\xC1?X!B\xC1\xD0 \xDE,\xDE\\S\xC1\x11\x18\xC4\xA9\xE1\xA9I\xDE\x99%\xFA\xA6\xC6&zF&\n\x1A\xDE\x1E!\xBE>:\n9\x99\xD9\xA9\n\xEE\xA9\xC9\xD9\xF9\x9A\n\xCE\x19\xC0\xC2,U\xDF\xD0\x10\xE8X3K3=#\v\x85\xE0\xC4\xB4\xC4\xA2L\xA8&\x06vh\x942p\xC0b\x1A\x00\x00\x00\xFF\xFF"
 
 SYN_REPLY = "\x80\x02\x00\x02\x00\x00\x005\x00\x00\x00\x01\x00\x00x\xbb\xdf\xa2Q\xb2b`f\xe0q\x86\x06R\x080\x90\x18\xb8\x10v0\xb0A\x943\xb0\x01\x93\xb1\x82\xbf7\x03;T#\x03\x07\xcc<\x00\x00\x00\x00\xff\xff"
 
 RST_STREAM = "\x80\x02\x00\x03\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\x00\x01"
 
+SETTINGS = "\x80\x02\x00\x04\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x01,"
+
 DATA = "\x00\x00\x00\x01\x00\x00\x00\rThis is SPDY."
 DATA_FIN = "\x00\x00\x00\x01\x01\x00\x00\x00"
 
-NV = "\x00\x03\x00\x0cContent-Type\x00\ntext/plain\x00\x06status\x00\x06200 OK\x00\x07version\x00\x08HTTP/1.1"
+NV = "\x00\x03\x00\x0cContent-Type\x00\ntext/plain\x00\x06status\x00\x06200 OK\x00\x07version\x00\x08HTTP/1.1"
+
+PING = "\x80\x02\x00\x06\x00\x00\x00\x04\x00\x00\x00\x01"
+
+GOAWAY = "\x80\x02\x00\x07\x00\x00\x00\x04\x00\x00\x00\x01"
+
+HEADERS = "\x80\x02\x00\x08\x01\x00\x01A\x00\x00\x00\x01\x00\x008\xEA\xDF\xA2Q\xB2b\xE0f`\x83\xA4\x17\x86(4\xDBu0\xAC\xD7\x06\x89\xC2\xFDa]hk\xA0g\xA9\x83p\x13X\xC0B\a\xEE?\x1D-}-\xB0\x98)\x03\x1Fjff\x90\xF3\f\xF6\x87:U\a\xECV\xB0:s\x1D\x88zc\x06~\xB4\xEC\xCE \b\xF2\x8C\x0E\xD47:\xC5)\xC9\x19p5\xB0\x14\xC2\xC0\x97\x9A\xA7\e\x1A\xAC\x93\nu\b\x03/J:d\xE0\x84\x86\x96\xAD\x01\x03\v\xA8``\xE0342\xD73\x00BC+K\x03\x03\x03\x06\xB6\\`\x81\x94\x9F\xC2\xC0\xEC\xEE\x1A\xC2\xC0V\f\xD4\x9B\x9B\xCA\xC0\x9AQRRP\xCC\xC0\f\n,\x11}{\x80\x80a\x9Do\x9B\xA8\x06,\x10\x80\xC5\x86mVq~\x1E\x03\x17\"\xD33\x94\xF9\xE6We\xE6\xE4$\xEA\x9B\xEA\x19(h\xF8&&g\xE6\x95\xE4\x17gX+x\x02\xD3a\x8E\x02P@\xC1?X!B\xC1\xD0 \xDE,\xDE\\S\xC1\x11\x18\xC4\xA9\xE1\xA9I\xDE\x99%\xFA\xA6\xC6&zF&\n\x1A\xDE\x1E!\xBE>:\n9\x99\xD9\xA9\n\xEE\xA9\xC9\xD9\xF9\x9A\n\xCE\x19\xC0\xC2,U\xDF\xD0\x10\xE8X3K3=#\v\x85\xE0\xC4\xB4\xC4\xA2L\xA8&\x06vh\x942p\xC0b\x1A\x00\x00\x00\xFF\xFF"

data/spec/protocol_spec.rb

@@ -1,109 +1,404 @@
 require 'helper'
 
 describe SPDY::Protocol do
+  context "data frames" do
+    describe "DATA" do
+      it "should create a data frame" do
+        data = "This is SPDY."
 
-  context "NV" do
-    it "should create an NV packet" do
-      nv = SPDY::Protocol::NV.new
-      nv.create({'Content-Type' => 'text/plain', 'status' => '200 OK', 'version' => 'HTTP/1.1'})
+        d = SPDY::Protocol::Data::Frame.new
+        d.create(:stream_id => 1, :data => data)
+
+        d.to_binary_s.should == DATA
+      end
+
+      it "should create a FIN data frame" do
+        d = SPDY::Protocol::Data::Frame.new
+        d.create(:stream_id => 1, :flags => 1)
+
+        d.to_binary_s.should == DATA_FIN
+      end
+
+      it "should read a FIN data frame" do
+        d = SPDY::Protocol::Data::Frame.new
+        d.create(:stream_id => 1, :flags => 1)
+
+        d.to_binary_s.should == DATA_FIN
+        pckt = SPDY::Protocol::Data::Frame.new.read(d.to_binary_s)
+        pckt.flags.should == 1
+      end
 
-      nv.to_binary_s.should == NV
     end
   end
 
-  context "SYN_STREAM" do
-    it "should create a SYN_STREAM packet" do
-      sr = SPDY::Protocol::Control::SynStream.new
+  context "control frames" do
+    describe "SYN_STREAM" do
+      it "should create a SYN_STREAM packet" do
+        zlib_session = SPDY::Zlib.new
 
-      headers = {
-        "accept"=>"application/xml", "host"=>"127.0.0.1:9000",
-        "method"=>"GET", "scheme"=>"https",
-        "url"=>"/?echo=a&format=json","version"=>"HTTP/1.1"
-      }
+        sr = SPDY::Protocol::Control::SynStream.new({:zlib_session => zlib_session})
 
-      sr.create(:stream_id => 1, :headers => headers)
-      sr.header.version.should == 2
-      sr.pri.should == 0
+        headers = {
+          "accept"=>"application/xml", "host"=>"127.0.0.1:9000",
+          "method"=>"GET", "scheme"=>"https",
+          "url"=>"/?echo=a&format=json","version"=>"HTTP/1.1"
+        }
 
-      sr.header.len.should > 50
-      sr.data.should_not be_nil
+        sr.create({:stream_id => 1, :headers => headers})
+        sr.header.version.should == 2
+        sr.pri.should == 0
 
-      st = SPDY::Protocol::Control::SynStream.new
-      st.parse(sr.to_binary_s)
-      st.num_bytes.should == sr.to_binary_s.size
-    end
+        sr.header.len.should > 50
+        sr.data.should_not be_nil
 
-    it "should parse SYN_STREAM packet" do
-      sr = SPDY::Protocol::Control::SynStream.new
-      sr.parse(SYN_STREAM)
+        st = SPDY::Protocol::Control::SynStream.new({:zlib_session => zlib_session})
+        st.parse(sr.to_binary_s)
+        st.num_bytes.should == sr.to_binary_s.size
+      end
 
-      sr.num_bytes.should == SYN_STREAM.size
+      it "should parse SYN_STREAM packet" do
+        zlib_session = SPDY::Zlib.new
 
-      sr.header.type.should == 1
-      sr.uncompressed_data.to_h.class.should == Hash
-      sr.uncompressed_data.to_h['method'].should == 'GET'
+        sr = SPDY::Protocol::Control::SynStream.new({:zlib_session => zlib_session})
+        sr.parse(SYN_STREAM)
 
-      sr.to_binary_s.should == SYN_STREAM
+        sr.num_bytes.should == SYN_STREAM.size
+
+        sr.header.type.should == 1
+        sr.uncompressed_data.to_h.class.should == Hash
+        sr.uncompressed_data.to_h['method'].should == 'GET'
+
+        sr.to_binary_s.should == SYN_STREAM
+      end
     end
-  end
 
-  context "SYN_REPLY" do
-    it "should create a SYN_REPLY packet" do
-      sr = SPDY::Protocol::Control::SynReply.new
+    describe "SYN_REPLY" do
+      describe "creating a packet" do
+        before do
+          zlib_session = SPDY::Zlib.new
+
+          @sr = SPDY::Protocol::Control::SynReply.new({:zlib_session => zlib_session})
+
+          headers = {'Content-Type' => 'text/plain', 'status' => '200 OK', 'version' => 'HTTP/1.1'}
+          @sr.create({:stream_id => 1, :headers => headers})
+        end
 
-      headers = {'Content-Type' => 'text/plain', 'status' => '200 OK', 'version' => 'HTTP/1.1'}
-      sr.create(:stream_id => 1, :headers => headers)
+        describe "common control frame fields" do
+          it "is version 2" do
+            @sr.header.version.should == 2
+          end
+          it "is type 2" do
+            @sr.header.type.should == 2
+          end
+          it "has empty flags" do
+            @sr.header.flags.should == 0
+          end
+        end
 
-      sr.header.version.should == 2
-      sr.header.stream_id.should == 1
+        describe "type specific frame fields" do
+          it "has a stream id" do
+            @sr.header.stream_id.should == 1
+          end
+          it "has data" do
+            @sr.data.should_not be_nil
+          end
+          specify { @sr.header.len.should > 50 }
+        end
 
-      sr.header.len.should > 50
-      sr.data.should_not be_nil
+        describe "assembled packet" do
+          before do
+            @packet = @sr.to_binary_s
+          end
 
-      sr.to_binary_s.should == SYN_REPLY
+          specify "starts with a control bit" do
+            @packet[0...1].should == "\x80"
+          end
+          specify "followed by the version" do
+            @packet[1...2].should == "\x02"
+          end
+          specify "followed by the type" do
+            @packet[2..3].should == "\x00\x02"
+          end
+          specify "followed by flags" do
+            @packet[4...5].should == "\x00"
+          end
+          specify "followed by the length" do
+            @packet[5..7].should == "\x00\x005"
+          end
+          specify "followed by the stream ID" do
+            @packet[8..11].should == "\x00\x00\x00\x01"
+          end
+          specify "followed by unused space" do
+            @packet[12..13].should == "\x00\x00"
+          end
+          specify "followed by compressed NV data" do
+            zlib_session = SPDY::Zlib.new
+
+            data = zlib_session.inflate(@packet[14..-1].to_s)
+            data.should =~ %r{\x00\x0cContent-Type}
+          end
+        end
+
+      end
+
+      it "should parse SYN_REPLY packet" do
+        zlib_session = SPDY::Zlib.new
+
+        sr = SPDY::Protocol::Control::SynReply.new({:zlib_session => zlib_session})
+        sr.parse(SYN_REPLY)
+
+        sr.header.type.should == 2
+        sr.uncompressed_data.to_h.class.should == Hash
+        sr.uncompressed_data.to_h['status'].should == '200 OK'
+
+        sr.to_binary_s.should == SYN_REPLY
+      end
     end
 
-    it "should parse SYN_REPLY packet" do
-      sr = SPDY::Protocol::Control::SynReply.new
-      sr.parse(SYN_REPLY)
+    describe "RST_STREAM" do
+      it "can parse a reset packet" do
+        ping = SPDY::Protocol::Control::RstStream.new
+        ping.parse(RST_STREAM)
 
-      sr.header.type.should == 2
-      sr.uncompressed_data.to_h.class.should == Hash
-      sr.uncompressed_data.to_h['status'].should == '200 OK'
+        ping.stream_id.should == 1
+        ping.type.should == 3
 
-      sr.to_binary_s.should == SYN_REPLY
+        ping.to_binary_s.should == RST_STREAM
+      end
+
+      describe "the assembled packet" do
+        before do
+          @rs = SPDY::Protocol::Control::RstStream.new
+          @rs.create(:stream_id => 1, :status_code => 1)
+          @frame = Array(@rs.to_binary_s.bytes)
+        end
+        specify "starts with a control bit" do
+          @frame[0].should == 128
+        end
+        specify "followed by the version (2)" do
+          @frame[1].should == 2
+        end
+        specify "followed by the type (3)" do
+          @frame[2..3].should == [0,3]
+        end
+        specify "followed by flags (0)" do
+          @frame[4].should == 0
+        end
+        specify "followed by the length (always 8)" do
+          @frame[5..7].should == [0,0,8]
+        end
+        specify "followed by the status code" do
+          @frame[8..11].should == [0,0,0,1]
+        end
+      end
     end
-  end
 
-  context "DATA" do
-    it "should create a data frame" do
-      data = "This is SPDY."
+    describe "SETTINGS" do
+      it "can parse a SETTINGS packet" do
+        settings = SPDY::Protocol::Control::Settings.new
+        settings.parse(SETTINGS)
+
+        settings.type.should == 4
+        settings.pairs.should == 1
+
+        settings.headers[0].id_data.should == SPDY::Protocol::SETTINGS_ROUND_TRIP_TIME
+        settings.headers[0].value_data.should == 300
+
+        settings.to_binary_s.should == SETTINGS
+      end
 
-      d = SPDY::Protocol::Data::Frame.new
-      d.create(:stream_id => 1, :data => data)
+      describe "the assembled packet" do
+        before do
+          @settings = SPDY::Protocol::Control::Settings.new
+          @settings.create(:settings_round_trip_time => 300)
+          @frame = Array(@settings.to_binary_s.bytes)
+        end
+        specify "starts with a control bit" do
+          @frame[0].should == 128
+        end
+        specify "followed by the version (2)" do
+          @frame[1].should == 2
+        end
+        specify "followed by the type (4)" do
+          @frame[2..3].should == [0,4]
+        end
+        specify "followed by flags" do
+          @frame[4].should == 0
+        end
+        specify "followed by the length (24 bits)" do
+          @frame[5..7].should == [0,0,8]
+        end
+        specify "followed by the number of entries (32 bits)" do
+          @frame[8..11].should == [0,0,0,1]
+        end
+        specify "followed by ID/Value Pairs (32 bits each)" do
+          @frame[12..19].should == [0,0,0,3, 0,0,1,44]
+        end
+      end
+    end
 
-      d.to_binary_s.should == DATA
+    describe "NOOP" do
+      specify "not implemented (being dropped from protocol)" do
+        # NOOP
+      end
     end
 
-    it "should create a FIN data frame" do
-      d = SPDY::Protocol::Data::Frame.new
-      d.create(:stream_id => 1, :flags => 1)
+    describe "PING" do
+      it "can parse a PING packet" do
+        ping = SPDY::Protocol::Control::Ping.new
+        ping.parse(PING)
+
+        ping.ping_id.should == 1
+        ping.type.should == 6
+
+        ping.to_binary_s.should == PING
+      end
 
-      d.to_binary_s.should == DATA_FIN
+      describe "the assembled packet" do
+        before do
+          @ping = SPDY::Protocol::Control::Ping.new
+          @ping.create(:ping_id => 1)
+          @frame = Array(@ping.to_binary_s.bytes)
+        end
+        specify "starts with a control bit" do
+          @frame[0].should == 128
+        end
+        specify "followed by the version (2)" do
+          @frame[1].should == 2
+        end
+        specify "followed by the type (6)" do
+          @frame[2..3].should == [0,6]
+        end
+        specify "followed by flags (0)" do
+          @frame[4].should == 0
+        end
+        specify "followed by the length (always 4)" do
+          @frame[5..7].should == [0,0,4]
+        end
+      end
     end
 
-    it "should read a FIN data frame" do
-      d = SPDY::Protocol::Data::Frame.new
-      d.create(:stream_id => 1, :flags => 1)
+    describe "GOAWAY" do
+      it "can parse a GOAWAY packet" do
+        goaway = SPDY::Protocol::Control::Goaway.new
+        goaway.parse(GOAWAY)
 
-      d.to_binary_s.should == DATA_FIN
-      pckt = SPDY::Protocol::Data::Frame.new.read(d.to_binary_s)
-      pckt.flags.should == 1
+        goaway.stream_id.should == 1
+        goaway.type.should == 7
+
+        goaway.to_binary_s.should == GOAWAY
+      end
+
+      describe "the assembled packet" do
+        before do
+          @goaway = SPDY::Protocol::Control::Goaway.new
+          @goaway.create(:stream_id => 42)
+          @frame = Array(@goaway.to_binary_s.bytes)
+        end
+        specify "starts with a control bit" do
+          @frame[0].should == 128
+        end
+        specify "followed by the version (2)" do
+          @frame[1].should == 2
+        end
+        specify "followed by the type (7)" do
+          @frame[2..3].should == [0,7]
+        end
+        specify "followed by flags (0)" do
+          @frame[4].should == 0
+        end
+        specify "followed by the length (always 4)" do
+          @frame[5..7].should == [0,0,4]
+        end
+        specify "followed by the last good stream ID (1 ignored bit + 31 bits)" do
+          @frame[8..11].should == [0,0,0,42]
+        end
+      end
     end
 
-  end
+    describe "HEADERS" do
+      it "can parse a HEADERS packet"do
+        zlib_session = SPDY::Zlib.new
+
+        headers = SPDY::Protocol::Control::Headers.new({:zlib_session => zlib_session})
+        headers.parse(HEADERS)
+
+        headers.header.stream_id.should == 1
+        headers.header.type.should == 8
+
+        headers.to_binary_s.should == HEADERS
+      end
+
+      describe "the assembled packet" do
+        before do
+          zlib_session = SPDY::Zlib.new
+
+          @headers = SPDY::Protocol::Control::Headers.new({:zlib_session => zlib_session})
 
-  # context "RST_STREAM" do
-  #   it "should parse reset packet"
-  # end
+          nv = {'Content-Type' => 'text/plain', 'status' => '200 OK', 'version' => 'HTTP/1.1'}
+          @headers.create({:stream_id => 42, :headers => nv})
+
+          @frame = Array(@headers.to_binary_s.bytes)
+        end
+        specify "starts with a control bit" do
+          @frame[0].should == 128
+        end
+        specify "followed by the version (2)" do
+          @frame[1].should == 2
+        end
+        specify "followed by the type (8)" do
+          @frame[2..3].should == [0,8]
+        end
+        specify "followed by flags (8 bits)" do
+          @frame[4].should == 0
+        end
+        specify "followed by the length (24 bits)" do
+          # 4 bytes (stream ID)
+          # 2 bytes (unused)
+          # N bytes for compressed NV section
+          @frame[5..7].should == [0,0,53]
+        end
+        specify "followed by the stream ID (1 ignored bit + 31 bits)" do
+          @frame[8..11].should == [0,0,0,42]
+        end
+        specify "followed by 16 unused bits" do
+          @frame[12..13].should == [0,0]
+        end
+        specify "followed by name/value pairs" do
+          @frame[14..-1].size.should == 47
+        end
+      end
+    end
+
+    describe "NV" do
+      describe "creating a packet" do
+        before do
+          nv = SPDY::Protocol::NV.new
+
+          @name_values = {'version' => 'HTTP/1.1', 'status' => '200 OK', 'Content-Type' => 'text/plain'}
+          nv.create(@name_values)
+
+          @binary_string = nv.to_binary_s
+        end
+
+        it "begins with the number of name-value pairs" do
+          @binary_string[0..1].should == "\x00\x03"
+        end
+
+        it "prefaces names with the length of the name" do
+          @binary_string.should =~ %r{\x00\x0cContent-Type}
+        end
+        it "prefaces values with the length of the value" do
+          @binary_string.should =~ %r{\x00\x08HTTP/1.1}
+        end
+
+        it "has 2 bytes (total number of name-value pairs) + 2 bytes for each name (length of name) + 2 bytes for each value (length of value) + names + values" do
+          num_size_bytes = 2 + @name_values.size * (2 + 2)
+
+          @binary_string.length.should ==
+            @name_values.inject(num_size_bytes) {|sum, kv| sum + kv[0].length + kv[1].length}
+        end
+      end
+    end
+  end
 end

metadata

@@ -1,61 +1,56 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: spdy
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.0.3
   prerelease: 
-  version: 0.0.2
 platform: ruby
-authors: 
+authors:
 - Ilya Grigorik
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-04-23 00:00:00 -04:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-10-06 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: bindata
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &2157355140 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: ffi-zlib
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *2157355140
+- !ruby/object:Gem::Dependency
+  name: ffi-zlib
+  requirement: &2157354720 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *2157354720
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2157354300 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
+  prerelease: false
+  version_requirements: *2157354300
 description: SPDY is an experiment with protocols for the web
-email: 
+email:
 - ilya@igvita.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - .rspec
 - Gemfile
@@ -63,6 +58,7 @@ files:
 - Rakefile
 - examples/spdy_server.rb
 - lib/spdy.rb
+- lib/spdy/compat.rb
 - lib/spdy/compressor.rb
 - lib/spdy/parser.rb
 - lib/spdy/protocol.rb
@@ -72,35 +68,31 @@ files:
 - spec/helper.rb
 - spec/parser_spec.rb
 - spec/protocol_spec.rb
-has_rdoc: true
 homepage: https://github.com/igrigorik/spdy
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: spdy
-rubygems_version: 1.6.2
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
 summary: SPDY is an experiment with protocols for the web
-test_files: 
+test_files:
 - spec/compressor_spec.rb
 - spec/helper.rb
 - spec/parser_spec.rb