spdy 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+misc.md

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,42 @@
+# SPDY: An experimental protocol for a faster web
+
+SPDY was developed at Google as part of the "let's make the web faster" initiative. SPDY ("SPeeDY") is an application-layer protocol for transporting content over the web, designed specifically for minimal latency. In lab tests, SPDY shows 64% reduction in page load times! For more details, check out the [official site](https://sites.google.com/a/chromium.org/dev/spdy).
+
+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)
+
+## 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
+
+    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
+
+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
+
+    # 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
+
+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

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+desc "Run all RSpec tests"
+RSpec::Core::RakeTask.new(:spec)

data/examples/spdy_server.rb

@@ -0,0 +1,54 @@
+$: << 'lib' << '../lib'
+
+require 'eventmachine'
+require 'spdy'
+
+class SPDYHandler < EM::Connection
+  def post_init
+    @parser = SPDY::Parser.new
+    @parser.on_headers_complete do |stream_id, associated_stream, priority, headers|
+      p [:SPDY_HEADERS, headers]
+
+      sr = SPDY::Protocol::Control::SynReply.new
+      h = {'Content-Type' => 'text/plain', 'status' => '200 OK', 'version' => 'HTTP/1.1'}
+      sr.create(:stream_id => 1, :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.")
+      send_data d.to_binary_s
+
+      p [:SPDY, :sent, :DATA]
+
+      d = SPDY::Protocol::Data::Frame.new
+      d.create(:stream_id => 1, :flags => 1)
+      send_data d.to_binary_s
+
+      p [:SPDY, :sent, :DATA_FIN]
+    end
+
+    start_tls
+  end
+
+  def receive_data(data)
+    @parser << data
+  end
+
+  def unbind
+    p [:SPDY, :connection_closed]
+  end
+end
+
+EM.run do
+  EM.start_server '0.0.0.0', 10000, SPDYHandler
+end
+
+# (1) start the SPDY eventmachine server
+# > ruby spdy_server.rb
+#
+# (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/

data/lib/spdy/compressor.rb

@@ -0,0 +1,68 @@
+module SPDY
+  module Zlib
+
+    DICT = \
+      "optionsgetheadpostputdeletetraceacceptaccept-charsetaccept-encodingaccept-" \
+      "languageauthorizationexpectfromhostif-modified-sinceif-matchif-none-matchi" \
+      "f-rangeif-unmodifiedsincemax-forwardsproxy-authorizationrangerefererteuser" \
+      "-agent10010120020120220320420520630030130230330430530630740040140240340440" \
+      "5406407408409410411412413414415416417500501502503504505accept-rangesageeta" \
+      "glocationproxy-authenticatepublicretry-afterservervarywarningwww-authentic" \
+      "ateallowcontent-basecontent-encodingcache-controlconnectiondatetrailertran" \
+      "sfer-encodingupgradeviawarningcontent-languagecontent-lengthcontent-locati" \
+      "oncontent-md5content-rangecontent-typeetagexpireslast-modifiedset-cookieMo" \
+      "ndayTuesdayWednesdayThursdayFridaySaturdaySundayJanFebMarAprMayJunJulAugSe" \
+      "pOctNovDecchunkedtext/htmlimage/pngimage/jpgimage/gifapplication/xmlapplic" \
+      "ation/xhtmltext/plainpublicmax-agecharset=iso-8859-1utf-8gzipdeflateHTTP/1" \
+      ".1statusversionurl\0"
+
+    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)
+      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
+
+      result = FFI::Zlib.inflateSetDictionary(zstream, DICT, DICT.size)
+      raise "invalid dictionary" if result != FFI::Zlib::Z_OK
+
+      result = FFI::Zlib.inflate(zstream, FFI::Zlib::Z_SYNC_FLUSH)
+      raise "cannot inflate" if result != FFI::Zlib::Z_OK
+
+      out_buf.get_bytes(0, zstream[:total_out])
+    end
+
+    def self.deflate(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
+
+      result = FFI::Zlib.deflateInit(zstream, -1)
+      raise "invalid stream" if result != FFI::Zlib::Z_OK
+
+      result = FFI::Zlib.deflateSetDictionary(zstream, DICT, DICT.size)
+      raise "invalid dictionary" if result != FFI::Zlib::Z_OK
+
+      result = FFI::Zlib.deflate(zstream, FFI::Zlib::Z_SYNC_FLUSH)
+      raise "cannot deflate" if result != FFI::Zlib::Z_OK
+
+      out_buf.get_bytes(0, zstream[:total_out])
+    end
+  end
+end

data/lib/spdy/parser.rb

@@ -0,0 +1,88 @@
+module SPDY
+  class Parser
+    include Protocol
+
+    def initialize
+      @buffer = ''
+    end
+
+    def <<(data)
+      @buffer << data
+      try_parse
+    end
+
+    def on_headers_complete(&blk)
+      @on_headers_complete = blk
+    end
+
+    def on_body(&blk)
+      @on_body = blk
+    end
+
+    def on_message_complete(&blk)
+      @on_message_complete = blk
+    end
+
+    private
+
+      def try_parse
+        type = @buffer[0,1].unpack('C').first >> 7 & 0x01
+        pckt = nil
+
+        case type
+          when CONTROL_BIT
+            return if @buffer.size < 12
+            pckt = Control::Header.new.read(@buffer[0,12])
+
+            case pckt.type.to_i
+              when 1 then # SYN_STREAM
+                pckt = Control::SynStream.new
+                pckt.read(@buffer)
+
+                headers = {}
+                if pckt.data.size > 0
+                  data = Zlib.inflate(pckt.data.to_s)
+                  headers = NV.new.read(data).to_h
+                end
+
+                if @on_headers_complete
+                  @on_headers_complete.call(pckt.header.stream_id.to_i,
+                                            pckt.associated_to_stream_id.to_i,
+                                            pckt.pri.to_i,
+                                            headers)
+                end
+
+              when 2 then # SYN_REPLY
+                raise 'SYN_REPLY not handled yet'
+              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
+
+            pckt = Data::Frame.new.read(@buffer)
+            @on_body.call(pckt.stream_id, pckt.data) if @on_body
+            @on_message_complete.call(pckt.stream_id) if @on_message_complete && fin?(pckt)
+
+          else
+            raise 'unknown packet type'
+        end
+
+        # remove parsed data from the buffer
+        @buffer.slice!(0..pckt.num_bytes)
+
+      rescue IOError
+        # rescue partial parse and wait for more data
+      end
+
+    private
+
+      def fin?(packet)
+        (packet.flags == 1) rescue false
+      end
+
+  end
+end

data/lib/spdy/protocol.rb

@@ -0,0 +1,122 @@
+module SPDY
+  module Protocol
+
+    CONTROL_BIT = 1
+    DATA_BIT    = 0
+    VERSION     = 2
+
+    module Control
+      class Header < BinData::Record
+        hide :u1
+
+        bit1 :frame, :initial_value => CONTROL_BIT
+        bit15 :version, :initial_value => VERSION
+        bit16 :type
+
+        bit8 :flags
+        bit24 :len
+
+        bit1 :u1
+        bit31 :stream_id
+      end
+
+      class SynStream < BinData::Record
+        hide :u1, :u2
+
+        header :header
+
+        bit1  :u1
+        bit31 :associated_to_stream_id
+
+        bit2  :pri
+        bit14 :u2
+
+        string :data, :read_length => lambda { header.len - 10 }
+      end
+
+      class SynReply < BinData::Record
+        attr_accessor :uncompressed_data
+
+        header :header
+        bit16 :unused
+        string :data, :read_length => lambda { header.len - 6 }
+
+        def parse(chunk)
+          self.read(chunk)
+
+          data = Zlib.inflate(self.data.to_s)
+          self.uncompressed_data = NV.new.read(data)
+          self
+        end
+
+        def create(opts = {})
+          self.header.type  = 2
+          self.header.len   = 6
+
+          self.header.flags   = opts[:flags] || 0
+          self.header.stream_id = opts[:stream_id]
+
+          nv = SPDY::Protocol::NV.new
+          nv.create(opts[:headers])
+
+          nv = SPDY::Zlib.deflate(nv.to_binary_s)
+          self.header.len = self.header.len.to_i + nv.size
+          self.data = nv
+
+          self
+        end
+      end
+    end
+
+    module Data
+      class Frame < BinData::Record
+        bit1 :frame, :initial_value => DATA_BIT
+        bit31 :stream_id
+
+        bit8 :flags, :initial_value => 0
+        bit24 :len,  :initial_value => 0
+
+        string :data, :read_length => :len
+
+        def create(opts = {})
+          self.stream_id = opts[:stream_id]
+          self.flags     = opts[:flags] if opts[:flags]
+
+          if opts[:data]
+            self.len       = opts[:data].size
+            self.data      = opts[:data]
+          end
+
+          self
+        end
+      end
+    end
+
+    class NV < BinData::Record
+      bit16 :pairs
+      array :headers, :initial_length => :pairs do
+        bit16 :name_len
+        string :name_data, :read_length => :name_len
+
+        bit16 :value_len
+        string :value_data, :read_length => :value_len
+      end
+
+      def create(opts = {})
+        opts.each do |k, v|
+          self.headers << {:name_len => k.size, :name_data => k, :value_len => v.size, :value_data => v}
+        end
+
+        self.pairs = opts.size
+        self
+      end
+
+      def to_h
+        headers.inject({}) do |h, v|
+          h[v.name_data.to_s] = v.value_data.to_s
+          h
+        end
+      end
+    end
+  end
+end

data/lib/spdy/version.rb

@@ -0,0 +1,3 @@
+module Spdy
+  VERSION = "0.0.1"
+end

data/lib/spdy.rb

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

data/spdy.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "spdy/version"
+
+Gem::Specification.new do |s|
+  s.name        = "spdy"
+  s.version     = Spdy::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ilya Grigorik"]
+  s.email       = ["ilya@igvita.com"]
+  s.homepage    = "https://github.com/igrigorik/spdy"
+  s.summary     = "SPDY is an experiment with protocols for the web"
+  s.description = s.summary
+
+  s.rubyforge_project = "spdy"
+
+  s.add_dependency "bindata"
+  s.add_dependency "ffi-zlib"
+  s.add_development_dependency "rspec"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/compressor_spec.rb

@@ -0,0 +1,14 @@
+require 'helper'
+
+describe SPDY::Zlib do
+  it "should inflate header with custom dictionary" do
+    SPDY::Zlib.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))
+
+    orig.should == rinse
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,15 @@
+require 'rspec'
+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"
+
+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"
+
+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"

data/spec/parser_spec.rb

@@ -0,0 +1,115 @@
+require 'helper'
+
+describe SPDY::Parser do
+  let(:s) { SPDY::Parser.new }
+
+  context "callbacks" do
+    it "should accept header callback" do
+      lambda do
+        s.on_headers_complete {}
+      end.should_not raise_error
+    end
+
+    it "should accept body callback" do
+      lambda do
+        s.on_body {}
+      end.should_not raise_error
+    end
+
+    it "should accept message complete callback" do
+      lambda do
+        s.on_message_complete {}
+      end.should_not raise_error
+    end
+  end
+
+  it "should accept incoming data" do
+    lambda { s << DATA }.should_not raise_error
+  end
+
+  it "should reassemble broken packets" do
+    stream, data = nil
+    s.on_body { |stream_id, d| stream, data = stream_id, d }
+
+    lambda { s << DATA[0...DATA.size - 10] }.should_not raise_error
+    lambda { s << DATA[DATA.size-10..DATA.size] }.should_not raise_error
+
+    stream.should == 1
+    data.should == 'This is SPDY.'
+
+    fired = false
+    s.on_headers_complete { fired = true }
+    s << SYN_STREAM
+
+    fired.should be_true
+  end
+
+  context "CONTROL" do
+    it "should parse SYN_STREAM packet" do
+      fired = false
+      s.on_headers_complete { fired = true }
+      s << SYN_STREAM
+
+      fired.should be_true
+    end
+
+    it "should return parsed headers" do
+      sid, asid, pri, headers = nil
+      s.on_headers_complete do |stream, astream, priority, head|
+        sid = stream; asid = astream; pri = priority; headers = head
+      end
+
+      s << SYN_STREAM
+
+      sid.should == 1
+      asid.should == 0
+      pri.should == 0
+
+      headers.class.should == Hash
+      headers['version'].should == "HTTP/1.1"
+    end
+  end
+
+  context "DATA" do
+    it "should parse data packet" do
+      stream, data = nil
+      s.on_body { |stream_id, d| stream, data = stream_id, d }
+      s << DATA
+
+      stream.should == 1
+      data.should == 'This is SPDY.'
+    end
+  end
+
+  context "FIN" do
+    it "should invoke message_complete on FIN flag in CONTROL packet" do
+      f1, f2 = false
+      s.on_headers_complete { f1 = true }
+      s.on_message_complete { |s| f2 = s }
+
+      sr = SPDY::Protocol::Control::SynStream.new
+      sr.header.stream_id = 3
+      sr.header.type  = 1
+      sr.header.flags = 0x01
+      sr.header.len = 10
+
+      s << sr.to_binary_s
+
+      f1.should be_true
+      f2.should == 3
+    end
+
+    it "should invoke message_complete on FIN flag in DATA packet" do
+      f1, f2 = false
+      s.on_body { f1 = true }
+      s.on_message_complete { |s| f2 = s }
+
+      s << DATA_FIN
+
+      f1.should be_true
+      f2.should == 1
+    end
+
+  end
+
+end

data/spec/protocol_spec.rb

@@ -0,0 +1,63 @@
+require 'helper'
+
+describe SPDY::Protocol do
+
+  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'})
+
+      nv.to_binary_s.should == NV
+    end
+  end
+
+  context "SYN_REPLY" do
+    it "should create a SYN_REPLY packet" do
+      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)
+
+      sr.header.version.should == 2
+      sr.header.stream_id.should == 1
+
+      sr.header.len.should > 50
+      sr.data.should_not be_nil
+
+      sr.to_binary_s.should == SYN_REPLY
+    end
+
+    it "should parse SYN_REPLY packet" do
+      sr = SPDY::Protocol::Control::SynReply.new
+      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
+
+  context "DATA" do
+    it "should create a data frame" do
+      data = "This is SPDY."
+
+      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
+  end
+
+  # context "RST_STREAM" do
+  #   it "should parse reset packet"
+  # end
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification 
+name: spdy
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Ilya Grigorik
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-07 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bindata
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    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 
+    none: false
+    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 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: SPDY is an experiment with protocols for the web
+email: 
+- ilya@igvita.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- README.md
+- Rakefile
+- examples/spdy_server.rb
+- lib/spdy.rb
+- lib/spdy/compressor.rb
+- lib/spdy/parser.rb
+- lib/spdy/protocol.rb
+- lib/spdy/version.rb
+- spdy.gemspec
+- spec/compressor_spec.rb
+- 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: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: spdy
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: SPDY is an experiment with protocols for the web
+test_files: 
+- spec/compressor_spec.rb
+- spec/helper.rb
+- spec/parser_spec.rb
+- spec/protocol_spec.rb