reel 0.5.0 → 0.6.0.pre1

data/lib/reel/version.rb

@@ -1,4 +1,4 @@
 module Reel
-  VERSION  = "0.5.0"
-  CODENAME = "Bette"
+  VERSION  = "0.6.0.pre1"
+  CODENAME = "Garland"
 end

data/lib/reel/websocket.rb

@@ -1,5 +1,6 @@
 require 'forwardable'
-require 'websocket_parser'
+require 'websocket/driver'
+require 'rack'
 
 module Reel
   class WebSocket
@@ -10,42 +11,32 @@ module Reel
     attr_reader :socket
     def_delegators :@socket, :addr, :peeraddr
 
-    def initialize(info, socket)
+    def initialize(info, connection)
+      driver_env = DriverEnvironment.new(info, connection.socket)      
+      
+      @socket = connection.hijack_socket
       @request_info = info
-      @socket = socket
 
-      handshake = ::WebSocket::ClientHandshake.new(:get, url, headers)
-
-      if handshake.valid?
-        response = handshake.accept_response
-        response.render(socket)
-      else
-        error = handshake.errors.first
-
-        response = Response.new(400)
-        response.reason = handshake.errors.first
-        response.render(@socket)
-
-        raise HandshakeError, "error during handshake: #{error}"
+      @driver = ::WebSocket::Driver.rack(driver_env)
+      @driver.on(:close) do
+        @socket.close
       end
 
-      @parser = ::WebSocket::Parser.new
-
-      @parser.on_close do |status, reason|
-        # According to the spec the server must respond with another
-        # close message before closing the connection
-        @socket << ::WebSocket::Message.close.to_data
-        close
-      end
+      @message_stream = MessageStream.new(@socket, @driver)
+      @driver.start
+    rescue EOFError
+      close
+    end
 
-      @parser.on_ping do |payload|
-        @socket << ::WebSocket::Message.pong(payload).to_data
+    def on_message(&block)
+      @driver.on :message do |message|
+        block.(message.data)
       end
     end
 
-    [:next_message, :next_messages, :on_message, :on_error, :on_close, :on_ping, :on_pong].each do |meth|
-      define_method meth do |&proc|
-        @parser.send __method__, &proc
+    [:error, :close, :ping, :pong].each do |meth|
+      define_method "on_#{meth}" do |&proc|
+        @driver.send(:on, meth, &proc)
       end
     end
 
@@ -65,20 +56,21 @@ module Reel
     alias read_frequency read_every
 
     def read
-      @parser.append @socket.readpartial(Connection::BUFFER_SIZE) until msg = @parser.next_message
-      msg
-    rescue
-      cancel_timer!
-      raise
+      @message_stream.read
     end
 
-    def body
-      nil
+    def closed?
+      @socket.closed?
     end
 
     def write(msg)
-      @socket << ::WebSocket::Message.new(msg).to_data
-      msg
+      if msg.is_a? String
+        @driver.text(msg)
+      elsif msg.is_a? Array
+        @driver.binary(msg)
+      else
+        raise "Can only send byte array or string over driver."
+      end
     rescue IOError, Errno::ECONNRESET, Errno::EPIPE
       cancel_timer!
       raise SocketError, "error writing to socket"
@@ -88,18 +80,59 @@ module Reel
     end
     alias_method :<<, :write
 
-    def closed?
-      @socket.closed?
-    end
-
     def close
-      cancel_timer!
-      @socket.close unless closed?
+      @driver.close
+      @socket.close
     end
 
     def cancel_timer!
       @timer && @timer.cancel
     end
 
+    private
+
+    class DriverEnvironment
+      extend Forwardable
+
+      attr_reader :env, :url, :socket
+
+      def_delegators :socket, :write
+
+      def initialize(info, socket)
+        @url = info.url
+
+        env_hash = Hash[info.headers.map { |key, value| ['HTTP_' + key.upcase.gsub('-','_'),value ] }]
+        
+        env_hash.merge!({
+          :method       => info.method,
+          :input        => info.body.to_s,
+          'REMOTE_ADDR' => info.remote_addr
+        })
+
+        @env = ::Rack::MockRequest.env_for(@url, env_hash)
+
+        @socket = socket
+      end
+    end
+
+    class MessageStream
+      def initialize(socket, driver)
+        @socket = socket
+        @driver = driver
+        @message_buffer = []
+
+        @driver.on :message do |message|
+          @message_buffer.push(message.data)
+        end
+      end
+
+      def read
+        while @message_buffer.empty?
+          buffer = @socket.readpartial(Connection::BUFFER_SIZE)
+          @driver.parse(buffer)
+        end
+        @message_buffer.shift
+      end
+    end
   end
 end

data/reel.gemspec

@@ -19,8 +19,11 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency 'celluloid-io',     '>= 0.15.0'
   gem.add_runtime_dependency 'http',             '>= 0.6.0.pre'
   gem.add_runtime_dependency 'http_parser.rb',   '>= 0.6.0'
-  gem.add_runtime_dependency 'websocket_parser', '>= 0.1.6'
+  gem.add_runtime_dependency 'websocket-driver', '>= 0.5.1'
+  gem.add_runtime_dependency 'rack'
 
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec', '>= 2.11.0'
+  gem.add_development_dependency 'certificate_authority'
+  gem.add_development_dependency 'websocket_parser', '>= 0.1.6'
 end

data/spec/reel/connection_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Reel::Connection do
+RSpec.describe Reel::Connection do
   let(:fixture_path) { File.expand_path("../../fixtures/example.txt", __FILE__) }
 
   it "reads requests without bodies" do
@@ -9,16 +9,16 @@ describe Reel::Connection do
       client << ExampleRequest.new.to_s
       request = connection.request
 
-      request.url.should     eq "/"
-      request.version.should eq "1.1"
+      expect(request.url).to     eq "/"
+      expect(request.version).to eq "1.1"
 
-      request['Host'].should eq "www.example.com"
-      request['Connection'].should eq "keep-alive"
-      request['User-Agent'].should eq "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_3) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.78 S"
-      request['Accept'].should eq "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
-      request['Accept-Encoding'].should eq "gzip,deflate,sdch"
-      request['Accept-Language'].should eq "en-US,en;q=0.8"
-      request['Accept-Charset'].should eq "ISO-8859-1,utf-8;q=0.7,*;q=0.3"
+      expect(request['Host']).to eq "www.example.com"
+      expect(request['Connection']).to eq "keep-alive"
+      expect(request['User-Agent']).to eq "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_3) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.78 S"
+      expect(request['Accept']).to eq "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+      expect(request['Accept-Encoding']).to eq "gzip,deflate,sdch"
+      expect(request['Accept-Language']).to eq "en-US,en;q=0.8"
+      expect(request['Accept-Charset']).to eq "ISO-8859-1,utf-8;q=0.7,*;q=0.3"
     end
   end
 
@@ -32,10 +32,10 @@ describe Reel::Connection do
       client << example_request.to_s
       request = connection.request
 
-      request.url.should     eq "/"
-      request.version.should eq "1.1"
-      request['Content-Length'].should eq body.length.to_s
-      request.body.to_s.should eq example_request.body
+      expect(request.url).to     eq "/"
+      expect(request.version).to eq "1.1"
+      expect(request['Content-Length']).to eq body.length.to_s
+      expect(request.body.to_s).to eq example_request.body
     end
   end
 
@@ -52,7 +52,7 @@ describe Reel::Connection do
       end
 
       response = client.read(4096)
-      response[(response.length - fixture_text.length)..-1].should eq fixture_text
+      expect(response[(response.length - fixture_text.length)..-1]).to eq fixture_text
     end
   end
 
@@ -64,12 +64,12 @@ describe Reel::Connection do
       request_count = 0
       connection.each_request do |request|
         request_count += 1
-        request.url.should eq "/"
+        expect(request.url).to eq "/"
         request.respond :ok
         client.close
       end
 
-      request_count.should eq 1
+      expect(request_count).to eq 1
     end
   end
 
@@ -95,7 +95,7 @@ describe Reel::Connection do
 
       crlf = "\r\n"
       fixture = "5#{crlf}Hello#{crlf}5#{crlf}World#{crlf}0#{crlf*2}"
-      response[(response.length - fixture.length)..-1].should eq fixture
+      expect(response[(response.length - fixture.length)..-1]).to eq fixture
     end
 
     it "with keep-alive" do
@@ -148,14 +148,33 @@ describe Reel::Connection do
       example_request = ExampleRequest.new(:get, "/", "1.1", {'Connection' => 'close'})
       client << example_request
 
-      connection.request.should_not be_nil
+      expect(connection.request).not_to be_nil
 
       connection.respond :ok, "Response sent"
 
-      connection.request.should be_nil
+      expect(connection.request).to be_nil
     end
   end
 
+  it "resets if client dropped connection" do
+    with_socket_pair do |client, peer|
+      connection = Reel::Connection.new(peer)
+      example_request = ExampleRequest.new
+      client << example_request
+
+      expect(connection.request).not_to be_nil
+
+      client.close # client drops connection
+      # now send more than the send buffer can hold, triggering a
+      # error (ECONNRESET or EPIPE)
+      connection.respond :ok, ("Some Big Response sent"*100000)
+
+      # connection should be at end
+      expect(connection.request).to be_nil
+    end
+  end
+
+
   it "raises an error trying to read two pipelines without responding first" do
     with_socket_pair do |client, peer|
       connection = Reel::Connection.new(peer)
@@ -179,16 +198,16 @@ describe Reel::Connection do
       3.times do
         request = connection.request
 
-        request.url.should     eq "/"
-        request.version.should eq "1.1"
+        expect(request.url).to     eq "/"
+        expect(request.version).to eq "1.1"
 
-        request['Host'].should eq "www.example.com"
-        request['Connection'].should eq "keep-alive"
-        request['User-Agent'].should eq "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_3) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.78 S"
-        request['Accept'].should eq "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
-        request['Accept-Encoding'].should eq "gzip,deflate,sdch"
-        request['Accept-Language'].should eq "en-US,en;q=0.8"
-        request['Accept-Charset'].should eq "ISO-8859-1,utf-8;q=0.7,*;q=0.3"
+        expect(request['Host']).to eq "www.example.com"
+        expect(request['Connection']).to eq "keep-alive"
+        expect(request['User-Agent']).to eq "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_3) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.78 S"
+        expect(request['Accept']).to eq "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+        expect(request['Accept-Encoding']).to eq "gzip,deflate,sdch"
+        expect(request['Accept-Language']).to eq "en-US,en;q=0.8"
+        expect(request['Accept-Charset']).to eq "ISO-8859-1,utf-8;q=0.7,*;q=0.3"
         connection.respond :ok, {}, ""
       end
     end
@@ -210,10 +229,10 @@ describe Reel::Connection do
         request = connection.request
 
         expected_body = "Hello, world number #{i}!"
-        request.url.should     eq "/"
-        request.version.should eq "1.1"
-        request['Content-Length'].should eq expected_body.length.to_s
-        request.body.to_s.should eq expected_body
+        expect(request.url).to     eq "/"
+        expect(request.version).to eq "1.1"
+        expect(request['Content-Length']).to eq expected_body.length.to_s
+        expect(request.body.to_s).to eq expected_body
 
         connection.respond :ok, {}, ""
       end
@@ -236,16 +255,16 @@ describe Reel::Connection do
         request = connection.request
 
         expected_body = "Hello, world number #{i}!"
-        request.url.should     eq "/"
-        request.version.should eq "1.1"
-        request['Content-Length'].should eq expected_body.length.to_s
-        request.should_not be_finished_reading
+        expect(request.url).to     eq "/"
+        expect(request.version).to eq "1.1"
+        expect(request['Content-Length']).to eq expected_body.length.to_s
+        expect(request).not_to be_finished_reading
         new_content = ""
         while chunk = request.body.readpartial(1)
           new_content << chunk
         end
-        new_content.should == expected_body
-        request.should be_finished_reading
+        expect(new_content).to eq(expected_body)
+        expect(request).to be_finished_reading
 
         connection.respond :ok, {}, ""
       end
@@ -264,9 +283,9 @@ describe Reel::Connection do
       client << example_request.to_s
 
       request = connection.request
-      request.should be_a(Reel::Request)
+      expect(request).to be_a(Reel::Request)
       client << content
-      request.body.to_s.should == content
+      expect(request.body.to_s).to eq(content)
     end
   end
 
@@ -280,7 +299,7 @@ describe Reel::Connection do
       client << example_request.to_s
 
       request = connection.request
-      timers = Timers.new
+      timers = Timers::Group.new
       timers.after(0.2){
         client << content
       }
@@ -291,8 +310,8 @@ describe Reel::Connection do
       }
       timers.wait
 
-      request.should be_a(Reel::Request)
-      read_body.should == content[0..7]
+      expect(request).to be_a(Reel::Request)
+      expect(read_body).to eq(content[0..7])
     end
   end
 
@@ -306,16 +325,16 @@ describe Reel::Connection do
       client << example_request.to_s
 
       request = connection.request
-      request.should be_a(Reel::Request)
-      request.should_not be_finished_reading
+      expect(request).to be_a(Reel::Request)
+      expect(request).not_to be_finished_reading
       client << content
       rebuilt = []
       connection.readpartial(64) # Buffer some body
       while chunk = request.read(8)
         rebuilt << chunk
       end
-      request.should be_finished_reading
-      rebuilt.should == ["I'm data", " you can", " stream!"]
+      expect(request).to be_finished_reading
+      expect(rebuilt).to eq(["I'm data", " you can", " stream!"])
     end
   end
 
@@ -330,15 +349,15 @@ describe Reel::Connection do
         client << example_request.to_s
 
         request = connection.request
-        request.should be_a(Reel::Request)
-        request.should_not be_finished_reading
+        expect(request).to be_a(Reel::Request)
+        expect(request).not_to be_finished_reading
         client << content
         rebuilt = []
         while chunk = request.body.readpartial(8)
           rebuilt << chunk
         end
-        request.should be_finished_reading
-        rebuilt.should == ["I'm data", " you can", " stream!"]
+        expect(request).to be_finished_reading
+        expect(rebuilt).to eq(["I'm data", " you can", " stream!"])
       end
     end
   end
@@ -364,14 +383,14 @@ describe Reel::Connection do
         client << example_request.to_s
 
         request = connection.request
-        request.should be_a(Reel::Request)
-        request.should_not be_finished_reading
+        expect(request).to be_a(Reel::Request)
+        expect(request).not_to be_finished_reading
         client << content
 
         data = ""
         request.body.each { |chunk| data << chunk }
-        request.should be_finished_reading
-        data.should == "I'm data you can stream!"
+        expect(request).to be_finished_reading
+        expect(data).to eq("I'm data you can stream!")
       end
     end
   end
@@ -385,7 +404,7 @@ describe Reel::Connection do
         client << example_request.to_s
         request = connection.request
 
-        lambda { request.read(-1) }.should raise_error(ArgumentError)
+        expect { request.read(-1) }.to raise_error(ArgumentError)
       end
     end
 
@@ -397,7 +416,7 @@ describe Reel::Connection do
         client << example_request.to_s
         request = connection.request
 
-        request.read(0).should be_empty
+        expect(request.read(0)).to be_empty
       end
     end
 
@@ -406,12 +425,12 @@ describe Reel::Connection do
         connection = Reel::Connection.new(peer, 4)
         example_request = ExampleRequest.new
         example_request.body = "Hello, world!"
-        connection.buffer_size.should == 4
+        expect(connection.buffer_size).to eq(4)
 
         client << example_request.to_s
         request = connection.request
 
-        request.read.should eq "Hello, world!"
+        expect(request.read).to eq "Hello, world!"
       end
     end
 
@@ -425,7 +444,7 @@ describe Reel::Connection do
         client << example_request.to_s
         request = connection.request
 
-        request.read.should eq "Hello, world!"
+        expect(request.read).to eq "Hello, world!"
       end
     end
 
@@ -439,8 +458,8 @@ describe Reel::Connection do
         request = connection.request
 
         buffer = ''
-        request.read(nil, buffer).should eq "Hello, world!"
-        buffer.should eq "Hello, world!"
+        expect(request.read(nil, buffer)).to eq "Hello, world!"
+        expect(buffer).to eq "Hello, world!"
       end
     end
 
@@ -453,7 +472,7 @@ describe Reel::Connection do
         client << example_request.to_s
         request = connection.request
 
-        request.read(1024).should eq "Hello, world!"
+        expect(request.read(1024)).to eq "Hello, world!"
       end
     end
 
@@ -465,7 +484,7 @@ describe Reel::Connection do
         client << example_request.to_s
         request = connection.request
 
-        request.read(1024).should be_nil
+        expect(request.read(1024)).to be_nil
       end
     end
 
@@ -477,7 +496,7 @@ describe Reel::Connection do
         client << example_request.to_s
         request = connection.request
 
-        request.read.should be_empty
+        expect(request.read).to be_empty
       end
     end
   end