net-http-spdy 0.0.2 → 0.0.3

data/.travis.yml

@@ -0,0 +1,11 @@
+rvm:
+  - 1.9.3
+  - ruby-head
+
+script: rake test
+
+gemfile:
+  - Gemfile
+
+notifications:
+  email: authornari+travis@gmail.com

data/Gemfile

@@ -3,5 +3,6 @@ source "http://rubygems.org"
 gemspec
 
 group :test do
-  gem 'test-unit', '~> 2.5.3'
+  gem 'test-unit', '~> 2.5.4'
+  gem 'eventmachine', '~> 1.0.0'
 end

data/README.rdoc

@@ -12,7 +12,8 @@ A SPDY HTTP client implementation with extended Net:HTTP.
 
 == FEATURES/PROBLEMS:
 
-* Supports SSL/TLS in Ruby 2.0.0 or later
+* Support SPDYv2
+* Support SSL/TLS in Ruby 2.0.0 or later
 
 == COMPARING:
 

data/examples/spdy.rb

@@ -10,14 +10,12 @@ flag_uris = %w(
 end
 fetch_threads = []
 uri = URI('https://www.modspdy.com/world-flags/')
-http = Net::HTTP::SPDY.new(uri.host, uri.port)
-http.use_ssl = true
-http.start
-flag_uris.each do |uri|
-  req = Net::HTTP::Get.new(uri)
-  fetch_threads << Thread.start do
-    http.request(req)
+Net::HTTP::SPDY.start(uri.host, uri.port, use_ssl: true) do |http|
+  flag_uris.each do |uri|
+    req = Net::HTTP::Get.new(uri)
+    fetch_threads << Thread.start do
+      http.request(req)
+    end
   end
+  fetch_threads.each(&:join)
 end
-fetch_threads.each(&:join)
-http.finish

data/lib/net/http/spdy.rb

@@ -4,6 +4,49 @@ $: << File.join(File.dirname(__FILE__), "../../../vender/spdy/lib/")
 require 'spdy'
 require 'openssl'
 
+# A SPDY HTTP Client with Net::HTTP
+#
+# Net::HTTP::SPDY has created with extending Net::HTTP.
+# See Net::HTTP, if you want to know major usages.
+# 
+# Different points from Net::HTTP to Net::HTTP::SPDY are here.
+#
+# == A TCP socket per multi-streams
+# 
+# A TCP Socket conneted with Net::HTTP::SPDY will not close usually
+# until you call Net::HTTP#finish.
+# And, you can use multi-thread to send HTTP requests continuously.
+#
+# Example:
+#
+#   require 'net/http/spdy'
+#   
+#   flag_uris = %w(
+#      images_sm/ad_flag.png images_sm/ae_flag.png
+#      images_sm/af_flag.png images_sm/ag_flag.png
+#      images_sm/ai_flag.png images_sm/am_flag.png
+#      images_sm/ao_flag.png images_sm/ar_flag.png
+#      images_sm/as_flag.png images_sm/at_flag.png).map do |path|
+#     URI('https://www.modspdy.com/world-flags/' + path)
+#   end
+#   fetch_threads = []
+#   uri = URI('https://www.modspdy.com/world-flags/')
+#   Net::HTTP::SPDY.start(uri.host, uri.port, use_ssl: true) do |http|
+#     flag_uris.each do |uri|
+#       req = Net::HTTP::Get.new(uri)
+#       fetch_threads << Thread.start do
+#         http.request(req)
+#       end
+#     end
+#     fetch_threads.each(&:join)
+#   end
+#
+# == Server push
+#
+# You can check to exist HTTP responses pushed by a server by
+# Net::HTTPResponse#has_associatd_response? and you can take
+# it by Net::HTTPResponse#associated_responses .
+#
 class Net::HTTP::SPDY < Net::HTTP
   def initialize(address, port = nil)
     super
@@ -17,21 +60,22 @@ class Net::HTTP::SPDY < Net::HTTP
   end
 
   if RUBY_VERSION >= "2.0.0"
-    SSL_IVNAMES << :@npn_protocols
-    SSL_ATTRIBUTES << :npn_protocols
     SSL_IVNAMES << :@npn_select_cb
     SSL_ATTRIBUTES << :npn_select_cb
   end
 
+  undef :close_on_empty_response= if defined?(self.close_on_empty_response=true)
+
+  private
+
   def connect
+    if RUBY_VERSION < "2.0.0" && use_ssl?
+      raise ArgumentError, "Supports SSL in Ruby 2.0.0 or later only"
+    end
     super
     @stream_session = StreamSession.new(@socket)
   end
 
-  undef :close_on_empty_response= if defined?(self.close_on_empty_response=true)
-
-  private
-
   def transport_request(req)
     begin_transport req
     req.uri = URI((use_ssl? ? "https://" : "http://") + addr_port + req.path)
@@ -55,7 +99,10 @@ class Net::HTTP::SPDY < Net::HTTP
         begin
           r = Net::HTTPResponse.read_new(s)
         end while r.kind_of?(Net::HTTPContinue)
-        yield r if block_given?
+        r.reading_body(s, true) {
+          yield r if block_given?
+        }
+        r.uri = s.uri
         res.associated_responses << r
       end
     end

data/lib/net/http/spdy/generic_request.rb

@@ -15,7 +15,7 @@ class Net::HTTPGenericRequest
     if is_spdy?(sock)
       stream = sock
       write_header stream, ver, path
-      wait_for_continue stream, ver if stream.sock.continue_timeout
+      wait_for_continue stream, ver if stream.continue_timeout
       IO.copy_stream(f, stream)
     else
       send_request_with_body_stream_wo_spdy

data/lib/net/http/spdy/response.rb

@@ -1,15 +1,23 @@
 class Net::HTTPResponse
-  if RUBY_VERSION <= "2.0.0"
-    attr_accessor :uri
+  if RUBY_VERSION < '2.0.0'
+    attr_reader :uri
+
+    def uri= uri # :nodoc:
+      @uri = uri.dup if uri
+    end
   end
 
   attr_reader :associated_responses
 
-  def has_associatd_response?
+  ##
+  # Returns true when itself has a associated_response
+  def has_associated_response?
     @associated_responses ||= []
-    not @response.empty?
+    not @associated_responses.empty?
   end
 
+  ##
+  # Returns associated responses
   def associated_responses
     @associated_responses ||= []
     return @associated_responses

data/lib/net/http/spdy/stream.rb

@@ -3,9 +3,9 @@ require 'forwardable'
 class Net::HTTP::SPDY::Stream
   extend Forwardable
 
-  attr_accessor :buf, :eof, :connected
-  attr_reader :sock, :uri, :assocs, :new_assoc, :id
-  def_delegators :@sock, :io, :closed?, :close
+  attr_accessor :buf, :eof, :connected, :new_assoc
+  attr_reader :sock, :uri, :assocs, :id
+  def_delegators :@sock, :io, :closed?, :close, :continue_timeout
 
   def initialize(id, session, sock, uri)
     @id = id
@@ -73,8 +73,8 @@ class Net::HTTP::SPDY::Stream
     }
     h['host'] = request.delete("host").first
 
-    %w(Connection Host Keep-Alive Proxy-Connection Transfer-Encoding).each do |h|
-      raise ArgumentError, "#{h} cannot send with SPDY" if not request[h].nil?
+    %w(Connection Host Keep-Alive Proxy-Connection Transfer-Encoding).each do |i|
+      raise ArgumentError, "Can't send #{i} with SPDY" if not request[i].nil?
     end
 
     sr = SPDY::Protocol::Control::SynStream.new(zlib_session: @session.parser.zlib_session)
@@ -98,6 +98,14 @@ class Net::HTTP::SPDY::Stream
     end
   end
 
+  def write_protocol_error
+    d = SPDY::Protocol::Control::RstStream.new
+    d.create(stream_id: @id, status_code: 1)
+    @session.monitor.synchronize do
+      @sock.write d.to_binary_s
+    end
+  end
+
   def close_write
     d = SPDY::Protocol::Data::Frame.new
     d.create(stream_id: @id, flags: 1)
@@ -112,23 +120,23 @@ class Net::HTTP::SPDY::Stream
   def read_frame(ignore_eof)
     while buf.empty?
       raise EOFError if eof? && !ignore_eof
-      begin
-        @session.monitor.synchronize do
+      @session.monitor.synchronize do
+        begin
           return if not buf.empty?
           s = @sock.io.read_nonblock(BUFSIZE)
           @session.parse(s)
-        end
-      rescue IO::WaitReadable
-        if IO.select([@sock.io], nil, nil, @sock.read_timeout)
-          retry
-        else
-          raise Net::ReadTimeout
-        end
-      rescue IO::WaitWritable
-        if IO.select(nil, [@sock.io], nil, @sock.read_timeout)
-          retry
-        else
-          raise Net::ReadTimeout
+        rescue IO::WaitReadable
+          if IO.select([@sock.io], nil, nil, @sock.read_timeout)
+            retry
+          else
+            raise Net::ReadTimeout
+          end
+        rescue IO::WaitWritable
+          if IO.select(nil, [@sock.io], nil, @sock.read_timeout)
+            retry
+          else
+            raise Net::ReadTimeout
+          end
         end
       end
     end

data/lib/net/http/spdy/stream_session.rb

@@ -50,7 +50,7 @@ class Net::HTTP::SPDY
         @sock.debug_output.puts "on_open: id=<#{id}>,assoc_id=<#{assoc_id}>" if @sock.debug_output
         if assoc_id
           s = @streams.fetch(id)
-          s.new_assoc = @assoc_id
+          s.new_assoc = assoc_id
         end
       end
       parser.on_headers do |id, headers|
@@ -59,15 +59,19 @@ class Net::HTTP::SPDY
         if s.new_assoc
           # TODO: check invalid header and send PROTOCOL_ERROR
           uri = URI(headers.delete('url'))
-          assoc = push(assoc_id, uri, true)
+          assoc = push(s.new_assoc, uri, true)
           s.new_assoc = nil
           s.assocs << assoc
+          s = assoc
         else
           s = @streams.fetch(id)
         end
   
-        # TODO: check invalid header
         h = ["#{headers['version']} #{headers['status']}"]
+        if headers['version'].nil? or headers['status'].nil?
+          s.write_protocol_error
+          raise StreamError, "Receives a SYN_REPLY without a status or without a version header"
+        end
         code, msg = headers.delete('status').split(" ")
         r = ::Net::HTTPResponse.new(headers.delete('version'), code, msg)
         r.each_capitalized{|k,v| h << "#{k}: #{v}" }

data/lib/net/http/spdy/version.rb

@@ -1,5 +1,5 @@
 require 'net/http'
 
 class Net::HTTP::SPDY < Net::HTTP
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/test/helper.rb

@@ -0,0 +1,104 @@
+module TestNetHTTPSPDY
+  extend Forwardable
+
+  HANDLERS = %w(on_open on_ping on_headers on_settings
+                on_body on_message_complete on_reset)
+
+  def setup
+    @parser = SPDY::Parser.new
+    spawn_server
+  end
+
+  def teardown
+    EM.stop_event_loop
+    while @server_thread.alive?
+      sleep 0.1
+    end
+  end
+
+  def new
+    http = Net::HTTP::SPDY.new(config('host'), config('port'))
+    http.set_debug_output logfile()
+    http
+  end
+
+  def config(key)
+    @config ||= self.class::CONFIG
+    @config[key]
+  end
+
+  def logfile
+    $DEBUG ? $stderr : NullWriter.new
+  end
+
+  def start(&block)
+    new.start(&block)
+  end
+
+  def_delegators "SPDYHandler", *HANDLERS
+  def_delegators :@parser, :zlib_session
+
+  private
+  def unused_port
+    s = TCPServer.open(0)
+    port = s.addr[1]
+    s.close
+    port
+  end
+
+  def spawn_server
+    @config = {'host' => '127.0.0.1', 'port' => unused_port}
+    SPDYHandler.parser = @parser
+    @server_thread = Thread.start do
+      EM.run do
+        EM.start_server(config('host'), config('port'), SPDYHandler)
+      end
+    end
+    @server_thread.abort_on_exception = true
+    n_try_max = 5
+    begin
+      TCPSocket.open(config('host'), config('port')).close
+    rescue Errno::ECONNREFUSED
+      sleep 0.2
+      n_try_max -= 1
+      raise 'cannot spawn server; give up' if n_try_max < 0
+      retry
+    end
+  end
+
+  class SPDYHandler < EM::Connection
+    def self.parser=(parser)
+      @@parser = parser
+    end
+
+    HANDLERS.each do |h|
+      self.class_eval <<-METHOD
+        @@#{h} = nil
+        def self.#{h}(&block)
+          @@#{h} = block
+        end
+      METHOD
+    end
+
+    def post_init
+      HANDLERS.each do |h|
+        if self.class.class_variable_get("@@#{h}")
+          @@parser.send(h) do |*args|
+            self.class.class_variable_get("@@#{h}").call(self, *args)
+          end
+        end
+      end
+    end
+
+    def receive_data(data)
+      @@parser << data if not data.empty?
+    end
+  end
+
+  class NullWriter
+    def <<(s) end
+    def puts(*args) end
+    def print(*args) end
+    def printf(*args) end
+  end
+end

data/test/run-test.rb

@@ -9,6 +9,7 @@ Bundler.require(:default, :test)
 require "test/unit"
 
 require "net/http/spdy"
+require 'helper'
 
 test_file = "./test/test_*.rb"
 Dir.glob(test_file) do |file|

data/test/test_access_to_web.rb

@@ -1,48 +1,50 @@
-class TestAccessToWeb < Test::Unit::TestCase
-  def test_get_google
-    uri = URI('https://www.google.com/')
-    http = Net::HTTP::SPDY.new(uri.host, uri.port)
-    http.use_ssl = true
-    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-    http.start do |http|
-      req = Net::HTTP::Get.new(uri)
-      res = http.request(req)
-      assert_include ["200", "302"], res.code
+if RUBY_VERSION >= "2.0.0"
+  class TestAccessToWeb < Test::Unit::TestCase
+    def test_get_google
+      uri = URI('https://www.google.com/')
+      http = Net::HTTP::SPDY.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      http.start do |http|
+        req = Net::HTTP::Get.new(uri)
+        res = http.request(req)
+        assert_include ["200", "302"], res.code
+      end
     end
-  end
-
-  def test_get_google_simple
-    uri = URI('https://www.google.com/')
-    Net::HTTP::SPDY.start(uri.host, uri.port, use_ssl: true) do |http|
-      res = http.get("/")
-      assert_include ["200", "302"], res.code
+  
+    def test_get_google_simple
+      uri = URI('https://www.google.com/')
+      Net::HTTP::SPDY.start(uri.host, uri.port, use_ssl: true) do |http|
+        res = http.get("/")
+        assert_include ["200", "302"], res.code
+      end
     end
-  end
-
-  def test_get_world_flags_parallel
-    flag_uris = %w(
-       images_sm/ad_flag.png images_sm/ae_flag.png
-       images_sm/af_flag.png images_sm/ag_flag.png
-       images_sm/ai_flag.png images_sm/am_flag.png
-       images_sm/ao_flag.png images_sm/ar_flag.png
-       images_sm/as_flag.png images_sm/at_flag.png).map do |path|
-      URI('https://www.modspdy.com/world-flags/' + path)
-    end
-    fetch_threads = []
-    uri = URI('https://www.modspdy.com/world-flags/')
-    http = Net::HTTP::SPDY.new(uri.host, uri.port)
-    http.use_ssl = true
-    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-    #http.set_debug_output $stderr
-    http.start
-    flag_uris.each do |uri|
-      req = Net::HTTP::Get.new(uri)
-      #fetch_threads << Thread.start do
-        res = http.request(req)
-        assert_equal "200", res.code
-      #end
+  
+    def test_get_world_flags_parallel
+      flag_uris = %w(
+         images_sm/ad_flag.png images_sm/ae_flag.png
+         images_sm/af_flag.png images_sm/ag_flag.png
+         images_sm/ai_flag.png images_sm/am_flag.png
+         images_sm/ao_flag.png images_sm/ar_flag.png
+         images_sm/as_flag.png images_sm/at_flag.png).map do |path|
+        URI('https://www.modspdy.com/world-flags/' + path)
+      end
+      fetch_threads = []
+      uri = URI('https://www.modspdy.com/world-flags/')
+      http = Net::HTTP::SPDY.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      #http.set_debug_output $stderr
+      http.start
+      flag_uris.each do |uri|
+        req = Net::HTTP::Get.new(uri)
+        #fetch_threads << Thread.start do
+          res = http.request(req)
+          assert_equal "200", res.code
+        #end
+      end
+      fetch_threads.each(&:join)
+      http.finish
     end
-    fetch_threads.each(&:join)
-    http.finish
   end
 end

data/test/test_spdy.rb

@@ -0,0 +1,108 @@
+class TestSpdy < Test::Unit::TestCase
+  include TestNetHTTPSPDY
+
+  def test_get
+    on_headers do |sv, stream_id, headers|
+      sr = SPDY::Protocol::Control::SynReply.new(zlib_session: zlib_session)
+      h = {'Content-Type' => 'text/plain', 'status' => '200', 'version' => 'HTTP/1.1'}
+      sr.create(stream_id: stream_id, headers: h)
+      sv.send_data sr.to_binary_s
+
+      d = SPDY::Protocol::Data::Frame.new
+      d.create(stream_id: stream_id, data: "This is SPDY.", flags: 1)
+      sv.send_data d.to_binary_s
+
+      assert_equal "http", headers['scheme']
+      assert_equal "GET", headers['method']
+      assert_equal "/", headers['url']
+      assert_equal "HTTP/1.1", headers['version']
+    end
+    start do |http|
+      res = http.request_get("/")
+      assert_equal '200', res.code
+      assert_equal 'This is SPDY.', res.body
+    end
+  end
+
+  def test_server_push
+    on_headers do |sv, stream_id, headers|
+      sr = SPDY::Protocol::Control::SynReply.new(zlib_session: zlib_session)
+      h = {'Content-Type' => 'text/plain', 'status' => '200', 'version' => 'HTTP/1.1'}
+      sr.create(stream_id: stream_id, headers: h)
+      sv.send_data sr.to_binary_s
+
+      # server push start
+      sr = SPDY::Protocol::Control::SynStream.new(zlib_session: zlib_session)
+      h = {'Content-Type' => 'text/plain', 'status' => '200', 'version' => 'HTTP/1.1', 'url' => "http://127.0.0.1/test.txt"}
+      sr.create(
+        stream_id: stream_id, headers: h,
+        associated_to_stream_id: stream_id+1, flags: 2)
+      sv.send_data sr.to_binary_s
+
+      d = SPDY::Protocol::Data::Frame.new
+      d.create(stream_id: stream_id+1, data: "PUSH OK", flags: 1)
+      sv.send_data d.to_binary_s
+      # finish
+
+      d = SPDY::Protocol::Data::Frame.new
+      d.create(stream_id: stream_id, data: "OK", flags: 1)
+      sv.send_data d.to_binary_s
+    end
+    start do |http|
+      res = http.request_get("/")
+      assert_equal '200', res.code
+      assert_equal 'OK', res.body
+      assert_equal true, res.has_associated_response?
+      assoc = res.associated_responses.first
+      assert_equal '200', assoc.code
+      assert_equal 'PUSH OK', assoc.body
+      assert_equal 'http://127.0.0.1/test.txt', assoc.uri.to_s
+    end
+  end
+
+  def test_get_without_version
+    on_headers do |sv, stream_id, headers|
+      sr = SPDY::Protocol::Control::SynReply.new(zlib_session: zlib_session)
+      h = {"status" => '200'}
+      sr.create(stream_id: stream_id, headers: h, flags: 1)
+      sv.send_data sr.to_binary_s
+    end
+    on_reset do |stream_id, status_code|
+      assert_equal 1, status_code
+    end
+    assert_raise Net::HTTP::SPDY::StreamError do
+      start do |http|
+        http.request_get("/")
+      end
+    end
+  end
+
+  def test_post
+    post_data = ""
+    on_headers do |sv, stream_id, headers|
+      assert_equal "http", headers['scheme']
+      assert_equal "POST", headers['method']
+      assert_equal "/", headers['url']
+      assert_equal "HTTP/1.1", headers['version']
+    end
+    on_body do |sv, stream_id, data|
+      if data == 'data'
+        sr = SPDY::Protocol::Control::SynReply.new(zlib_session: zlib_session)
+        h = {'Content-Type' => 'text/plain', 'status' => '200', 'version' => 'HTTP/1.1'}
+        sr.create(stream_id: stream_id, headers: h)
+        sv.send_data sr.to_binary_s
+
+        d = SPDY::Protocol::Data::Frame.new
+        d.create(stream_id: stream_id, data: "OK", flags: 1)
+        sv.send_data d.to_binary_s
+      end
+    end
+
+    start do |http|
+      http.request_post("/", 'data') do |res|
+        assert_equal '200', res.code
+        assert_equal 'OK', res.body
+      end
+    end
+  end
+end

data/vender/spdy/lib/spdy/parser.rb

@@ -95,7 +95,7 @@ module SPDY
                 pckt = Control::Settings.new({:zlib_session => @zlib_session})
                 pckt.read(@buffer)
 
-                @on_settings.call(pckt.stream_id, pckt.status_code) if @on_settings
+                @on_settings.call(pckt.flags, pckt.headers) if @on_settings
 
               when 6 then # PING
                 pckt = Control::Ping.new({:zlib_session => @zlib_session})

data/vender/spdy/lib/spdy/protocol.rb

@@ -83,6 +83,7 @@ module SPDY
 
         def create(opts = {})
           build({:type => 1, :len => 10}.merge(opts))
+          self.associated_to_stream_id = opts.fetch(:associated_to_stream_id, 0)
         end
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: net-http-spdy
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-20 00:00:00.000000000 Z
+date: 2013-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bindata
@@ -51,6 +51,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
 - Gemfile
 - README.rdoc
 - Rakefile
@@ -63,8 +64,10 @@ files:
 - lib/net/http/spdy/stream_session.rb
 - lib/net/http/spdy/version.rb
 - net-http-spdy.gemspec
+- test/helper.rb
 - test/run-test.rb
 - test/test_access_to_web.rb
+- test/test_spdy.rb
 - vender/spdy/README.md
 - vender/spdy/lib/spdy.rb
 - vender/spdy/lib/spdy/compat.rb
@@ -97,5 +100,7 @@ signing_key:
 specification_version: 3
 summary: A SPDY HTTP client implementation with extended Net:HTTP
 test_files:
+- test/helper.rb
 - test/run-test.rb
 - test/test_access_to_web.rb
+- test/test_spdy.rb