RubyGems - reel - Versions diffs - 0.4.0 → 0.5.0.pre - Mend

reel 0.4.0 → 0.5.0.pre

Potentially problematic release.

This version of reel might be problematic. Click here for more details.

Files changed (49) hide show

checksums.yaml +4 -4
data/.travis.yml +5 -2
data/Gemfile +6 -0
data/README.md +26 -16
data/benchmarks/hello_reel.rb +1 -1
data/benchmarks/reel_pool.rb +27 -0
data/examples/hello_world.rb +2 -2
data/examples/{ssl_hello_world.rb → https_hello_world.rb} +1 -1
data/examples/roundtrip.rb +1 -1
data/examples/server_sent_events.rb +22 -18
data/examples/spy_hello_world.rb +22 -0
data/examples/websockets.rb +3 -3
data/lib/reel.rb +6 -9
data/lib/reel/connection.rb +40 -42
data/lib/reel/mixins.rb +3 -1
data/lib/reel/request.rb +40 -9
data/lib/reel/request/body.rb +65 -0
data/lib/reel/request/info.rb +21 -0
data/lib/reel/{request_parser.rb → request/parser.rb} +2 -2
data/lib/reel/request/state_machine.rb +26 -0
data/lib/reel/response.rb +4 -11
data/lib/reel/response/writer.rb +59 -0
data/lib/reel/server.rb +30 -6
data/lib/reel/server/http.rb +20 -0
data/lib/reel/server/https.rb +63 -0
data/lib/reel/spy.rb +71 -0
data/lib/reel/stream.rb +2 -2
data/lib/reel/version.rb +2 -2
data/lib/reel/websocket.rb +1 -1
data/reel.gemspec +3 -3
data/spec/fixtures/ca.crt +27 -0
data/spec/fixtures/ca.key +27 -0
data/spec/fixtures/client.crt +81 -20
data/spec/fixtures/client.unsigned.crt +22 -0
data/spec/fixtures/server.crt +80 -20
data/spec/reel/connection_spec.rb +50 -11
data/spec/reel/{server_spec.rb → http_server_spec.rb} +1 -1
data/spec/reel/https_server_spec.rb +119 -0
data/spec/reel/{response_writer_spec.rb → response/writer_spec.rb} +10 -2
data/spec/reel/websocket_spec.rb +2 -2
data/spec/spec_helper.rb +3 -34
data/spec/support/example_request.rb +34 -0
metadata +56 -43
data/examples/chunked.rb +0 -25
data/lib/reel/request_body.rb +0 -56
data/lib/reel/request_info.rb +0 -19
data/lib/reel/response_writer.rb +0 -76
data/lib/reel/ssl_server.rb +0 -41
data/spec/reel/ssl_server_spec.rb +0 -54

data/examples/chunked.rb DELETED Viewed

@@ -1,25 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-require 'reel'
-app = Rack::Builder.new do
-  map '/' do
-    run lambda { |env|
-      body = Reel::ChunkStream.new do |body|
-        # sending a payload to make sure browsers will render chunks as received
-        body << "<html>#{' '*1024}\n"
-        ('A'..'Z').each do |l|
-          body << "<div>#{l}</div>\n"
-          sleep 0.5
-        end
-        body << "</html>\n"
-        body.finish
-      end
-      [200, {
-        'Content-Type' => 'text/html'
-        }, body]
-    }
-  end
-end.to_app
-Rack::Handler::Reel.run app, Port: 9292

data/lib/reel/request_body.rb DELETED Viewed

@@ -1,56 +0,0 @@
-module Reel
-  # Represents the bodies of Requests
-  class RequestBody
-    include Enumerable
-    def initialize(request)
-      @request   = request
-      @streaming = nil
-      @contents  = nil
-    end
-    # Read exactly the given amount of data
-    def read(length)
-      stream!
-      @request.read(length)
-    end
-    # Read up to length bytes, but return any data that's available
-    def readpartial(length = nil)
-      stream!
-      @request.readpartial(length)
-    end
-    # Iterate over the body, allowing it to be enumerable
-    def each
-      while chunk = readpartial
-        yield chunk
-      end
-    end
-    # Eagerly consume the entire body as a string
-    def to_s
-      return @contents if @contents
-      raise StateError, "body is being streamed" unless @streaming.nil?
-      begin
-        @streaming = false
-        @contents = ""
-        while chunk = @request.readpartial
-          @contents << chunk
-        end
-      rescue
-        @contents = nil
-        raise
-      end
-      @contents
-    end
-    # Assert that the body is actively being streamed
-    def stream!
-      raise StateError, "body has already been consumed" if @streaming == false
-      @streaming = true
-    end
-  end
-end

data/lib/reel/request_info.rb DELETED Viewed

@@ -1,19 +0,0 @@
-module Reel
-  class RequestInfo
-    attr_reader :http_method, :url, :http_version, :headers
-    def initialize(http_method, url, http_version, headers)
-      @http_method  = http_method
-      @url          = url
-      @http_version = http_version
-      @headers      = headers
-    end
-    UPGRADE   = 'Upgrade'.freeze
-    WEBSOCKET = 'websocket'.freeze
-    def websocket_request?
-      headers[UPGRADE] && headers[UPGRADE].downcase == WEBSOCKET
-    end
-  end
-end

data/lib/reel/response_writer.rb DELETED Viewed

@@ -1,76 +0,0 @@
-module Reel
-  class Response
-    class Writer
-      CRLF = "\r\n"
-      def initialize(socket)
-        @socket = socket
-      end
-      # Write body chunks directly to the connection
-      def write(chunk)
-        chunk_header = chunk.bytesize.to_s(16)
-        @socket << chunk_header + CRLF
-        @socket << chunk + CRLF
-      rescue IOError, Errno::EPIPE, Errno::ECONNRESET => ex
-        raise Reel::SocketError, ex.to_s
-      end
-      # Finish the response and reset the response state to header
-      def finish_response
-        @socket << "0#{CRLF * 2}"
-      end
-      # Takes a Reel::Response and renders it
-      # back over the socket.
-      def handle_response(response)
-        @socket << render_header(response)
-        if response.respond_to?(:render)
-          response.render(@socket)
-        else
-          case response.body
-          when String
-            @socket << response.body
-          when IO
-            begin
-              if defined?(JRUBY_VERSION) && JRUBY_VERSION <= "1.6.7"
-                # JRuby 1.6.7 doesn't support IO.copy_stream :(
-                while data = response.body.read(4096)
-                  @socket << data
-                end
-              else
-                # Use OS sendfile via IO.copy_stream
-                # FIXME: should use Celluloid::IO.copy_stream and allow these
-                # calls to be multiplexed through Celluloid::IO's reactor
-                # Until then we need a thread for each of these responses
-                Celluloid.defer { IO.copy_stream(response.body, @socket.to_io) }
-                # @socket currently not being converted to appropriate IO object automatically.
-                # Convert the object in advance to still enjoy IO.copy_stream coverage.
-              end
-            ensure
-              response.body.close
-            end
-          when Enumerable
-            response.body.each do |chunk|
-              write(chunk)
-            end
-            finish_response
-          end
-        end
-      end
-      # Convert headers into a string
-      def render_header(response)
-        response_header = "#{response.version} #{response.status} #{response.reason}#{CRLF}"
-        unless response.headers.empty?
-          response_header << response.headers.map do |header, value|
-            "#{header}: #{value}"
-          end.join(CRLF) << CRLF
-        end
-        response_header << CRLF
-      end
-      private :render_header
-    end
-  end
-end

data/lib/reel/ssl_server.rb DELETED Viewed

@@ -1,41 +0,0 @@
-module Reel
-  class SSLServer < Server
-    execute_block_on_receiver :initialize
-    def initialize(host, port, options = {}, &callback)
-      backlog = options.fetch(:backlog, DEFAULT_BACKLOG)
-      # Ideally we can encapsulate this rather than making Ruby OpenSSL a
-      # mandatory part of the Reel API. It would be nice to support
-      # alternatives (e.g. Puma's MiniSSL)
-      ssl_context      = OpenSSL::SSL::SSLContext.new
-      ssl_context.cert = OpenSSL::X509::Certificate.new options.fetch(:cert)
-      ssl_context.key  = OpenSSL::PKey::RSA.new options.fetch(:key)
-      # We don't presently support verifying client certificates
-      # TODO: support client certificates!
-      ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      @tcpserver  = Celluloid::IO::TCPServer.new(host, port)
-      @server     = Celluloid::IO::SSLServer.new(@tcpserver, ssl_context)
-      @server.listen(backlog)
-      @callback = callback
-      async.run
-    end
-    def run
-      loop do
-        begin
-          socket = @server.accept
-        rescue OpenSSL::SSL::SSLError => ex
-          Logger.warn "Error accepting SSLSocket: #{ex.class}: #{ex.to_s}"
-          retry
-        end
-        async.handle_connection socket
-      end
-    end
-  end
-end

data/spec/reel/ssl_server_spec.rb DELETED Viewed

@@ -1,54 +0,0 @@
-require 'spec_helper'
-require 'net/http'
-describe Reel::SSLServer do
-  let(:example_ssl_port) { example_port + 1 }
-  let(:example_url)      { "https://#{example_addr}:#{example_ssl_port}#{example_path}" }
-  let(:endpoint)         { URI(example_url) }
-  let(:response_body)    { "ohai thar" }
-  let(:server_cert) { fixture_dir.join("server.crt").read }
-  let(:server_key)  { fixture_dir.join("server.key").read }
-  it "receives HTTP requests and sends responses" do
-    ex = nil
-    handler = proc do |connection|
-      begin
-        request = connection.request
-        request.method.should eq 'GET'
-        request.version.should eq "1.1"
-        request.url.should eq example_path
-        connection.respond :ok, response_body
-      rescue => ex
-      end
-    end
-    with_reel_sslserver(handler) do
-      http = Net::HTTP.new(endpoint.host, endpoint.port)
-      http.use_ssl = true
-      # FIXME: VERIFY_NONE is bad! Authenticate the server cert!
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      request = Net::HTTP::Get.new(endpoint.path)
-      response = http.request(request)
-      response.body.should eq response_body
-    end
-    raise ex if ex
-  end
-  def with_reel_sslserver(handler, context = OpenSSL::SSL::SSLContext.new)
-    options = {
-      :cert => server_cert,
-      :key  => server_key
-    }
-    server = Reel::SSLServer.new(example_addr, example_ssl_port, options, &handler)
-    yield server
-  ensure
-    server.terminate if server && server.alive?
-  end
-end