faye-websocket 0.2.0 → 0.3.0

data/examples/{index.html → ws.html}

@@ -16,22 +16,26 @@
           socket = new Socket('ws://' + location.hostname + ':' + location.port + '/', protos),
           index  = 0;
       
-      socket.onopen = function() {
-        logger.innerHTML += '<li>OPEN: ' + socket.protocol + '</li>';
-        socket.send('Hello, world');
+      var log = function(text) {
+        logger.innerHTML += '<li>' + text + '</li>';
       };
       
+      socket.addEventListener('open', function() {
+        log('OPEN: ' + socket.protocol);
+        socket.send('Hello, world');
+      });
+      
       socket.onerror = function(event) {
-        logger.innerHTML += '<li>ERROR: ' + error.message + '</li>';
+        log('ERROR: ' + event.message);
       };
       
-      socket.addEventListener('message', function(event) {
-        logger.innerHTML += '<li>MESSAGE: ' + event.data + '</li>';
+      socket.onmessage = function(event) {
+        log('MESSAGE: ' + event.data);
         setTimeout(function() { socket.send(++index + ' ' + event.data) }, 2000);
-      });
+      };
       
       socket.onclose = function(event) {
-        logger.innerHTML += '<li>CLOSE: ' + event.code + ', ' + event.reason + '</li>';
+        log('CLOSE: ' + event.code + ', ' + event.reason);
       };
     </script>
     

data/lib/faye/adapters/goliath.rb

@@ -0,0 +1,47 @@
+class Goliath::Connection
+  attr_accessor :socket_stream
+  alias :goliath_receive_data :receive_data
+  
+  def receive_data(data)
+    if @serving == :websocket
+      socket_stream.receive(data) if socket_stream
+    else
+      goliath_receive_data(data)
+      socket_stream.receive(@parser.upgrade_data) if socket_stream
+      @serving = :websocket if @api.websocket?
+    end
+  end
+  
+  def unbind
+    super
+  ensure
+    socket_stream.fail if socket_stream
+  end
+end
+
+class Goliath::API
+  include Faye::WebSocket::Adapter
+end
+
+class Goliath::Request
+  alias :goliath_process :process
+  
+  def process
+    env['em.connection'] = conn
+    goliath_process
+  end
+end
+
+class Goliath::Response
+  alias :goliath_head :head
+  alias :goliath_headers_output :headers_output
+  
+  def head
+    (status == 101) ? '' : goliath_head
+  end
+  
+  def headers_output
+    (status == 101) ? '' : goliath_headers_output
+  end
+end
+

data/lib/faye/adapters/rainbows.rb

@@ -0,0 +1,32 @@
+# WebSocket extensions for Rainbows
+# Based on code from the Cramp project
+# http://github.com/lifo/cramp
+
+# Copyright (c) 2009-2011 Pratik Naik
+# 
+# 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.
+
+module Faye
+  class WebSocket
+    autoload :RainbowsClient, File.expand_path('../rainbows_client', __FILE__)
+  end
+end
+
+Rainbows::O[:em_client_class] = "Faye::WebSocket::RainbowsClient"

data/lib/faye/adapters/rainbows_client.rb

@@ -0,0 +1,70 @@
+# WebSocket extensions for Rainbows
+# Based on code from the Cramp project
+# http://github.com/lifo/cramp
+
+# Copyright (c) 2009-2011 Pratik Naik
+# 
+# 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.
+
+module Faye
+  class WebSocket
+    
+    class RainbowsClient < Rainbows::EventMachine::Client
+      include Faye::WebSocket::Adapter
+      attr_accessor :socket_stream
+      
+      def receive_data(data)
+        return super unless @state == :websocket
+        socket_stream.receive(data) if socket_stream
+      end
+      
+      def app_call(*args)
+        @env['em.connection'] = self
+        if args.first == NULL_IO and @hp.content_length == 0 and websocket?
+          prepare_request_body
+        else
+          super
+        end
+      end
+      
+      def on_read(data)
+        if @state == :body and websocket? and @hp.body_eof?
+          @state = :websocket
+          @input.rewind
+          app_call StringIO.new(@buf)
+        else
+          super
+        end
+      end
+      
+      def unbind
+        super
+      ensure
+        socket_stream.fail if socket_stream
+      end
+      
+      def write_headers(*args)
+        super unless async_connection?
+      end
+    end
+    
+  end
+end
+

data/lib/faye/{thin_extensions.rb → adapters/thin.rb}

@@ -24,52 +24,39 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 class Thin::Connection
-  def receive_data(data)
-    trace { data }
-
-    case @serving
-    when :websocket
-      callback = @request.env[Thin::Request::WEBSOCKET_RECEIVE_CALLBACK]
-      callback.call(data) if callback
-    else
-      if @request.parse(data)
-        if @request.websocket?
-          @request.env['em.connection'] = self
-          @response.persistent!
-          @response.websocket = true
-          @serving = :websocket
-        end
-
-        process
-      end
+  attr_accessor :socket_stream
+  
+  alias :thin_process      :process
+  alias :thin_receive_data :receive_data
+  
+  def process
+    if @serving != :websocket and @request.websocket?
+      @serving = :websocket
     end
-  rescue Thin::InvalidRequest => e
-    log "!! Invalid request"
-    log_error e
-    close_connection
+    if @request.async_connection?
+      @request.env['em.connection'] = self
+      @response.persistent!
+      @response.async = true
+    end
+    thin_process
+  end
+  
+  def receive_data(data)
+    return thin_receive_data(data) unless @serving == :websocket
+    socket_stream.receive(data) if socket_stream
   end
 end
 
 class Thin::Request
-  WEBSOCKET_RECEIVE_CALLBACK = 'websocket.receive_callback'.freeze
-  def websocket?
-    @env['HTTP_CONNECTION'] and
-    @env['HTTP_CONNECTION'].split(/\s*,\s*/).include?('Upgrade') and
-    ['WebSocket', 'websocket'].include?(@env['HTTP_UPGRADE'])
-  end
+  include Faye::WebSocket::Adapter
 end
 
 class Thin::Response
-  # Headers for sending Websocket upgrade
-  attr_accessor :websocket
-
-  def each
-    yield(head) unless websocket
-    if @body.is_a?(String)
-      yield @body
-    else
-      @body.each { |chunk| yield chunk }
-    end
+  attr_accessor :async
+  alias :thin_head :head
+  
+  def head
+    async ? '' : thin_head
   end
 end
 

data/lib/faye/eventsource.rb

@@ -0,0 +1,118 @@
+require File.expand_path('../websocket', __FILE__) unless defined?(Faye::WebSocket)
+
+module Faye
+  class EventSource
+    DEFAULT_PING  = 10
+    DEFAULT_RETRY = 5
+    
+    include WebSocket::API::EventTarget
+    include WebSocket::API::ReadyStates
+    attr_reader :env, :url, :ready_state
+    
+    def self.eventsource?(env)
+      accept = (env['HTTP_ACCEPT'] || '').split(/\s*,\s*/)
+      accept.include?('text/event-stream')
+    end
+    
+    def self.determine_url(env)
+      secure = if env.has_key?('HTTP_X_FORWARDED_PROTO')
+                 env['HTTP_X_FORWARDED_PROTO'] == 'https'
+               else
+                 env['HTTP_ORIGIN'] =~ /^https:/i
+               end
+      
+      scheme = secure ? 'https:' : 'http:'
+      "#{ scheme }//#{ env['HTTP_HOST'] }#{ env['REQUEST_URI'] }"
+    end
+    
+    def initialize(env, options = {})
+      @env    = env
+      @ping   = options[:ping] || DEFAULT_PING
+      @retry  = (options[:retry] || DEFAULT_RETRY).to_f
+      @url    = EventSource.determine_url(env)
+      @stream = Stream.new(self)
+      
+      @ready_state = CONNECTING
+      
+      callback = @env['async.callback']
+      callback.call([101, {}, @stream])
+      
+      @stream.write("HTTP/1.1 200 OK\r\n" +
+                    "Content-Type: text/event-stream\r\n" +
+                    "Cache-Control: no-cache, no-store\r\n" +
+                    "\r\n\r\n" +
+                    "retry: #{ (@retry * 1000).floor }\r\n\r\n")
+      
+      @ping_timer = EventMachine.add_periodic_timer(@ping) do
+        @stream.write(":\r\n\r\n")
+      end
+      
+      @ready_state = OPEN
+    end
+    
+    def last_event_id
+      @env['HTTP_LAST_EVENT_ID'] || ''
+    end
+    
+    def rack_response
+      [ -1, {}, [] ]
+    end
+    
+    def send(message, options = {})
+      return false unless @ready_state == OPEN
+      
+      message = WebSocket.encode(message).
+                gsub(/(\r\n|\r|\n)/, '\1data: ')
+      
+      frame  = ""
+      frame << "event: #{options[:event]}\r\n" if options[:event]
+      frame << "id: #{options[:id]}\r\n" if options[:id]
+      frame << "data: #{message}\r\n\r\n"
+      
+      @stream.write(frame)
+      true
+    end
+    
+    def close
+      return if [CLOSING, CLOSED].include?(@ready_state)
+      @ready_state = CLOSED
+      EventMachine.cancel_timer(@ping_timer)
+      @stream.close_connection_after_writing
+      event = WebSocket::API::Event.new('close')
+      event.init_event('close', false, false)
+      dispatch_event(event)
+    end
+  end
+  
+  class EventSource::Stream
+    include EventMachine::Deferrable
+    
+    extend Forwardable
+    def_delegators :@connection, :close_connection, :close_connection_after_writing
+    
+    def initialize(event_source)
+      @event_source = event_source
+      @connection   = event_source.env['em.connection']
+      @stream_send  = event_source.env['stream.send']
+      
+      @connection.socket_stream = self if @connection.respond_to?(:socket_stream)
+    end
+    
+    def each(&callback)
+      @stream_send ||= callback
+    end
+    
+    def fail
+      @event_source.close
+    end
+    
+    def receive(data)
+    end
+    
+    def write(data)
+      return unless @stream_send
+      @stream_send.call(data)
+    end
+  end
+end
+

data/lib/faye/websocket.rb

@@ -12,18 +12,18 @@ require 'digest/md5'
 require 'digest/sha1'
 require 'forwardable'
 require 'net/http'
+require 'stringio'
 require 'uri'
-
 require 'eventmachine'
-require 'thin'
-require File.dirname(__FILE__) + '/thin_extensions'
 
 module Faye
+  autoload :EventSource, File.expand_path('../eventsource', __FILE__)
+  
   class WebSocket
-    
     root = File.expand_path('../websocket', __FILE__)
     require root + '/../../faye_websocket_mask'
     
+    autoload :Adapter,         root + '/adapter'
     autoload :API,             root + '/api'
     autoload :Client,          root + '/client'
     autoload :Draft75Parser,   root + '/draft75_parser'
@@ -33,6 +33,18 @@ module Faye
     # http://www.w3.org/International/questions/qa-forms-utf-8.en.php
     UTF8_MATCH = /^([\x00-\x7F]|[\xC2-\xDF][\x80-\xBF]|\xE0[\xA0-\xBF][\x80-\xBF]|[\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}|\xED[\x80-\x9F][\x80-\xBF]|\xF0[\x90-\xBF][\x80-\xBF]{2}|[\xF1-\xF3][\x80-\xBF]{3}|\xF4[\x80-\x8F][\x80-\xBF]{2})*$/
     
+    ADAPTERS = {
+      'thin'     => :Thin,
+      'rainbows' => :Rainbows,
+      'goliath'  => :Goliath
+    }
+    
+    def self.load_adapter(backend)
+      const = Kernel.const_get(ADAPTERS[backend]) rescue nil
+      require(backend) unless const
+      require File.expand_path("../adapters/#{backend}", __FILE__)
+    end
+    
     def self.encode(string, validate_encoding = false)
       if Array === string
         return nil if validate_encoding and !valid_utf8?(string)
@@ -46,6 +58,12 @@ module Faye
       UTF8_MATCH =~ byte_array.pack('C*') ? true : false
     end
     
+    def self.websocket?(env)
+      env['HTTP_CONNECTION'] and
+      env['HTTP_CONNECTION'].split(/\s*,\s*/).include?('Upgrade') and
+      ['WebSocket', 'websocket'].include?(env['HTTP_UPGRADE'])
+    end
+    
     def self.parser(env)
       if env['HTTP_SEC_WEBSOCKET_VERSION']
         HybiParser
@@ -56,6 +74,17 @@ module Faye
       end
     end
     
+    def self.determine_url(env)
+      secure = if env.has_key?('HTTP_X_FORWARDED_PROTO')
+                 env['HTTP_X_FORWARDED_PROTO'] == 'https'
+               else
+                 env['HTTP_ORIGIN'] =~ /^https:/i
+               end
+      
+      scheme = secure ? 'wss:' : 'ws:'
+      "#{ scheme }//#{ env['HTTP_HOST'] }#{ env['REQUEST_URI'] }"
+    end
+    
     extend Forwardable
     def_delegators :@parser, :version
     
@@ -63,16 +92,17 @@ module Faye
     include API
     
     def initialize(env, supported_protos = nil)
-      @env      = env
-      @callback = @env['async.callback']
-      @stream   = Stream.new(self, @env['em.connection'])
-      @callback.call [200, {}, @stream]
+      @env    = env
+      @stream = Stream.new(self)
       
-      @url = determine_url
+      @url = WebSocket.determine_url(@env)
       @ready_state = CONNECTING
       @buffered_amount = 0
       
       @parser = WebSocket.parser(@env).new(self, :protocols => supported_protos)
+      
+      @callback = @env['async.callback']
+      @callback.call([101, {}, @stream])
       @stream.write(@parser.handshake_response)
       
       @ready_state = OPEN
@@ -80,28 +110,21 @@ module Faye
       event = Event.new('open')
       event.init_event('open', false, false)
       dispatch_event(event)
-      
-      @env[Thin::Request::WEBSOCKET_RECEIVE_CALLBACK] = lambda do |data|
-        response = @parser.parse(data)
-        @stream.write(response) if response
-      end
     end
     
     def protocol
       @parser.protocol || ''
     end
     
+    def rack_response
+      [ -1, {}, [] ]
+    end
+    
   private
     
-    def determine_url
-      secure = if @env.has_key?('HTTP_X_FORWARDED_PROTO')
-                 @env['HTTP_X_FORWARDED_PROTO'] == 'https'
-               else
-                 @env['HTTP_ORIGIN'] =~ /^https:/i
-               end
-      
-      scheme = secure ? 'wss:' : 'ws:'
-      "#{ scheme }//#{ @env['HTTP_HOST'] }#{ @env['REQUEST_URI'] }"
+    def parse(data)
+      response = @parser.parse(data)
+      @stream.write(response) if response
     end
   end
   
@@ -111,24 +134,35 @@ module Faye
     extend Forwardable
     def_delegators :@connection, :close_connection, :close_connection_after_writing
     
-    def initialize(web_socket, connection)
-      @web_socket = web_socket
-      @connection = connection
+    def initialize(web_socket)
+      @web_socket  = web_socket
+      @connection  = web_socket.env['em.connection']
+      @stream_send = web_socket.env['stream.send']
+      
+      @connection.socket_stream = self if @connection.respond_to?(:socket_stream)
     end
     
     def each(&callback)
-      @data_callback = callback
+      @stream_send ||= callback
     end
     
     def fail
       @web_socket.close(1006, '', false)
     end
     
+    def receive(data)
+      @web_socket.__send__(:parse, data)
+    end
+    
     def write(data)
-      return unless @data_callback
-      @data_callback.call(data)
+      return unless @stream_send
+      @stream_send.call(data)
     end
   end
-  
+end
+
+Faye::WebSocket::ADAPTERS.each do |name, const|
+  klass = Kernel.const_get(const) rescue nil
+  Faye::WebSocket.load_adapter(name) if klass
 end