spdy 0.0.1 → 0.0.2

data/lib/spdy/parser.rb

@@ -25,6 +25,23 @@ module SPDY
 
     private
 
+      def unpack_control(pckt, data)
+        pckt.read(data)
+
+        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 rescue nil),
+                                    (pckt.pri.to_i rescue nil),
+                                    headers)
+        end
+      end
+
       def try_parse
         type = @buffer[0,1].unpack('C').first >> 7 & 0x01
         pckt = nil
@@ -37,23 +54,12 @@ module SPDY
             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
+                unpack_control(pckt, @buffer)
 
               when 2 then # SYN_REPLY
-                raise 'SYN_REPLY not handled yet'
+                pckt = Control::SynReply.new
+                unpack_control(pckt, @buffer)
+
               else
                 raise 'invalid control frame'
             end
@@ -72,9 +78,9 @@ module SPDY
         end
 
         # remove parsed data from the buffer
-        @buffer.slice!(0..pckt.num_bytes)
+        @buffer.slice!(0...pckt.num_bytes)
 
-      rescue IOError
+      rescue IOError => e
         # rescue partial parse and wait for more data
       end
 

data/lib/spdy/protocol.rb

@@ -6,6 +6,35 @@ module SPDY
     VERSION     = 2
 
     module Control
+      module Helpers
+        def parse(chunk)
+          head = Control::Header.new.read(chunk)
+          self.read(chunk)
+
+          data = Zlib.inflate(self.data.to_s)
+          self.uncompressed_data = NV.new.read(data)
+          self
+        end
+
+        def build(opts = {})
+          self.header.type  = opts[:type]
+          self.header.len   = opts[:len]
+
+          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
+
       class Header < BinData::Record
         hide :u1
 
@@ -21,6 +50,9 @@ module SPDY
       end
 
       class SynStream < BinData::Record
+        attr_accessor :uncompressed_data
+        include Helpers
+
         hide :u1, :u2
 
         header :header
@@ -32,38 +64,22 @@ module SPDY
         bit14 :u2
 
         string :data, :read_length => lambda { header.len - 10 }
+
+        def create(opts = {})
+          build({:type => 1, :len => 10}.merge(opts))
+        end
       end
 
       class SynReply < BinData::Record
         attr_accessor :uncompressed_data
+        include Helpers
 
         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
+          build({:type => 2, :len => 6}.merge(opts))
         end
       end
     end

data/lib/spdy/version.rb

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

data/spec/protocol_spec.rb

@@ -11,6 +11,42 @@ describe SPDY::Protocol do
     end
   end
 
+  context "SYN_STREAM" do
+    it "should create a SYN_STREAM packet" do
+      sr = SPDY::Protocol::Control::SynStream.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.create(:stream_id => 1, :headers => headers)
+      sr.header.version.should == 2
+      sr.pri.should == 0
+
+      sr.header.len.should > 50
+      sr.data.should_not be_nil
+
+      st = SPDY::Protocol::Control::SynStream.new
+      st.parse(sr.to_binary_s)
+      st.num_bytes.should == sr.to_binary_s.size
+    end
+
+    it "should parse SYN_STREAM packet" do
+      sr = SPDY::Protocol::Control::SynStream.new
+      sr.parse(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
+
   context "SYN_REPLY" do
     it "should create a SYN_REPLY packet" do
       sr = SPDY::Protocol::Control::SynReply.new
@@ -55,6 +91,16 @@ describe SPDY::Protocol do
 
       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
+
   end
 
   # context "RST_STREAM" do

metadata

@@ -2,7 +2,7 @@
 name: spdy
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Ilya Grigorik
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-07 00:00:00 -04:00
+date: 2011-04-23 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency