net-http-spdy 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+pkg/

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+gemspec
+
+group :test do
+  gem 'test-unit', '~> 2.5.3'
+end

data/README.rdoc

@@ -0,0 +1,47 @@
+= net-http-spdy
+
+* https://github.com/authorNari/net-http-spdy
+
+== DESCRIPTION:
+
+A SPDY HTTP client implementation with extended Net:HTTP.
+
+== INSTALL:
+
+  gem install net-http-spdy
+
+== FEATURES/PROBLEMS:
+
+* Supports SSL/TLS in Ruby 2.0.0 or later
+
+== COMPARING:
+
+    % time ruby examples/https.rb
+    ruby examples/https.rb  0.12s user 0.01s system 4% cpu 2.766 total
+    % time ruby examples/spdy.rb
+    ruby examples/spdy.rb  0.38s user 0.03s system 26% cpu 1.553 total
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2013 Narihiro Nakamura
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+task :default => %w(test)
+
+task :test do
+  sh "/usr/bin/env ruby test/run-test.rb"
+end

data/examples/https.rb

@@ -0,0 +1,15 @@
+require 'net/http/persistent'
+
+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
+uri = URI('https://www.modspdy.com/')
+http = Net::HTTP::Persistent.new
+flag_uris.each do |uri|
+  http.request(uri)
+end

data/examples/spdy.rb

@@ -0,0 +1,23 @@
+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/')
+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)
+  end
+end
+fetch_threads.each(&:join)
+http.finish

data/lib/net/http/spdy.rb

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+require "bundler"
+Bundler.require(:default)
+require 'net/http'
+$: << File.join(File.dirname(__FILE__), "../../../vender/spdy/lib/")
+require 'spdy'
+require 'net/http/spdy/stream'
+require 'net/http/spdy/stream_session'
+require 'net/http/spdy/generic_request'
+require 'net/http/spdy/response'
+require 'openssl'
+
+class Net::HTTP::SPDY < Net::HTTP
+  def initialize(address, port = nil)
+    super
+    @npn_select_cb = ->(protocols) do
+      prot = protocols.detect{|pr| pr == "spdy/2"}
+      if prot.nil?
+        raise "This server doesn't support SPDYv2"
+      end
+      prot
+    end
+  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
+
+  def connect
+    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)
+    stream = @stream_session.create(req.uri)
+    res = nil
+    res = catch(:response) {
+      req.exec stream, @curr_http_version, edit_path(req.path)
+      begin
+        r = Net::HTTPResponse.read_new(stream)
+      end while res.kind_of?(Net::HTTPContinue)
+
+      r.uri = req.uri
+
+      r.reading_body(stream, req.response_body_permitted?) {
+        yield res if block_given?
+      }
+      r
+    }
+    stream.assocs.each do |s|
+      if not s.eof?
+        begin
+          r = Net::HTTPResponse.read_new(s)
+        end while r.kind_of?(Net::HTTPContinue)
+        yield r if block_given?
+        res.associated_responses << r
+      end
+    end
+
+    end_transport req, res
+    res
+  rescue => exception
+    D "Conn close because of error #{exception}"
+    @socket.close if @socket and not @socket.closed?
+    raise exception
+  end
+
+  def end_transport(req, res)
+    # nothing to do
+  end
+
+  def sspi_auth?(res)
+    return false
+  end
+
+  def keep_alive?(req, res)
+    return false
+  end
+
+  def proxy?
+    # TODO: supports proxy
+    return false
+  end
+end

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

@@ -0,0 +1,38 @@
+class Net::HTTPGenericRequest
+  attr_accessor :uri
+
+  alias exec_wo_spdy exec
+  def exec(sock, ver, path)   #:nodoc: internal use only
+    exec_wo_spdy(sock, ver, path)
+    if is_spdy?(sock) && (@body || @body_stream || @body_data)
+      sock.close_write
+    end
+  end
+
+  private
+  alias send_request_with_body_stream_wo_spdy send_request_with_body_stream
+  def send_request_with_body_stream(sock, ver, path, f)
+    if is_spdy?(sock)
+      stream = sock
+      write_header stream, ver, path
+      wait_for_continue stream, ver if stream.sock.continue_timeout
+      IO.copy_stream(f, stream)
+    else
+      send_request_with_body_stream_wo_spdy
+    end
+  end
+
+  alias write_header_wo_spdy write_header
+  def write_header(sock, ver, path)
+    if is_spdy?(sock)
+      stream = sock
+      stream.write_headers(@method, path, ver, self)
+    else
+      write_header_wo_spdy(sock, ver, path)
+    end
+  end
+
+  def is_spdy?(sock)
+    sock.kind_of?(Net::HTTP::SPDY::Stream)
+  end
+end

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

@@ -0,0 +1,17 @@
+class Net::HTTPResponse
+  if RUBY_VERSION <= "2.0.0"
+    attr_accessor :uri
+  end
+
+  attr_reader :associated_responses
+
+  def has_associatd_response?
+    @associated_responses ||= []
+    not @response.empty?
+  end
+
+  def associated_responses
+    @associated_responses ||= []
+    return @associated_responses
+  end
+end

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

@@ -0,0 +1,142 @@
+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
+
+  def initialize(id, session, sock, uri)
+    @id = id
+    @session = session
+    @sock = sock
+    @buf = ""
+    @eof = false
+    @uri = uri
+    @assocs = []
+    @new_assoc = nil
+    @connected = false
+  end
+
+  def eof?
+    @buf.empty? && (@eof || @sock.eof?)
+  end
+
+  def read(len, dest = '', ignore_eof = false)
+    while @buf.size < len
+      read_frame(ignore_eof)
+      break if ignore_eof && eof?
+    end
+    dest << rbuf_consume(len)
+    return dest
+  end
+
+  def read_all(dest = '')
+    dest << rbuf_consume(@buf.size)
+    until eof?
+      read_frame(false)
+      dest << rbuf_consume(@buf.size)
+    end
+    return dest
+  end
+
+  def readuntil(terminator, ignore_eof = false)
+    idx = @buf.index(terminator)
+    while idx.nil?
+      read_frame(ignore_eof)
+      idx = @buf.index(terminator)
+      idx = @buf.size if ignore_eof && eof?
+    end
+    return rbuf_consume(idx + terminator.size)
+  end
+
+  def readline
+    readuntil("\n").chop
+  end
+
+  def write(buf)
+    d = SPDY::Protocol::Data::Frame.new
+    d.create(stream_id: @id, data: buf)
+    @session.monitor.synchronize do
+      @sock.write d.to_binary_s
+    end
+  end
+  alias << write
+
+  def write_headers(method, path, ver, request)
+    h = {
+      'method' => method,
+      'url' => path,
+      'version' => "HTTP/#{ver}",
+      'scheme' => request.uri.scheme
+    }
+    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?
+    end
+
+    sr = SPDY::Protocol::Control::SynStream.new(zlib_session: @session.parser.zlib_session)
+    request.each_header do |key, value|
+      h[key.downcase] = value
+    end
+    if request.request_body_permitted?
+      sr.create(stream_id: @id, headers: h)
+    else
+      sr.create(stream_id: @id, headers: h, flags: 1)
+    end
+    @sock.debug_output.puts h if @sock.debug_output
+    @session.monitor.synchronize do
+      # wait to open a lower stream
+      @session.monitor_cond.wait_while do
+        @session.streams.detect{|s| s.id < @id && !s.connected }
+      end
+      @sock.write sr.to_binary_s
+      @connected = true
+      @session.monitor_cond.broadcast
+    end
+  end
+
+  def close_write
+    d = SPDY::Protocol::Data::Frame.new
+    d.create(stream_id: @id, flags: 1)
+    @session.monitor.synchronize do
+      @sock.write d.to_binary_s
+    end
+  end
+
+  private
+
+  BUFSIZE = 1024 * 16
+  def read_frame(ignore_eof)
+    while buf.empty?
+      raise EOFError if eof? && !ignore_eof
+      begin
+        @session.monitor.synchronize do
+          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
+        end
+      end
+    end
+  rescue EOFError
+    raise unless ignore_eof
+  end
+
+  def rbuf_consume(len)
+    @buf.slice!(0, len)
+  end
+end

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

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+require 'monitor'
+
+class Net::HTTP::SPDY
+  class StreamError < StandardError; end
+
+  class StreamSession
+    attr_reader :parser, :monitor, :monitor_cond
+
+    def initialize(sock)
+      @sock = sock
+      @highest_id = -1
+      @streams = {}
+      @parser = create_parser
+      @monitor = Monitor.new
+      @monitor_cond = @monitor.new_cond
+    end
+  
+    def create(uri)
+      @monitor.synchronize do
+        @highest_id += 2
+      end
+      return push(@highest_id, uri)
+    end
+  
+    def known?(id)
+      @streams.has_key?(id)
+    end
+  
+    def push(id, uri, connected=false)
+      s = Stream.new(id, self, @sock, uri)
+      s.connected = connected
+      @streams[id] = s
+      return @streams[id]
+    end
+  
+    def parse(buf)
+      @parser << buf
+    end
+  
+    def streams
+      @streams.values
+    end
+  
+    private
+  
+    def create_parser
+      parser = SPDY::Parser.new
+      parser.on_open do |id, assoc_id, pri|
+        @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
+        end
+      end
+      parser.on_headers do |id, headers|
+        @sock.debug_output.puts "on_headers: id=<#{id}>, headers=<#{headers}>" if @sock.debug_output
+        s = @streams.fetch(id)
+        if s.new_assoc
+          # TODO: check invalid header and send PROTOCOL_ERROR
+          uri = URI(headers.delete('url'))
+          assoc = push(assoc_id, uri, true)
+          s.new_assoc = nil
+          s.assocs << assoc
+        else
+          s = @streams.fetch(id)
+        end
+  
+        # TODO: check invalid header
+        h = ["#{headers['version']} #{headers['status']}"]
+        code, msg = headers.delete('status').split(" ")
+        r = ::Net::HTTPResponse.new(headers.delete('version'), code, msg)
+        r.each_capitalized{|k,v| h << "#{k}: #{v}" }
+        h << "\r\n"
+  
+        @sock.debug_output.puts %Q[->#{h.join("\r\n").dump}] if @sock.debug_output
+        s.buf << h.join("\r\n")
+      end
+      parser.on_body do |id, data|
+        @sock.debug_output.puts "on_body: id=<#{id}>" if @sock.debug_output
+        s = @streams.fetch(id)
+        @sock.debug_output.puts %Q[->#{data.dump}] if @sock.debug_output
+        s.buf << data
+      end
+      parser.on_message_complete do |id|
+        @sock.debug_output.puts "on_message_complete: id=<#{id}>" if @sock.debug_output
+        # TODO: send frame to close
+        @streams.fetch(id).eof = true
+        @streams.delete(id)
+      end
+      parser.on_reset do |id, status|
+        @sock.debug_output.puts "on_reset: id=<#{id}>, status=<#{status}>" if @sock.debug_output
+        case status
+        when 1
+          raise StreamError, 'received PROTOCOL_ERROR'
+        when 2
+          raise StreamError, 'received INVALID_STREAM'
+        when 3
+          raise StreamError, 'received REFUSED_STREAM'
+        when 4
+          raise StreamError, 'received UNSUPPORTED_VERSION'
+        when 5
+          raise StreamError, 'received CANCEL'
+        when 6
+          raise StreamError, 'received INTERNAL_ERROR'
+        when 7
+          raise StreamError, 'received FLOW_CONTROL_ERROR'
+        end
+      end
+      return parser
+    end
+  end
+end

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

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

data/net-http-spdy.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "net/http/spdy/version"
+
+Gem::Specification.new do |s|
+  s.name        = "net-http-spdy"
+  s.version     = Net::HTTP::SPDY::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Narihiro Nakamura"]
+  s.email       = ["authornari@gmail.com"]
+  s.homepage    = "https://github.com/authorNari/spdy"
+  s.summary     = "A SPDY HTTP client implementation atop Net:HTTP"
+  s.description = s.summary
+
+  s.files         = `git ls-files`.split($\)
+  s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.name          = "net-http-spdy"
+  s.require_paths = ["lib"]
+
+  s.add_dependency "bindata"
+  s.add_dependency "ffi-zlib"
+end

data/test/run-test.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+base_dir = File.expand_path(File.dirname(__FILE__))
+top_dir = File.expand_path("..", base_dir)
+$LOAD_PATH.unshift(File.join(top_dir, "lib"))
+$LOAD_PATH.unshift(File.join(top_dir, "test"))
+
+require "bundler"
+Bundler.require(:default, :test)
+require "test/unit"
+
+require "net/http/spdy"
+
+test_file = "./test/test_*.rb"
+Dir.glob(test_file) do |file|
+  require file
+end

data/test/test_access_to_web.rb

@@ -0,0 +1,40 @@
+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
+
+  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
+end

data/vender/spdy/README.md

@@ -0,0 +1,43 @@
+# SPDY
+
+SPDY is an experimental protocol designed to reduce latency of web pages. The SPDY v2 draft is the foundation for the HTTP 2.0 initiative led by the HTTPbis working group. 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 support is available in Chrome, Firefox, and Opera on the client, and on Apache, Nginx, Jetty, node.js and others on the server. All of Google web services, when running over SSL, are available through SPDY! In other words, if you are using Google products over SSL, chances are, you are fetching the content from Google servers over SPDY, not HTTP.
+
+* [HTTPBis - HTTP 2.0 Charter](http://datatracker.ietf.org/wg/httpbis/charter/)
+* [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 connection. This gem implements a basic, pure Ruby parser for the SPDY v2 protocol:
+
+```ruby
+s = SPDY::Parser.new
+
+s.on_headers_complete { |stream_id, 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:
+
+```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
+
+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.
+
+### License
+
+MIT License - Copyright (c) 2011 Ilya Grigorik

data/vender/spdy/lib/spdy.rb

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

data/vender/spdy/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/vender/spdy/lib/spdy/compressor.rb

@@ -0,0 +1,79 @@
+module SPDY
+  class 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 initialize
+      @inflate_zstream = FFI::Zlib::Z_stream.new
+      result = FFI::Zlib.inflateInit(@inflate_zstream)
+      raise "invalid stream" if result != FFI::Zlib::Z_OK
+
+      @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.deflateSetDictionary(@deflate_zstream, DICT, DICT.size)
+      raise "invalid dictionary" if result != FFI::Zlib::Z_OK
+    end
+
+    def reset
+      result = FFI::Zlib.inflateReset(@inflate_zstream)
+      raise "invalid stream" if result != FFI::Zlib::Z_OK
+
+      result = FFI::Zlib.deflateReset(@deflate_zstream)
+      raise "invalid stream" if result != FFI::Zlib::Z_OK
+    end
+
+    def inflate(data)
+      in_buf  = FFI::MemoryPointer.from_string(data)
+      out_buf = FFI::MemoryPointer.new(CHUNK)
+
+      @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.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
+
+      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(@deflate_zstream, FFI::Zlib::Z_SYNC_FLUSH)
+      raise "cannot deflate" if result != FFI::Zlib::Z_OK
+
+      out_buf.get_bytes(0, CHUNK - @deflate_zstream[:avail_out])
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+module SPDY
+  class Parser
+    include Protocol
+
+    attr :zlib_session
+
+    def initialize
+      @buffer = ''
+      @zlib_session = Zlib.new
+    end
+
+    def <<(data)
+      @buffer << data
+      try_parse
+    end
+
+    def on_open(&blk)
+      @on_open = blk
+    end
+
+    def on_ping(&blk)
+      @on_ping = blk
+    end
+
+    def on_headers(&blk)
+      @on_headers = blk
+    end
+
+    def on_settings(&blk)
+      @on_settings = blk
+    end
+
+    def on_body(&blk)
+      @on_body = blk
+    end
+
+    def on_message_complete(&blk)
+      @on_message_complete = blk
+    end
+
+    def on_reset(&blk)
+      @on_reset = blk
+    end
+
+    private
+
+      def handle_headers(pckt)
+        headers = pckt.uncompressed_data.to_h
+        if @on_headers && !headers.empty?
+          @on_headers.call(pckt.header.stream_id.to_i,
+                          headers)
+        end
+      end
+
+      def try_parse
+        return if @buffer.empty?
+        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({:zlib_session => @zlib_session})
+                pckt.parse(@buffer)
+
+                if @on_open
+                  @on_open.call(pckt.header.stream_id.to_i,
+                                (pckt.associated_to_stream_id.to_i rescue nil),
+                                (pckt.pri.to_i rescue nil))
+                end
+                handle_headers(pckt)
+
+                @on_message_complete.call(pckt.header.stream_id) if @on_message_complete && fin?(pckt.header)
+
+              when 2 then # SYN_REPLY
+                pckt = Control::SynReply.new({:zlib_session => @zlib_session})
+                pckt.parse(@buffer)
+                handle_headers(pckt)
+
+                @on_message_complete.call(pckt.header.stream_id) if @on_message_complete && fin?(pckt.header)
+
+              when 3 then # RST_STREAM
+                return if @buffer.size < 16
+                pckt = Control::RstStream.new({:zlib_session => @zlib_session})
+                pckt.read(@buffer)
+
+                @on_reset.call(pckt.stream_id, pckt.status_code) if @on_reset
+
+              when 4 then # SETTINGS
+                return if @buffer.size < 16
+                pckt = Control::Settings.new({:zlib_session => @zlib_session})
+                pckt.read(@buffer)
+
+                @on_settings.call(pckt.stream_id, pckt.status_code) if @on_settings
+
+              when 6 then # PING
+                pckt = Control::Ping.new({:zlib_session => @zlib_session})
+                pckt.read(@buffer)
+
+                @on_ping.call(pckt.ping_id) if @on_ping
+
+
+
+              when 8 then # HEADERS
+                pckt = Control::Headers.new({:zlib_session => @zlib_session})
+                pckt.parse(@buffer)
+
+                @on_headers.call(pckt.header.stream_id, pckt.uncompressed_data.to_h) if @on_headers
+
+              else
+                raise "invalid control frame: #{pckt.type}"
+            end
+
+          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)
+
+        # try parsing another frame
+        try_parse
+
+      rescue IOError => e
+        # rescue partial parse and wait for more data
+      end
+
+    private
+
+      def fin?(packet)
+        (packet.flags == 1) rescue false
+      end
+
+  end
+end

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

@@ -0,0 +1,269 @@
+module SPDY
+  module Protocol
+
+    CONTROL_BIT = 1
+    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)
+
+          if data.length > 0
+            data = @zlib_session.inflate(self.data.to_s)
+            self.uncompressed_data = NV.new.read(data)
+          else
+            self.uncompressed_data = NV.new
+          end
+
+          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 = @zlib_session.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
+
+        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
+        attr_accessor :uncompressed_data
+        include Helpers
+
+        hide :u1, :u2
+
+        header :header
+
+        bit1  :u1
+        bit31 :associated_to_stream_id
+
+        bit2  :pri
+        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 create(opts = {})
+          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
+      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.downcase, :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/vender/spdy/lib/spdy/version.rb

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

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: net-http-spdy
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Narihiro Nakamura
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bindata
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ffi-zlib
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A SPDY HTTP client implementation atop Net:HTTP
+email:
+- authornari@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- examples/https.rb
+- examples/spdy.rb
+- lib/net/http/spdy.rb
+- lib/net/http/spdy/generic_request.rb
+- lib/net/http/spdy/response.rb
+- lib/net/http/spdy/stream.rb
+- lib/net/http/spdy/stream_session.rb
+- lib/net/http/spdy/version.rb
+- net-http-spdy.gemspec
+- test/run-test.rb
+- test/test_access_to_web.rb
+- vender/spdy/README.md
+- vender/spdy/lib/spdy.rb
+- vender/spdy/lib/spdy/compat.rb
+- vender/spdy/lib/spdy/compressor.rb
+- vender/spdy/lib/spdy/parser.rb
+- vender/spdy/lib/spdy/protocol.rb
+- vender/spdy/lib/spdy/version.rb
+homepage: https://github.com/authorNari/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: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A SPDY HTTP client implementation atop Net:HTTP
+test_files:
+- test/run-test.rb
+- test/test_access_to_web.rb