faye 0.8.11 → 1.0.0

data/lib/faye.rb

@@ -6,18 +6,20 @@ require 'em-http/version'
 require 'eventmachine'
 require 'faye/websocket'
 require 'forwardable'
+require 'multi_json'
 require 'rack'
+require 'securerandom'
 require 'set'
 require 'time'
 require 'uri'
-require 'yajl'
 
 module Faye
-  VERSION = '0.8.11'
+  VERSION = '1.0.0'
 
   ROOT = File.expand_path(File.dirname(__FILE__))
 
   autoload :Publisher,    File.join(ROOT, 'faye', 'mixins', 'publisher')
+  autoload :Deferrable,   File.join(ROOT, 'faye', 'mixins', 'deferrable')
   autoload :Timeouts,     File.join(ROOT, 'faye', 'mixins', 'timeouts')
   autoload :Logging,      File.join(ROOT, 'faye', 'mixins', 'logging')
 
@@ -28,6 +30,7 @@ module Faye
   autoload :Grammar,      File.join(ROOT, 'faye', 'protocol', 'grammar')
   autoload :Extensible,   File.join(ROOT, 'faye', 'protocol', 'extensible')
   autoload :Channel,      File.join(ROOT, 'faye', 'protocol', 'channel')
+  autoload :Envelope,     File.join(ROOT, 'faye', 'protocol', 'envelope')
   autoload :Subscription, File.join(ROOT, 'faye', 'protocol', 'subscription')
   autoload :Publication,  File.join(ROOT, 'faye', 'protocol', 'publication')
   autoload :Client,       File.join(ROOT, 'faye', 'protocol', 'client')
@@ -48,7 +51,6 @@ module Faye
   class << self
     attr_accessor :logger
   end
-  self.logger = method(:puts)
 
   def self.ensure_reactor_running!
     Engine.ensure_reactor_running!
@@ -59,7 +61,7 @@ module Faye
   end
 
   def self.client_id_from_messages(messages)
-    first = [messages].flatten.first
+    first = [messages].flatten.find { |m| m['channel'] == '/meta/connect' }
     first && first['clientId']
   end
 
@@ -78,9 +80,13 @@ module Faye
     end
   end
 
+  def self.parse_url(url)
+    String === url ? URI.parse(url) : url
+  end
+
   def self.to_json(value)
     case value
-      when Hash, Array then Yajl::Encoder.encode(value)
+      when Hash, Array then MultiJson.dump(value)
       when String, NilClass then value.inspect
       else value.to_s
     end

data/lib/faye/adapters/rack_adapter.rb

@@ -4,7 +4,7 @@ module Faye
     include Logging
 
     extend Forwardable
-    def_delegators "@server.engine", :bind, :unbind
+    def_delegators '@server.engine', *Faye::Publisher.instance_methods
 
     ASYNC_RESPONSE = [-1, {}, []].freeze
 
@@ -15,19 +15,17 @@ module Faye
     TYPE_SCRIPT = {'Content-Type' => 'text/javascript; charset=utf-8'}
     TYPE_TEXT   = {'Content-Type' => 'text/plain; charset=utf-8'}
 
-    VALID_JSONP_CALLBACK = /^[a-z_\$][a-z0-9_\$]*(\.[a-z_\$][a-z0-9_\$]*)*$/i
-
     # This header is passed by Rack::Proxy during testing. Rack::Proxy seems to
     # set content-length for you, and setting it in here really slows the tests
     # down. Better suggestions welcome.
     HTTP_X_NO_CONTENT_LENGTH = 'HTTP_X_NO_CONTENT_LENGTH'
 
     def initialize(app = nil, options = nil)
-      @app      = app if app.respond_to?(:call)
-      @options  = [app, options].grep(Hash).first || {}
+      @app     = app if app.respond_to?(:call)
+      @options = [app, options].grep(Hash).first || {}
 
       @endpoint    = @options[:mount] || DEFAULT_ENDPOINT
-      @endpoint_re = Regexp.new('^' + @endpoint.gsub(/\/$/, '') + '(/[^/]+)*(\\.[^\\.]+)?$')
+      @endpoint_re = Regexp.new('^' + @endpoint.gsub(/\/$/, '') + '(/[^/]*)*(\\.[^\\.]+)?$')
       @server      = Server.new(@options)
 
       @static = StaticServer.new(ROOT, /\.(?:js|map)$/)
@@ -38,6 +36,10 @@ module Faye
       [*extensions].each { |extension| add_extension(extension) }
     end
 
+    def listen(*args)
+      raise 'The listen() method is deprecated - see https://github.com/faye/faye-websocket-ruby#running-your-socket-application for information on running your Faye server'
+    end
+
     def add_extension(extension)
       @server.add_extension(extension)
     end
@@ -50,27 +52,6 @@ module Faye
       @client ||= Client.new(@server)
     end
 
-    def listen(port, ssl_options = nil)
-      Faye::WebSocket.load_adapter('thin')
-      handler = Rack::Handler.get('thin')
-      handler.run(self, :Port => port) do |s|
-        if ssl_options
-          s.ssl = true
-          s.ssl_options = {
-            :private_key_file => ssl_options[:key],
-            :cert_chain_file  => ssl_options[:cert]
-          }
-        end
-        @thin_server = s
-      end
-    end
-
-    def stop
-      return unless @thin_server
-      @thin_server.stop
-      @thin_server = nil
-    end
-
     def call(env)
       Faye.ensure_reactor_running!
       request = Rack::Request.new(env)
@@ -81,14 +62,15 @@ module Faye
                       [404, TYPE_TEXT, ["Sure you're not looking for #{@endpoint} ?"]]
       end
 
+      return @static.call(env) if @static =~ request.path_info
+
       # http://groups.google.com/group/faye-users/browse_thread/thread/4a01bb7d25d3636a
       if env['REQUEST_METHOD'] == 'OPTIONS' or env['HTTP_ACCESS_CONTROL_REQUEST_METHOD'] == 'POST'
-        return handle_options(request)
+        return handle_options
       end
 
-      return @static.call(env)        if @static =~ request.path_info
-      return handle_websocket(env)    if Faye::WebSocket.websocket?(env)
-      return handle_eventsource(env)  if Faye::EventSource.eventsource?(env)
+      return handle_websocket(request)   if Faye::WebSocket.websocket?(env)
+      return handle_eventsource(request) if Faye::EventSource.eventsource?(env)
 
       handle_request(request)
     end
@@ -103,35 +85,27 @@ module Faye
 
       debug "Received message via HTTP #{request.request_method}: ?", json_msg
 
-      message  = Yajl::Parser.parse(json_msg)
+      message = MultiJson.load(json_msg)
+      request.env['rack.hijack'].call if request.env['rack.hijack']
+
       jsonp    = request.params['jsonp'] || JSONP_CALLBACK
       headers  = request.get? ? TYPE_SCRIPT.dup : TYPE_JSON.dup
       origin   = request.env['HTTP_ORIGIN']
       callback = request.env['async.callback']
-
-      if jsonp !~ VALID_JSONP_CALLBACK
-        error 'Invalid JSON-P callback: ?', jsonp
-        return [400, TYPE_TEXT, ['Bad request']]
-      end
-
-      @server.flush_connection(message) if request.get?
+      hijack   = request.env['rack.hijack_io']
 
       headers['Access-Control-Allow-Origin'] = origin if origin
       headers['Cache-Control'] = 'no-cache, no-store'
-      headers['X-Content-Type-Options'] = 'nosniff'
-
-      @server.process(message, false) do |replies|
-        response = Faye.to_json(replies)
 
-        if request.get?
-          response = "/**/#{ jsonp }(#{ response });"
-          headers['Content-Disposition'] = 'attachment; filename=f.txt'
+      EventMachine.next_tick do
+        @server.process(message, request) do |replies|
+          response = Faye.to_json(replies)
+          response = "#{ jsonp }(#{ jsonp_escape(response) });" if request.get?
+          headers['Content-Length'] = response.bytesize.to_s unless request.env[HTTP_X_NO_CONTENT_LENGTH]
+          headers['Connection'] = 'close'
+          debug 'HTTP response: ?', response
+          send_response([200, headers, [response]], hijack, callback)
         end
-
-        headers['Content-Length'] = response.bytesize.to_s unless request.env[HTTP_X_NO_CONTENT_LENGTH]
-        headers['Connection'] = 'close'
-        debug 'HTTP response: ?', response
-        callback.call [200, headers, [response]]
       end
 
       ASYNC_RESPONSE
@@ -140,22 +114,59 @@ module Faye
       [400, TYPE_TEXT, ['Bad request']]
     end
 
-    def handle_websocket(env)
-      ws        = Faye::WebSocket.new(env, nil, :ping => @options[:ping])
+    def message_from_request(request)
+      message = request.params['message']
+      return message if message
+
+      # Some clients do not send a content-type, e.g.
+      # Internet Explorer when using cross-origin-long-polling
+      # Some use application/xml when using CORS
+      content_type = request.env['CONTENT_TYPE'] || ''
+
+      if content_type.split(';').first == 'application/json'
+        request.body.read
+      else
+        CGI.parse(request.body.read)['message'][0]
+      end
+    end
+
+    def jsonp_escape(json)
+      json.gsub(/\u2028/, '\u2028').gsub(/\u2029/, '\u2029')
+    end
+
+    def send_response(response, hijack, callback)
+      return callback.call(response) if callback
+
+      buffer = "HTTP/1.1 #{response[0]} OK\r\n"
+      response[1].each do |name, value|
+        buffer << "#{name}: #{value}\r\n"
+      end
+      buffer << "\r\n"
+      response[2].each do |chunk|
+        buffer << chunk
+      end
+
+      hijack.write(buffer)
+      hijack.flush
+      hijack.close_write
+    end
+
+    def handle_websocket(request)
+      ws        = Faye::WebSocket.new(request.env, nil, :ping => @options[:ping])
       client_id = nil
 
       ws.onmessage = lambda do |event|
         begin
           debug "Received message via WebSocket[#{ws.version}]: ?", event.data
 
-          message = Yajl::Parser.parse(event.data)
+          message = MultiJson.load(event.data)
           cid     = Faye.client_id_from_messages(message)
 
-          @server.close_socket(client_id) if client_id and cid != client_id
-          @server.open_socket(cid, ws)
+          @server.close_socket(client_id) if client_id and cid and cid != client_id
+          @server.open_socket(cid, ws, request)
           client_id = cid
 
-          @server.process(message, false) do |replies|
+          @server.process(message, request) do |replies|
             ws.send(Faye.to_json(replies)) if ws
           end
         rescue => e
@@ -171,12 +182,12 @@ module Faye
       ws.rack_response
     end
 
-    def handle_eventsource(env)
-      es        = Faye::EventSource.new(env, :ping => @options[:ping])
+    def handle_eventsource(request)
+      es        = Faye::EventSource.new(request.env, :ping => @options[:ping])
       client_id = es.url.split('/').pop
 
       debug 'Opened EventSource connection for ?', client_id
-      @server.open_socket(client_id, es)
+      @server.open_socket(client_id, es, request)
 
       es.onclose = lambda do |event|
         @server.close_socket(client_id)
@@ -186,20 +197,15 @@ module Faye
       es.rack_response
     end
 
-    def message_from_request(request)
-      message = request.params['message']
-      return message if message
-
-      # Some clients do not send a content-type, e.g.
-      # Internet Explorer when using cross-origin-long-polling
-      # Some use application/xml when using CORS
-      content_type = request.env['CONTENT_TYPE'] || ''
-
-      if content_type.split(';').first == 'application/json'
-        request.body.read
-      else
-        CGI.parse(request.body.read)['message'][0]
-      end
+    def handle_options
+      headers = {
+        'Access-Control-Allow-Credentials' => 'false',
+        'Access-Control-Allow-Headers'     => 'Accept, Content-Type, Pragma, X-Requested-With',
+        'Access-Control-Allow-Methods'     => 'POST, GET, PUT, DELETE, OPTIONS',
+        'Access-Control-Allow-Origin'      => '*',
+        'Access-Control-Max-Age'           => '86400'
+      }
+      [200, headers, []]
     end
 
     def format_request(request)
@@ -213,17 +219,6 @@ module Faye
       string
     end
 
-    def handle_options(request)
-      headers = {
-        'Access-Control-Allow-Origin'       => '*',
-        'Access-Control-Allow-Credentials'  => 'false',
-        'Access-Control-Max-Age'            => '86400',
-        'Access-Control-Allow-Methods'      => 'POST, GET, PUT, DELETE, OPTIONS',
-        'Access-Control-Allow-Headers'      => 'Accept, Content-Type, Pragma, X-Requested-With'
-      }
-      [200, headers, ['']]
-    end
-
   end
 end
 

data/lib/faye/engines/connection.rb

@@ -2,7 +2,7 @@ module Faye
   module Engine
 
     class Connection
-      include EventMachine::Deferrable
+      include Deferrable
       include Timeouts
 
       attr_accessor :socket
@@ -24,7 +24,7 @@ module Faye
         options = options || {}
         timeout = options['timeout'] ? options['timeout'] / 1000.0 : @engine.timeout
 
-        set_deferred_status(:deferred)
+        set_deferred_status(:unknown)
         callback(&block)
 
         begin_delivery_timeout
@@ -32,19 +32,17 @@ module Faye
       end
 
       def flush!(force = false)
-        release_connection!(force)
+        @engine.close_connection(@id) if force or socket.nil?
+
+        remove_timeout(:connection)
+        remove_timeout(:delivery)
+
         set_deferred_status(:succeeded, @inbox.entries)
         @inbox = []
       end
 
     private
 
-      def release_connection!(force = false)
-        @engine.close_connection(@id) if force or socket.nil?
-        remove_timeout(:connection)
-        remove_timeout(:delivery)
-      end
-
       def begin_delivery_timeout
         return if @inbox.empty?
         add_timeout(:delivery, MAX_DELAY) { flush! }

data/lib/faye/engines/memory.rb

@@ -37,6 +37,7 @@ module Faye
         @messages.delete(client_id)
         @server.debug 'Destroyed client ?', client_id
         @server.trigger(:disconnect, client_id)
+        @server.trigger(:close, client_id)
         callback.call if callback
       end
 

data/lib/faye/engines/proxy.rb

@@ -20,10 +20,10 @@ module Faye
     end
 
     def self.random(bitlength = ID_LENGTH)
-      limit    = 2 ** bitlength - 1
-      max_size = limit.to_s(36).size
-      string   = rand(limit).to_s(36)
-      string = '0' + string while string.size < max_size
+      limit    = 2 ** bitlength
+      max_size = (limit - 1).to_s(36).size
+      string   = SecureRandom.random_number(limit).to_s(36)
+      string   = '0' + string while string.size < max_size
       string
     end
 
@@ -37,6 +37,8 @@ module Faye
       def_delegators :@engine, *METHODS
 
       def initialize(options)
+        super()
+
         @options     = options
         @connections = {}
         @interval    = @options[:interval] || INTERVAL
@@ -45,7 +47,7 @@ module Faye
         engine_class = @options[:type] || Memory
         @engine      = engine_class.create(self, @options)
 
-        bind :disconnect do |client_id|
+        bind :close do |client_id|
           EventMachine.next_tick { close_connection(client_id) }
         end
 
@@ -82,7 +84,6 @@ module Faye
       end
 
       def open_socket(client_id, socket)
-        return unless client_id
         conn = connection(client_id, true)
         conn.socket = socket
       end

data/lib/faye/mixins/deferrable.rb

@@ -0,0 +1,15 @@
+module Faye
+  module Deferrable
+
+    include EventMachine::Deferrable
+
+    def set_deferred_status(status, *args)
+      if status == :unknown
+        @deferred_status = @deferred_args = @callbacks = @errbacks = nil
+      end
+      super
+    end
+
+  end
+end
+

data/lib/faye/mixins/logging.rb

@@ -1,45 +1,34 @@
 module Faye
   module Logging
 
-    DEFAULT_LOG_LEVEL = :error
-
     LOG_LEVELS = {
+      :fatal  => 4,
       :error  => 3,
       :warn   => 2,
       :info   => 1,
       :debug  => 0
     }
 
-    class << self
-      attr_writer :log_level
-
-      def log_level
-        @log_level || DEFAULT_LOG_LEVEL
-      end
-    end
-
-    attr_writer :log_level
+  private
 
-    def log_level
-      @log_level || Logging.log_level
+    LOG_LEVELS.each do |level, value|
+      define_method(level) { |*args| write_log(args, level) }
     end
 
-    def log(message_args, level)
+    def write_log(message_args, level)
       return unless Faye.logger
-      return if LOG_LEVELS[log_level] > LOG_LEVELS[level]
 
       message = message_args.shift.gsub(/\?/) do
         Faye.to_json(message_args.shift)
       end
 
-      timestamp = Time.now.strftime('%Y-%m-%d %H:%M:%S')
-      banner = " [#{ level.to_s.upcase }] [#{ self.class.name }] "
-
-      Faye.logger.call(timestamp + banner + message)
-    end
+      banner = "[#{ self.class.name }] "
 
-    LOG_LEVELS.each do |level, value|
-      define_method(level) { |*args| log(args, level) }
+      if Faye.logger.respond_to?(level)
+        Faye.logger.__send__(level, banner + message)
+      elsif Faye.logger.respond_to?(:call)
+        Faye.logger.call(banner + message)
+      end
     end
 
   end