faye-websocket 0.4.7 → 0.5.0

data/lib/faye/websocket.rb

@@ -1,216 +1,93 @@
-# API and protocol references:
+# API references:
 #
 # * http://dev.w3.org/html5/websockets/
 # * http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#interface-eventtarget
 # * http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#interface-event
-# * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75
-# * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
-# * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17
 
-require 'base64'
-require 'digest/md5'
-require 'digest/sha1'
 require 'forwardable'
-require 'net/http'
 require 'stringio'
 require 'uri'
 require 'eventmachine'
+require 'websocket/driver'
 
 module Faye
   autoload :EventSource, File.expand_path('../eventsource', __FILE__)
+  autoload :RackStream,  File.expand_path('../rack_stream', __FILE__)
 
   class WebSocket
     root = File.expand_path('../websocket', __FILE__)
-    require root + '/../../faye_websocket_mask'
 
-    def self.jruby?
-      defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-    end
-
-    def self.rbx?
-      defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
-    end
-
-    if jruby?
-      require 'jruby'
-      com.jcoglan.faye.FayeWebsocketMaskService.new.basicLoad(JRuby.runtime)
-    end
-
-    unless WebSocketMask.respond_to?(:mask)
-      def WebSocketMask.mask(payload, mask)
-        @instance ||= new
-        @instance.mask(payload, mask)
-      end
-    end
-
-    unless String.instance_methods.include?(:force_encoding)
-      require root + '/utf8_match'
-    end
-
-    autoload :Adapter,         root + '/adapter'
-    autoload :API,             root + '/api'
-    autoload :Client,          root + '/client'
-    autoload :Draft75Parser,   root + '/draft75_parser'
-    autoload :Draft76Parser,   root + '/draft76_parser'
-    autoload :HybiParser,      root + '/hybi_parser'
+    autoload :Adapter, root + '/adapter'
+    autoload :API,     root + '/api'
+    autoload :Client,  root + '/client'
 
     ADAPTERS = {
-      'thin'     => :Thin,
+      'goliath'  => :Goliath,
       'rainbows' => :Rainbows,
-      'goliath'  => :Goliath
+      'thin'     => :Thin
     }
 
-    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.utf8_string(string)
-      string = string.pack('C*') if Array === string
-      string.respond_to?(:force_encoding) ?
-          string.force_encoding('UTF-8') :
-          string
+    def self.determine_url(env)
+      secure = Rack::Request.new(env).ssl?
+      scheme = secure ? 'wss:' : 'ws:'
+      "#{ scheme }//#{ env['HTTP_HOST'] }#{ env['REQUEST_URI'] }"
     end
 
-    def self.encode(string, validate_encoding = false)
-      if Array === string
-        string = utf8_string(string)
-        return nil if validate_encoding and !valid_utf8?(string)
-      end
-      utf8_string(string)
+    def self.ensure_reactor_running
+      Thread.new { EventMachine.run } unless EventMachine.reactor_running?
+      Thread.pass until EventMachine.reactor_running?
     end
 
-    def self.valid_utf8?(byte_array)
-      string = utf8_string(byte_array)
-      if defined?(UTF8_MATCH)
-        UTF8_MATCH =~ string ? true : false
-      else
-        string.valid_encoding?
-      end
+    def self.load_adapter(backend)
+      const = Kernel.const_get(ADAPTERS[backend]) rescue nil
+      require(backend) unless const
+      path = File.expand_path("../adapters/#{backend}.rb", __FILE__)
+      require(path) if File.file?(path)
     end
 
     def self.websocket?(env)
-      env['REQUEST_METHOD'] == 'GET' and
-      env['HTTP_CONNECTION'] and
-      env['HTTP_CONNECTION'].split(/\s*,\s*/).include?('Upgrade') and
-      env['HTTP_UPGRADE'].downcase == 'websocket'
-    end
-
-    def self.parser(env)
-      if env['HTTP_SEC_WEBSOCKET_VERSION']
-        HybiParser
-      elsif env['HTTP_SEC_WEBSOCKET_KEY1']
-        Draft76Parser
-      else
-        Draft75Parser
-      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'] }"
+      ::WebSocket::Driver.websocket?(env)
     end
 
-    extend Forwardable
-    def_delegators :@parser, :version
-
     attr_reader :env
     include API
 
-    def initialize(env, supported_protos = nil, options = {})
+    def initialize(env, protocols = nil, options = {})
+      WebSocket.ensure_reactor_running
+
       @env     = env
+      @url     = WebSocket.determine_url(@env)
+      @driver  = ::WebSocket::Driver.rack(self, :protocols => protocols)
       @stream  = Stream.new(self)
       @ping    = options[:ping]
       @ping_id = 0
 
-      @url = WebSocket.determine_url(@env)
-      @ready_state = CONNECTING
-      @buffered_amount = 0
-
-      @parser = WebSocket.parser(@env).new(self, :protocols => supported_protos)
-
-      @send_buffer = []
-      EventMachine.next_tick { open }
-
-      @callback = @env['async.callback']
-      @callback.call([101, {}, @stream])
-      @stream.write(@parser.handshake_response)
-
-      @ready_state = OPEN if @parser.open?
-
-      if @ping
-        @ping_timer = EventMachine.add_periodic_timer(@ping) do
-          @ping_id += 1
-          ping(@ping_id.to_s)
-        end
+      if callback = @env['async.callback']
+        callback.call([101, {}, @stream])
       end
-    end
 
-    def ping(message = '', &callback)
-      return false unless @parser.respond_to?(:ping)
-      @parser.ping(message, &callback)
+      super()
+      @driver.start
     end
 
-    def protocol
-      @parser.protocol || ''
+    def write(data)
+      @stream.write(data)
     end
 
     def rack_response
       [ -1, {}, [] ]
     end
 
-  private
-
-    def parse(data)
-      response = @parser.parse(data)
-      return unless response
-      @stream.write(response)
-      open
-    end
-  end
-
-  class WebSocket::Stream
-    include EventMachine::Deferrable
-
-    extend Forwardable
-    def_delegators :@connection, :close_connection, :close_connection_after_writing
-
-    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)
-      @stream_send ||= callback
-    end
-
-    def fail
-      @web_socket.close(1006, '', false)
-    end
+    class Stream < RackStream
+      def fail
+        @socket_object.__send__(:finalize, '', 1006)
+      end
 
-    def receive(data)
-      @web_socket.__send__(:parse, data)
+      def receive(data)
+        @socket_object.__send__(:parse, data)
+      end
     end
 
-    def write(data)
-      return unless @stream_send
-      @stream_send.call(data) rescue nil
-    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
-

data/lib/faye/websocket/api.rb

@@ -1,96 +1,106 @@
+require File.expand_path('../api/event_target', __FILE__)
+require File.expand_path('../api/event', __FILE__)
+
 module Faye
   class WebSocket
 
     module API
-      module ReadyStates
-        CONNECTING = 0
-        OPEN       = 1
-        CLOSING    = 2
-        CLOSED     = 3
-      end
+      CONNECTING = 0
+      OPEN       = 1
+      CLOSING    = 2
+      CLOSED     = 3
 
-      class IllegalStateError < StandardError
-      end
-
-      require File.expand_path('../api/event_target', __FILE__)
-      require File.expand_path('../api/event', __FILE__)
       include EventTarget
-      include ReadyStates
+
+      extend Forwardable
+      def_delegators :@driver, :version
 
       attr_reader :url, :ready_state, :buffered_amount
 
-    private
+      def initialize
+        super
 
-      def open
-        return if @parser and not @parser.open?
-        @ready_state = OPEN
+        @ready_state = CONNECTING
+        @buffered_amount = 0
+
+        @driver.on(:open)    { |e| open }
+        @driver.on(:message) { |e| receive_message(e.data) }
+        @driver.on(:close)   { |e| finalize(e.reason, e.code) }
 
-        buffer = @send_buffer || []
-        while message = buffer.shift
-          send(*message)
+        @driver.on(:error) do |error|
+          event = Event.new('error')
+          event.init_event('error', false, false)
+          dispatch_event(event)
+        end
+
+        if @ping
+          @ping_timer = EventMachine.add_periodic_timer(@ping) do
+            @ping_id += 1
+            ping(@ping_id.to_s)
+          end
         end
+      end
+
+    private
 
+      def open
+        return unless @ready_state == CONNECTING
+        @ready_state = OPEN
         event = Event.new('open')
         event.init_event('open', false, false)
         dispatch_event(event)
       end
 
-    public
-
-      def receive(data)
-        return false unless @ready_state == OPEN
+      def receive_message(data)
+        return unless @ready_state == OPEN
         event = Event.new('message')
         event.init_event('message', false, false)
         event.data = data
         dispatch_event(event)
       end
 
-      def send(data, type = nil, error_type = nil)
-        if @ready_state == CONNECTING
-          if @send_buffer
-            @send_buffer << [data, type, error_type]
-            return true
-          else
-            raise IllegalStateError, 'Cannot call send(), socket is not open yet'
-          end
-        end
+      def finalize(reason = nil, code = nil)
+        return if @ready_state == CLOSED
+        @ready_state = CLOSED
+        EventMachine.cancel_timer(@ping_timer) if @ping_timer
+        @stream.close_connection_after_writing
+        event = Event.new('close', :code => code || 1000, :reason => reason || '')
+        event.init_event('close', false, false)
+        dispatch_event(event)
+      end
 
-        return false if @ready_state == CLOSED
+      def parse(data)
+        @driver.parse(data)
+      end
 
-        data = data.to_s unless Array === data
+    public
 
-        data = WebSocket.encode(data) if String === data
-        frame = @parser.frame(data, type, error_type)
-        @stream.write(frame) if frame
+      def write(data)
+        @stream.write(data)
       end
 
-      def close(code = nil, reason = nil, ack = true)
-        return if @ready_state == CLOSED
-        return if @ready_state == CLOSING && ack
-
-        finalize = lambda do
-          @ready_state = CLOSED
-          EventMachine.cancel_timer(@ping_timer) if @ping_timer
-          @stream.close_connection_after_writing
-          event = Event.new('close', :code => code || 1000, :reason => reason || '')
-          event.init_event('close', false, false)
-          dispatch_event(event)
+      def send(message)
+        return false if @ready_state > OPEN
+        case message
+          when Numeric then @driver.text(message.to_s)
+          when String  then @driver.text(message)
+          when Array   then @driver.binary(message)
+          else false
         end
+      end
 
-        return finalize.call if @ready_state == CONNECTING
+      def ping(message = '', &callback)
+        return false if @ready_state > OPEN
+        @driver.ping(message, &callback)
+      end
 
-        @ready_state = CLOSING
+      def close
+        @ready_state = CLOSING if @ready_state == OPEN
+        @driver.close
+      end
 
-        if ack
-          if @parser.respond_to?(:close)
-            @parser.close(code, reason, &finalize)
-          else
-            finalize.call
-          end
-        else
-          @parser.close(code, reason) if @parser.respond_to?(:close)
-          finalize.call
-        end
+      def protocol
+        @driver.protocol || ''
       end
     end
 

data/lib/faye/websocket/api/event.rb

@@ -2,7 +2,7 @@ module Faye::WebSocket::API
   class Event
 
     attr_reader   :type, :bubbles, :cancelable
-    attr_accessor :target, :current_target, :event_phase, :data
+    attr_accessor :target, :current_target, :event_phase, :data, :message
 
     CAPTURING_PHASE = 1
     AT_TARGET       = 2

data/lib/faye/websocket/api/event_target.rb

@@ -1,31 +1,54 @@
 module Faye::WebSocket::API
   module EventTarget
 
-    attr_accessor :onopen, :onmessage, :onerror, :onclose
+    include ::WebSocket::Driver::EventEmitter
+    events = %w[open message error close]
+
+    events.each do |event_type|
+      define_method "on#{event_type}=" do |handler|
+        EventMachine.next_tick do
+          flush(event_type, &handler)
+          instance_variable_set("@on#{event_type}", handler)
+        end
+      end
+    end
 
     def add_event_listener(event_type, listener, use_capture = false)
-      @listeners ||= {}
-      list = @listeners[event_type] ||= []
-      list << listener
+      add_listener(event_type, &listener)
     end
 
-    def remove_event_listener(event_type, listener, use_capture = false)
-      return unless @listeners and @listeners[event_type]
-      return @listeners.delete(event_type) unless listener
+    def add_listener(event_type, &listener)
+      EventMachine.next_tick do
+        flush(event_type, &listener)
+        super(event_type, &listener)
+      end
+    end
 
-      @listeners[event_type].delete_if(&listener.method(:==))
+    def remove_event_listener(event_type, listener, use_capture = false)
+      remove_listener(event_type, &listener)
     end
 
     def dispatch_event(event)
       event.target = event.current_target = self
       event.event_phase = Event::AT_TARGET
 
-      callback = __send__("on#{ event.type }")
+      callback = instance_variable_get("@on#{ event.type }")
+      count    = listener_count(event.type)
+
+      unless callback or count > 0
+        @buffers ||= Hash.new { |k,v| k[v] = [] }
+        @buffers[event.type].push(event)
+      end
+
       callback.call(event) if callback
+      emit(event.type, event)
+    end
+
+  private
 
-      return unless @listeners and @listeners[event.type]
-      @listeners[event.type].each do |listener|
-        listener.call(event)
+    def flush(event_type, &callback)
+      if buffer = @buffers && @buffers.delete(event_type.to_s)
+        buffer.each { |event| callback.call(event) }
       end
     end