faye 0.5.5 → 0.6.0

data/lib/faye/protocol/extensible.rb

@@ -1,5 +1,6 @@
 module Faye
   module Extensible
+    include Logging
     
     def add_extension(extension)
       @extensions ||= []
@@ -20,6 +21,8 @@ module Faye
     end
     
     def pipe_through_extensions(stage, message, &callback)
+      debug 'Passing through ? extensions: ?', stage, message
+
       return callback.call(message) unless @extensions
       extensions = @extensions.dup
       

data/lib/faye/protocol/server.rb

@@ -5,30 +5,35 @@ module Faye
     include Extensible
     
     def initialize(options = {})
-      info('New server created')
-      @options     = options
-      @channels    = Channel::Tree.new
-      @connections = {}
-      @namespace   = Namespace.new
+      @options    = options || {}
+      engine_opts = @options[:engine] || {}
+      engine_opts[:timeout] = @options[:timeout]
+      @engine     = Faye::Engine.get(engine_opts)
+
+      info 'Created new server: ?', @options
     end
     
-    def client_ids
-      @connections.keys
+    def flush_connection(messages)
+      [messages].flatten.each do |message|
+        client_id = message["clientId"]
+        info 'Flushing connection for ?', client_id
+        @engine.flush(client_id) if client_id
+      end
     end
     
-    def process(messages, local_or_remote = false, &callback)
-      socket = local_or_remote.is_a?(WebSocket) ? local_or_remote : nil
-      local  = (local_or_remote == true)
-      
-      debug('Processing messages from ? client', local ? 'LOCAL' : 'REMOTE')
-      
+    def process(messages, local = false, &callback)
       messages = [messages].flatten
+      info 'Processing messages: ? (local: ?)', messages, local
+
+      return callback.call([]) if messages.size == 0
       processed, responses = 0, []
       
       gather_replies = lambda do |replies|
         responses.concat(replies)
         processed += 1
-        callback.call(responses.compact) if processed == messages.size
+        responses.compact!
+        info 'Returning replies: ?', responses
+        callback.call(responses) if processed == messages.size
       end
       
       handle_reply = lambda do |replies|
@@ -36,6 +41,7 @@ module Faye
         gather_replies.call(replies) if expected == 0
         
         replies.each_with_index do |reply, i|
+          debug 'Processing reply: ?', reply
           pipe_through_extensions(:outgoing, reply) do |message|
             replies[i] = message
             extended  += 1
@@ -46,33 +52,11 @@ module Faye
       
       messages.each do |message|
         pipe_through_extensions(:incoming, message) do |piped_message|
-          handle(piped_message, socket, local, &handle_reply)
+          handle(piped_message, local, &handle_reply)
         end
       end
     end
     
-    def flush_connection(messages)
-      [messages].flatten.each do |message|
-        connection = @connections[message['clientId']]
-        connection.flush! if connection
-      end
-    end
-    
-  private
-    
-    def connection(id)
-      return @connections[id] if @connections.has_key?(id)
-      connection = Connection.new(id, @options)
-      connection.add_subscriber(:stale_connection, method(:destroy_connection))
-      @connections[id] = connection
-    end
-    
-    def destroy_connection(connection)
-      connection.disconnect!
-      connection.remove_subscriber(:stale_connection, method(:destroy_connection))
-      @connections.delete(connection.id)
-    end
-    
     def make_response(message)
       response = {}
       %w[id clientId channel error].each do |field|
@@ -84,22 +68,15 @@ module Faye
       response
     end
     
-    def distribute_message(message)
-      return if message['error']
-      @channels.glob(message['channel']).each do |channel|
-        channel << message
-        info('Publishing message ? from client ? to ?', message['data'], message['clientId'], channel.name)
-      end
-    end
-    
-    def handle(message, socket = nil, local = false, &callback)
+    def handle(message, local = false, &callback)
       return callback.call([]) if !message
+      info 'Handling message: ? (local: ?)', message, local
       
-      distribute_message(message)
       channel_name = message['channel']
+      @engine.publish(message) unless message['error'] or Grammar::CHANNEL_NAME !~ channel_name
       
       if Channel.meta?(channel_name)
-        handle_meta(message, socket, local, &callback)
+        handle_meta(message, local, &callback)
       elsif message['clientId'].nil?
         callback.call([])
       else
@@ -109,46 +86,24 @@ module Faye
       end
     end
     
-    def handle_meta(message, socket, local, &callback)
-      response = __send__(Channel.parse(message['channel'])[1], message, local)
+    def handle_meta(message, local, &callback)
+      method = Channel.parse(message['channel'])[1]
       
-      advize(response)
-      
-      if response['channel'] == Channel::CONNECT and response['successful'] == true
-        return accept_connection(message['advice'], response, socket, &callback)
-      end
-      
-      callback.call([response])
-    end
-    
-    def accept_connection(options, response, socket, &callback)
-      info('Accepting connection from ?', response['clientId'])
-      
-      connection = connection(response['clientId'])
-      
-      # Disabled because CometD doesn't like messages not being
-      # delivered as part of a /meta/* response
-      # if socket
-      #   return connection.socket = socket
-      # end
-      
-      connection.connect(options) do |events|
-        info('Sending event messages to ?', response['clientId'])
-        debug('Events for ?: ?', response['clientId'], events)
-        callback.call([response] + events)
+      __send__(method, message, local) do |responses|
+        responses = [responses].flatten
+        responses.each(&method(:advize))
+        callback.call(responses)
       end
     end
     
     def advize(response)
-      connection = @connections[response['clientId']]
-      
       advice = response['advice'] ||= {}
-      if connection
-        advice['reconnect'] ||= 'retry'
-        advice['interval']  ||= (connection.interval * 1000).floor
-        advice['timeout']   ||= (connection.timeout * 1000).floor
-      else
+      if response['error']
         advice['reconnect'] ||= 'handshake'
+      else
+        advice['reconnect'] ||= 'retry'
+        advice['interval']  ||= (@engine.interval * 1000).floor
+        advice['timeout']   ||= (@engine.timeout * 1000).floor
       end
     end
     
@@ -157,7 +112,7 @@ module Faye
     # MAY contain   * minimumVersion
     #               * ext
     #               * id
-    def handshake(message, local = false)
+    def handshake(message, local = false, &callback)
       response = make_response(message)
       response['version'] = BAYEUX_VERSION
       
@@ -177,128 +132,123 @@ module Faye
       end
       
       response['successful'] = response['error'].nil?
-      return response unless response['successful']
+      return callback.call(response) unless response['successful']
       
-      client_id = @namespace.generate
-      response['clientId'] = connection(client_id).id
-      info('Accepting handshake from client ?', response['clientId'])
-      response
+      @engine.create_client do |client_id|
+        response['clientId'] = client_id
+        callback.call(response)
+      end
     end
     
     # MUST contain  * clientId
     #               * connectionType
     # MAY contain   * ext
     #               * id
-    def connect(message, local = false)
-      response   = make_response(message)
-      
-      client_id  = message['clientId']
-      connection = client_id ? @connections[client_id] : nil
+    def connect(message, local = false, &callback)
+      response        = make_response(message)
+      client_id       = message['clientId']
       connection_type = message['connectionType']
       
-      response['error'] = Error.client_unknown(client_id) if connection.nil?
-      response['error'] = Error.parameter_missing('clientId') if client_id.nil?
-      response['error'] = Error.parameter_missing('connectionType') if connection_type.nil?
-      
-      response['successful'] = response['error'].nil?
-      response.delete('clientId') unless response['successful']
-      return response unless response['successful']
-      
-      response['clientId'] = connection.id
-      response
+      @engine.client_exists(client_id) do |exists|
+        response['error'] = Error.client_unknown(client_id) unless exists
+        response['error'] = Error.parameter_missing('clientId') if client_id.nil?
+        
+        unless CONNECTION_TYPES.include?(connection_type)
+          response['error'] = Error.conntype_mismatch(connection_type)
+        end
+        
+        response['error'] = Error.parameter_missing('connectionType') if connection_type.nil?
+        
+        response['successful'] = response['error'].nil?
+        
+        if response['successful']
+          @engine.connect(response['clientId'], message['advice']) do |events|
+            callback.call([response] + events)
+          end
+        else
+          response.delete('clientId')
+          callback.call(response)
+        end
+      end
     end
     
     # MUST contain  * clientId
     # MAY contain   * ext
     #               * id
-    def disconnect(message, local = false)
-      response   = make_response(message)
-      
+    def disconnect(message, local = false, &callback)
+      response   = make_response(message)      
       client_id  = message['clientId']
-      connection = client_id ? @connections[client_id] : nil
-      
-      response['error'] = Error.client_unknown(client_id) if connection.nil?
-      response['error'] = Error.parameter_missing('clientId') if client_id.nil?
-      
-      response['successful'] = response['error'].nil?
-      response.delete('clientId') unless response['successful']
-      return response unless response['successful']
       
-      destroy_connection(connection)
-      
-      info('Disconnected client: ?', client_id)
-      response['clientId'] = client_id
-      response
+      @engine.client_exists(client_id) do |exists|
+        response['error'] = Error.client_unknown(client_id) unless exists
+        response['error'] = Error.parameter_missing('clientId') if client_id.nil?
+        
+        response['successful'] = response['error'].nil?
+        response.delete('clientId') unless response['successful']
+        
+        @engine.destroy_client(client_id) if response['successful']
+        callback.call(response)
+      end
     end
     
     # MUST contain  * clientId
     #               * subscription
     # MAY contain   * ext
     #               * id
-    def subscribe(message, local = false)
-      response      = make_response(message)
-      
-      client_id     = message['clientId']
-      connection    = client_id ? @connections[client_id] : nil
-      subscription  = [message['subscription']].flatten
-      
-      response['error'] = Error.client_unknown(client_id) if connection.nil?
-      response['error'] = Error.parameter_missing('clientId') if client_id.nil?
-      response['error'] = Error.parameter_missing('subscription') if message['subscription'].nil?
-      
-      response['subscription'] = subscription.compact
-      
-      subscription.each do |channel_name|
-        next if response['error']
-        response['error'] = Error.channel_forbidden(channel_name) unless local or Channel.subscribable?(channel_name)
-        response['error'] = Error.channel_invalid(channel_name) unless Channel.valid?(channel_name)
+    def subscribe(message, local = false, &callback)
+      response     = make_response(message)
+      client_id    = message['clientId']
+      subscription = [message['subscription']].flatten
+      
+      @engine.client_exists(client_id) do |exists|
+        response['error'] = Error.client_unknown(client_id) unless exists
+        response['error'] = Error.parameter_missing('clientId') if client_id.nil?
+        response['error'] = Error.parameter_missing('subscription') if message['subscription'].nil?
         
-        next if response['error']
-        channel = @channels[channel_name] ||= Channel.new(channel_name)
+        response['subscription'] = message['subscription'] || []
         
-        info('Subscribing client ? to ?', client_id, channel.name)
-        connection.subscribe(channel)
+        subscription.each do |channel|
+          next if response['error']
+          response['error'] = Error.channel_forbidden(channel) unless local or Channel.subscribable?(channel)
+          response['error'] = Error.channel_invalid(channel) unless Channel.valid?(channel)
+          
+          next if response['error']
+          @engine.subscribe(client_id, channel)
+        end
+        
+        response['successful'] = response['error'].nil?
+        callback.call(response)
       end
-      
-      response['successful'] = response['error'].nil?
-      response
     end
     
     # MUST contain  * clientId
     #               * subscription
     # MAY contain   * ext
     #               * id
-    def unsubscribe(message, local = false)
-      response      = make_response(message)
-      
-      client_id     = message['clientId']
-      connection    = client_id ? @connections[client_id] : nil
-      subscription  = [message['subscription']].flatten
-      
-      response['error'] = Error.client_unknown(client_id) if connection.nil?
-      response['error'] = Error.parameter_missing('clientId') if client_id.nil?
-      response['error'] = Error.parameter_missing('subscription') if message['subscription'].nil?
-      
-      response['subscription'] = subscription.compact
-      
-      subscription.each do |channel_name|
-        next if response['error']
+    def unsubscribe(message, local = false, &callback)
+      response     = make_response(message)
+      client_id    = message['clientId']
+      subscription = [message['subscription']].flatten
+      
+      @engine.client_exists(client_id) do |exists|
+        response['error'] = Error.client_unknown(client_id) unless exists
+        response['error'] = Error.parameter_missing('clientId') if client_id.nil?
+        response['error'] = Error.parameter_missing('subscription') if message['subscription'].nil?
         
-        unless Channel.valid?(channel_name)
-          response['error'] = Error.channel_invalid(channel_name)
-          next
-        end
+        response['subscription'] = message['subscription'] || []
         
-        channel = @channels[channel_name]
-        next unless channel
+        subscription.each do |channel|
+          next if response['error']
+          response['error'] = Error.channel_forbidden(channel) unless local or Channel.subscribable?(channel)
+          response['error'] = Error.channel_invalid(channel) unless Channel.valid?(channel)
+          
+          next if response['error']
+          @engine.unsubscribe(client_id, channel)
+        end
         
-        info('Unsubscribing client ? from ?', client_id, channel.name)
-        connection.unsubscribe(channel)
-        @channels.remove(channel_name) if channel.unused?
+        response['successful'] = response['error'].nil?
+        callback.call(response)
       end
-      
-      response['successful'] = response['error'].nil?
-      response
     end
     
   end

data/lib/faye/transport/http.rb

@@ -0,0 +1,45 @@
+require 'em-http'
+require 'em-http/version'
+
+module Faye
+  
+  class Transport::Http < Transport
+    def self.usable?(endpoint)
+      endpoint.is_a?(String)
+    end
+    
+    def request(message, timeout)
+      retry_block = retry_block(message, timeout)
+      
+      content = JSON.unparse(message)
+      params = {
+        :head => {
+          'Content-Type'    => 'application/json',
+          'host'            => URI.parse(@endpoint).host,
+          'Content-Length'  => content.length
+        },
+        :body    => content,
+        :timeout => -1  # for em-http-request < 1.0
+      }
+      if EventMachine::HttpRequest::VERSION.split('.')[0].to_i >= 1
+        options = {   # for em-http-request >= 1.0
+          :inactivity_timeout => 0,    # connection inactivity (post-setup) timeout (0 = disable timeout)
+        }
+        request = EventMachine::HttpRequest.new(@endpoint, options).post(params)
+      else
+        request = EventMachine::HttpRequest.new(@endpoint).post(params)
+      end
+      request.callback do
+        begin
+          receive(JSON.parse(request.response))
+        rescue
+          retry_block.call
+        end
+      end
+      request.errback { retry_block.call }
+    end
+  end
+  
+  Transport.register 'long-polling', Transport::Http
+  
+end