faye 0.8.8 → 0.8.9

data/lib/faye.rb

@@ -13,18 +13,18 @@ require 'uri'
 require 'yajl'
 
 module Faye
-  VERSION = '0.8.8'
-  
+  VERSION = '0.8.9'
+
   ROOT = File.expand_path(File.dirname(__FILE__))
-  
+
   autoload :Publisher,    File.join(ROOT, 'faye', 'mixins', 'publisher')
   autoload :Timeouts,     File.join(ROOT, 'faye', 'mixins', 'timeouts')
   autoload :Logging,      File.join(ROOT, 'faye', 'mixins', 'logging')
-  
+
   autoload :Namespace,    File.join(ROOT, 'faye', 'util', 'namespace')
-  
+
   autoload :Engine,       File.join(ROOT, 'faye', 'engines', 'proxy')
-  
+
   autoload :Grammar,      File.join(ROOT, 'faye', 'protocol', 'grammar')
   autoload :Extensible,   File.join(ROOT, 'faye', 'protocol', 'extensible')
   autoload :Channel,      File.join(ROOT, 'faye', 'protocol', 'channel')
@@ -32,37 +32,37 @@ module Faye
   autoload :Publication,  File.join(ROOT, 'faye', 'protocol', 'publication')
   autoload :Client,       File.join(ROOT, 'faye', 'protocol', 'client')
   autoload :Server,       File.join(ROOT, 'faye', 'protocol', 'server')
-  
+
   autoload :Transport,    File.join(ROOT, 'faye', 'transport', 'transport')
   autoload :Error,        File.join(ROOT, 'faye', 'error')
-  
+
   autoload :RackAdapter,  File.join(ROOT, 'faye', 'adapters', 'rack_adapter')
   autoload :StaticServer, File.join(ROOT, 'faye', 'adapters', 'static_server')
-  
+
   BAYEUX_VERSION   = '1.0'
   JSONP_CALLBACK   = 'jsonpcallback'
   CONNECTION_TYPES = %w[long-polling cross-origin-long-polling callback-polling websocket eventsource in-process]
-  
+
   MANDATORY_CONNECTION_TYPES = %w[long-polling callback-polling in-process]
-  
+
   class << self
     attr_accessor :logger
   end
   self.logger = method(:puts)
-  
+
   def self.ensure_reactor_running!
     Engine.ensure_reactor_running!
   end
-  
+
   def self.random(*args)
     Engine.random(*args)
   end
-  
+
   def self.client_id_from_messages(messages)
     first = [messages].flatten.first
     first && first['clientId']
   end
-  
+
   def self.copy_object(object)
     case object
     when Hash
@@ -77,7 +77,7 @@ module Faye
       object
     end
   end
-  
+
   def self.to_json(value)
     case value
       when Hash, Array then Yajl::Encoder.encode(value)
@@ -85,15 +85,15 @@ module Faye
       else value.to_s
     end
   end
-  
+
   def self.async_each(list, iterator, callback)
     n       = list.size
     i       = -1
     calls   = 0
     looping = false
-    
+
     loop, resume = nil, nil
-    
+
     iterate = lambda do
       calls -= 1
       i += 1
@@ -103,7 +103,7 @@ module Faye
         iterator.call(list[i], resume)
       end
     end
-    
+
     loop = lambda do
       unless looping
         looping = true
@@ -111,7 +111,7 @@ module Faye
         looping = false
       end
     end
-    
+
     resume = lambda do
       calls += 1
       loop.call

data/lib/faye/adapters/rack_adapter.rb

@@ -1,53 +1,53 @@
 module Faye
   class RackAdapter
-    
+
     include Logging
 
     extend Forwardable
     def_delegators "@server.engine", :bind, :unbind
 
     ASYNC_RESPONSE = [-1, {}, []].freeze
-    
+
     DEFAULT_ENDPOINT  = '/bayeux'
     SCRIPT_PATH       = 'faye-browser-min.js'
-    
+
     TYPE_JSON   = {'Content-Type' => 'application/json; charset=utf-8'}
     TYPE_SCRIPT = {'Content-Type' => 'text/javascript; charset=utf-8'}
     TYPE_TEXT   = {'Content-Type' => 'text/plain; charset=utf-8'}
-    
+
     # 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 || {}
-      
+
       @endpoint    = @options[:mount] || DEFAULT_ENDPOINT
-      @endpoint_re = Regexp.new('^' + @endpoint + '(/[^/]+)*(\\.[^\\.]+)?$')
+      @endpoint_re = Regexp.new('^' + @endpoint.gsub(/\/$/, '') + '(/[^/]+)*(\\.[^\\.]+)?$')
       @server      = Server.new(@options)
-      
+
       @static = StaticServer.new(ROOT, /\.(?:js|map)$/)
       @static.map(File.basename(@endpoint) + '.js', SCRIPT_PATH)
       @static.map('client.js', SCRIPT_PATH)
-      
+
       return unless extensions = @options[:extensions]
       [*extensions].each { |extension| add_extension(extension) }
     end
-    
+
     def add_extension(extension)
       @server.add_extension(extension)
     end
-    
+
     def remove_extension(extension)
       @server.remove_extension(extension)
     end
-    
+
     def get_client
       @client ||= Client.new(@server)
     end
-    
+
     def listen(port, ssl_options = nil)
       Faye::WebSocket.load_adapter('thin')
       handler = Rack::Handler.get('thin')
@@ -62,56 +62,56 @@ module Faye
         @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)
-      
+
       unless request.path_info =~ @endpoint_re
         env['faye.client'] = get_client
         return @app ? @app.call(env) :
                       [404, TYPE_TEXT, ["Sure you're not looking for #{@endpoint} ?"]]
       end
-      
+
       # 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)
       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)
-      
+
       handle_request(request)
     end
-    
+
   private
-    
+
     def handle_request(request)
       unless json_msg = message_from_request(request)
         error 'Received request with no message: ?', format_request(request)
         return [400, TYPE_TEXT, ['Bad request']]
       end
-      
+
       debug "Received message via HTTP #{request.request_method}: ?", json_msg
-      
+
       message  = Yajl::Parser.parse(json_msg)
       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']
-      
+
       @server.flush_connection(message) if request.get?
-      
+
       headers['Access-Control-Allow-Origin'] = origin if origin
       headers['Cache-Control'] = 'no-cache, no-store'
-      
+
       @server.process(message, false) do |replies|
         response = Faye.to_json(replies)
         response = "#{ jsonp }(#{ response });" if request.get?
@@ -120,26 +120,28 @@ module Faye
         debug 'HTTP response: ?', response
         callback.call [200, headers, [response]]
       end
-      
+
       ASYNC_RESPONSE
     rescue => e
       error "#{e.message}\nBacktrace:\n#{e.backtrace * "\n"}"
       [400, TYPE_TEXT, ['Bad request']]
     end
-    
+
     def handle_websocket(env)
       ws        = Faye::WebSocket.new(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)
-          client_id = Faye.client_id_from_messages(message)
-          
-          @server.open_socket(client_id, ws)
-          
+
+          message = Yajl::Parser.parse(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)
+          client_id = cid
+
           @server.process(message, false) do |replies|
             ws.send(Faye.to_json(replies)) if ws
           end
@@ -147,57 +149,57 @@ module Faye
           error "#{e.message}\nBacktrace:\n#{e.backtrace * "\n"}"
         end
       end
-      
+
       ws.onclose = lambda do |event|
         @server.close_socket(client_id)
         ws = nil
       end
-      
+
       ws.rack_response
     end
-    
+
     def handle_eventsource(env)
       es        = Faye::EventSource.new(env, :ping => @options[:ping])
       client_id = es.url.split('/').pop
-      
+
       debug 'Opened EventSource connection for ?', client_id
       @server.open_socket(client_id, es)
-      
+
       es.onclose = lambda do |event|
         @server.close_socket(client_id)
         es = nil
       end
-      
+
       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
     end
-    
+
     def format_request(request)
       request.body.rewind
       string = "curl -X #{request.request_method.upcase}"
       string << " '#{request.url}'"
       if request.post?
-        string << " -H 'Content-Type: #{request.env['CONTENT_TYPE']}'" 
+        string << " -H 'Content-Type: #{request.env['CONTENT_TYPE']}'"
         string << " -d '#{request.body.read}'"
       end
       string
     end
-    
+
     def handle_options(request)
       headers = {
         'Access-Control-Allow-Origin'       => '*',
@@ -208,7 +210,7 @@ module Faye
       }
       [200, headers, ['']]
     end
-    
+
   end
 end
 

data/lib/faye/adapters/static_server.rb

@@ -1,29 +1,28 @@
 module Faye
   class StaticServer
-    
+
     def initialize(directory, path_regex)
       @directory  = directory
       @path_regex = path_regex
       @path_map   = {}
       @index      = {}
     end
-    
+
     def map(request_path, filename)
       @path_map[request_path] = filename
     end
-    
+
     def =~(pathname)
       @path_regex =~ pathname
     end
-    
+
     def call(env)
-      pathname = env['PATH_INFO']
-      pathname = File.basename(pathname)
-      pathname = @path_map[pathname] || pathname
-      
-      cache = @index[pathname] ||= {}
-      fullpath = File.join(@directory, pathname)
-      
+      filename = File.basename(env['PATH_INFO'])
+      filename = @path_map[filename] || filename
+
+      cache = @index[filename] ||= {}
+      fullpath = File.join(@directory, filename)
+
       begin
         cache[:content] ||= File.read(fullpath)
         cache[:digest]  ||= Digest::SHA1.hexdigest(cache[:content])
@@ -31,26 +30,27 @@ module Faye
       rescue
         return [404, {}, []]
       end
-      
-      type    = /\.js$/ =~ fullpath ? RackAdapter::TYPE_SCRIPT : RackAdapter::TYPE_JSON
-      headers = type.dup
-      ims     = env['HTTP_IF_MODIFIED_SINCE']
-      
+
+      type = /\.js$/ =~ fullpath ? RackAdapter::TYPE_SCRIPT : RackAdapter::TYPE_JSON
+      ims  = env['HTTP_IF_MODIFIED_SINCE']
+
       no_content_length = env[RackAdapter::HTTP_X_NO_CONTENT_LENGTH]
-      
-      headers['Content-Length'] = '0' unless no_content_length
-      headers['ETag'] = cache[:digest]
-      headers['Last-Modified'] = cache[:mtime].httpdate
-      
+
+      headers = {
+        'ETag'          => cache[:digest],
+        'Last-Modified' => cache[:mtime].httpdate
+      }
+
       if env['HTTP_IF_NONE_MATCH'] == cache[:digest]
         [304, headers, ['']]
       elsif ims and cache[:mtime] <= Time.httpdate(ims)
         [304, headers, ['']]
       else
         headers['Content-Length'] = cache[:content].bytesize.to_s unless no_content_length
+        headers.update(type)
         [200, headers, [cache[:content]]]
       end
     end
-    
+
   end
 end

data/lib/faye/engines/connection.rb

@@ -1,60 +1,60 @@
 module Faye
   module Engine
-    
+
     class Connection
       include EventMachine::Deferrable
       include Timeouts
-      
+
       attr_accessor :socket
-      
+
       def initialize(engine, id, options = {})
         @engine  = engine
         @id      = id
         @options = options
         @inbox   = Set.new
       end
-      
+
       def deliver(message)
         return socket.send(message) if socket
         return unless @inbox.add?(message)
         begin_delivery_timeout
       end
-      
+
       def connect(options, &block)
         options = options || {}
         timeout = options['timeout'] ? options['timeout'] / 1000.0 : @engine.timeout
-        
+
         set_deferred_status(:deferred)
         callback(&block)
-        
+
         begin_delivery_timeout
         begin_connection_timeout(timeout)
       end
-      
+
       def flush!(force = false)
         release_connection!(force)
         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! }
       end
-      
+
       def begin_connection_timeout(timeout)
         add_timeout(:connection, timeout) { flush! }
       end
     end
-    
+
   end
 end