reel 0.2.0 → 0.3.0.pre

data/lib/reel/stream.rb

@@ -0,0 +1,128 @@
+module Reel
+  class Stream
+
+    def initialize &proc
+      @proc = proc
+    end
+
+    def call socket
+      @socket = socket
+      @proc.call self
+    end
+
+    def write data
+      write!  data
+      self
+    end
+    alias :<< :write
+
+    # behaves like a true Rack::Response/BodyProxy object
+    def each(*)
+      yield self
+    end
+
+    def on_error &proc
+      @on_error = proc
+      self
+    end
+
+    def close
+      @socket.close unless closed?
+    end
+    alias finish close
+
+    def closed?
+      @socket.closed?
+    end
+
+    private
+    def write! string
+      @socket << string
+    rescue => e
+      @on_error ? @on_error.call(e) : raise(e)
+    end
+
+  end
+    
+  class EventStream < Stream
+
+    # EventSource-related helpers
+    #
+    # @example
+    #   Reel::EventStream.new do |socket|
+    #     socket.event 'some event'
+    #     socket.retry 10
+    #   end
+    #
+    # @note
+    #   though retry is a reserved word, it is ok to use it as `object#retry`
+    #
+    %w[event id retry].each do |meth|
+      define_method meth do |data|
+        # unlike on #data, these messages expects a single \n at the end.
+        write! "%s: %s\n" % [meth, data]
+      end
+    end
+
+    def data data
+      # - any single message should not contain \n except at the end.
+      # - EventSource expects \n\n at the end of each single message.
+      write! "data: %s\n\n" % data.gsub(/\n|\r/, '')
+      self
+    end
+
+  end
+  
+  class ChunkStream < Stream
+    
+    def write chunk
+      chunk_header = chunk.bytesize.to_s(16)
+      write! chunk_header + Response::CRLF
+      write! chunk + Response::CRLF
+      self
+    end
+    alias :<< :write
+
+    # finish does not actually close the socket,
+    # it only inform the browser there are no more messages
+    def finish
+      write! "0#{Response::CRLF * 2}"
+    end
+
+    def close
+      finish
+      super
+    end
+
+  end
+
+  class StreamResponse < Response
+
+    IDENTITY = 'identity'.freeze
+
+    def initialize status, headers, body
+      self.status = status
+      @body = body
+
+      case @body
+      when EventStream
+        # EventSource behaves extremely bad on chunked Transfer-Encoding
+        headers[TRANSFER_ENCODING] = IDENTITY
+      when ChunkStream
+        headers[TRANSFER_ENCODING] = CHUNKED
+      when Stream
+      else
+        raise TypeError, "can't render #{@body.class} as a response body"
+      end
+
+      @headers = canonicalize_headers(headers)
+      @version = http_version
+    end
+
+    def render socket
+      socket << render_header
+      @body.call socket
+    end
+  end
+
+end

data/lib/reel/version.rb

@@ -1,3 +1,3 @@
 module Reel
-  VERSION = "0.2.0"
+  VERSION = "0.3.0.pre"
 end

data/lib/reel/websocket.rb

@@ -1,11 +1,16 @@
+require 'forwardable'
 require 'websocket_parser'
 
 module Reel
   class WebSocket
-    attr_reader :url, :headers
+    extend Forwardable
+    include ConnectionMixin
+    include RequestMixin
 
-    def initialize(socket, url, headers)
-      @socket, @url, @headers = socket, url, headers
+    def_delegators :@socket, :addr, :peeraddr
+
+    def initialize(http_parser, socket)
+      @http_parser, @socket = http_parser, socket
 
       handshake = ::WebSocket::ClientHandshake.new(:get, url, headers)
 
@@ -36,20 +41,45 @@ module Reel
       end
     end
 
-    def [](header)
-      @headers[header]
+    [: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
+      end
+    end
+
+    def read_every n, unit = :s
+      cancel_timer! # only one timer allowed per stream
+      seconds = case unit.to_s
+      when /\Am/
+        n * 60
+      when /\Ah/
+        n * 3600
+      else
+        n
+      end
+      @timer = Celluloid.every(seconds) { read }
     end
+    alias read_interval  read_every
+    alias read_frequency read_every
 
     def read
       @parser.append @socket.readpartial(Connection::BUFFER_SIZE) until msg = @parser.next_message
       msg
+    rescue => e
+      cancel_timer!
+      @on_error ? @on_error.call(e) : raise(e)
+    end
+
+    def body
+      nil
     end
 
     def write(msg)
       @socket << ::WebSocket::Message.new(msg).to_data
       msg
-    rescue Errno::EPIPE
-      raise SocketError, "error writing to socket"
+    rescue => e
+      cancel_timer!
+      @on_error ? @on_error.call(e) : raise(e)
     end
     alias_method :<<, :write
 
@@ -58,7 +88,13 @@ module Reel
     end
 
     def close
-      @socket.close
+      cancel_timer!
+      @socket.close unless closed?
     end
+
+    def cancel_timer!
+      @timer && @timer.cancel
+    end
+
   end
 end

data/spec/reel/connection_spec.rb

@@ -94,4 +94,93 @@ describe Reel::Connection do
       connection.request.should be_false
     end
   end
+
+  describe "Connection#read behaving like IO#read" do
+    it "raises an exception if length is a negative value" do
+      with_socket_pair do |client, connection|
+        example_request = ExampleRequest.new
+
+        client << example_request.to_s
+        request = connection.request
+
+        lambda { request.read(-1) }.should raise_error(ArgumentError)
+      end
+    end
+
+    it "returns an empty string if the length is zero" do
+      with_socket_pair do |client, connection|
+        example_request = ExampleRequest.new
+
+        client << example_request.to_s
+        request = connection.request
+
+        request.read(0).should be_empty
+      end
+    end
+
+    it "reads to EOF if length is nil" do
+      with_socket_pair do |client, connection|
+        body = "Hello, world!"
+        example_request = ExampleRequest.new
+        example_request.body = body
+
+        client << example_request.to_s
+        request = connection.request
+
+        request.read.should eq "Hello, world!"
+      end
+    end
+
+    it "uses the optional buffer to recieve data" do
+      with_socket_pair do |client, connection|
+        body = "Hello, world!"
+        example_request = ExampleRequest.new
+        example_request.body = body
+
+        client << example_request.to_s
+        request = connection.request
+
+        buffer = ''
+        request.read(nil, buffer).should eq "Hello, world!"
+        buffer.should eq "Hello, world!"
+      end
+    end
+
+    it "returns with the content it could read when the length longer than EOF" do
+      with_socket_pair do |client, connection|
+        body = "Hello, world!"
+        example_request = ExampleRequest.new
+        example_request.body = body
+
+        client << example_request.to_s
+        request = connection.request
+
+        request.read(1024).should eq "Hello, world!"
+      end
+    end
+
+    it "returns nil at EOF if a length is passed" do
+      with_socket_pair do |client, connection|
+        example_request = ExampleRequest.new
+
+        client << example_request.to_s
+        request = connection.request
+
+        request.read(1024).should be_nil
+      end
+    end
+
+    it "returns an empty string at EOF if length is nil" do
+      with_socket_pair do |client, connection|
+        example_request = ExampleRequest.new
+
+        client << example_request.to_s
+        request = connection.request
+
+        request.read.should be_empty
+      end
+    end
+
+  end
+
 end

data/spec/reel/rack_worker_spec.rb

@@ -1,17 +1,15 @@
 require 'spec_helper'
 
 describe Reel::RackWorker do
-
   let(:endpoint) { URI(example_url) }
 
-  let(:worker) do
-    app = Proc.new do |env|
-      [200, {'Content-Type' => 'text/plain'}, ['Hello world!']]
-      [200, {'Content-Type' => 'text/plain'}, ['Hello rack world!']]
-    end
+  RackApp = Proc.new do |env|
+    [200, {'Content-Type' => 'text/plain'}, ['Hello rack world!']]
+  end
 
+  let(:worker) do
     handler = Rack::Handler::Reel.new
-    handler.options[:app] = app
+    handler.options[:app] = RackApp
 
     Reel::RackWorker.new(handler)
   end
@@ -20,37 +18,51 @@ describe Reel::RackWorker do
     with_socket_pair do |client, connection|
       client << ExampleRequest.new(:get, '/test?hello=true').to_s
       request = connection.request
-      env = worker.rack_env(request, connection)
+      env = worker.request_env(request, connection)
 
       Reel::RackWorker::PROTO_RACK_ENV.each do |k, v|
         env[k].should == v
       end
 
-      env["SERVER_NAME"].should == '0.0.0.0'
-      env["SERVER_PORT"].should == 3000
+      env["SERVER_NAME"].should == 'www.example.com'
+      env["SERVER_PORT"].should == "3000"
       env["REMOTE_ADDR"].should == "127.0.0.1"
       env["PATH_INFO"].should == "/test"
       env["REQUEST_METHOD"].should == "GET"
-      env["REQUEST_PATH"].should == "/test"
-      env["ORIGINAL_FULLPATH"].should == "/test"
       env["QUERY_STRING"].should == "hello=true"
       env["HTTP_HOST"].should == 'www.example.com'
       env["HTTP_ACCEPT_LANGUAGE"].should == "en-US,en;q=0.8"
-      env["REQUEST_URI"].should == 'http://www.example.com/test'
-
-      %w(localhost 127.0.0.1).should include env["REMOTE_HOST"]
 
       env["rack.input"].should be_kind_of(StringIO)
       env["rack.input"].string.should == ''
+
+      validator = ::Rack::Lint.new(RackApp)
+      status, *rest = validator.call(env)
+      status.should == 200
     end
   end
 
+  context "WebSocket" do
+    include WebSocketHelpers
+
+    it "places websocket into rack env" do
+      with_socket_pair do |client, connection|
+        client << handshake.to_data
+        request = connection.request
+        env = worker.websocket_env(request)
+        
+        env["REMOTE_ADDR"].should == "127.0.0.1"
+        env["rack.websocket"].should be_a Reel::WebSocket
+      end
+    end    
+  end
+
   it "delegates web requests to the rack app" do
     ex = nil
 
     handler = proc do |connection|
       begin
-        worker.handle!(connection.detach)
+        worker.async.handle(connection.detach)
       rescue => ex
       end
     end

data/spec/reel/response_spec.rb

@@ -10,8 +10,8 @@ describe Reel::Response do
       connection.close
 
       response = client.read(4096)
-      crlf = "\r\n"
-      fixture = "5#{crlf}Hello5#{crlf}World0#{crlf*2}"
+      crlf = Reel::Response::CRLF
+      fixture = "5#{crlf}Hello#{crlf}5#{crlf}World#{crlf}0#{crlf*2}"
       response[(response.length - fixture.length)..-1].should eq fixture
     end
   end

data/spec/reel/server_spec.rb

@@ -11,7 +11,7 @@ describe Reel::Server do
     handler = proc do |connection|
       begin
         request = connection.request
-        request.method.should eq :get
+        request.method.should eq 'GET'
         request.version.should eq "1.1"
         request.url.should eq example_path
 
@@ -34,7 +34,7 @@ describe Reel::Server do
     handler = proc do |connection|
       begin
         request = connection.request
-        request.method.should eq :post
+        request.method.should eq 'POST'
         connection.respond :ok, request.body
       rescue => ex
       end

data/spec/reel/websocket_spec.rb

@@ -1,26 +1,11 @@
 require 'spec_helper'
 
 describe Reel::WebSocket do
-  let(:example_host)    { "www.example.com" }
-  let(:example_path)    { "/example"}
-  let(:example_url)     { "ws://#{example_host}#{example_path}" }
+  include WebSocketHelpers
+
   let(:example_message) { "Hello, World!" }
   let(:another_message) { "What's going on?" }
 
-  let :handshake_headers do
-    {
-      "Host"                   => example_host,
-      "Upgrade"                => "websocket",
-      "Connection"             => "Upgrade",
-      "Sec-WebSocket-Key"      => "dGhlIHNhbXBsZSBub25jZQ==",
-      "Origin"                 => "http://example.com",
-      "Sec-WebSocket-Protocol" => "chat, superchat",
-      "Sec-WebSocket-Version"  => "13"
-    }
-  end
-
-  let(:handshake) { WebSocket::ClientHandshake.new(:get, example_url, handshake_headers) }
-
   it "performs websocket handshakes" do
     with_socket_pair do |client, connection|
       client << handshake.to_data