faye 0.3.4 → 0.5.0

data/lib/faye/{rack_adapter.rb → adapters/rack_adapter.rb}

@@ -1,6 +1,7 @@
 require 'rubygems'
 require 'rack'
 require 'thin'
+require Faye::ROOT + '/thin_extensions'
 
 module Faye
   class RackAdapter
@@ -9,7 +10,7 @@ module Faye
     ASYNC_RESPONSE = [-1, {}, []].freeze
     
     DEFAULT_ENDPOINT  = '/bayeux'
-    SCRIPT_PATH       = File.join(ROOT, 'faye-client-min.js')
+    SCRIPT_PATH       = File.join(ROOT, 'faye-browser-min.js')
     
     TYPE_JSON   = {'Content-Type' => 'application/json'}
     TYPE_SCRIPT = {'Content-Type' => 'text/javascript'}
@@ -20,21 +21,29 @@ module Faye
       @options  = [app, options].grep(Hash).first || {}
       
       @endpoint    = @options[:mount] || DEFAULT_ENDPOINT
-      @endpoint_re = Regexp.new('^' + @endpoint + '(/[^/]+)*(\\.js)?$')
+      @endpoint_re = Regexp.new('^' + @endpoint + '(/[^/]*)*(\\.js)?$')
       @server      = Server.new(@options)
     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 run(port)
+    def listen(port)
       handler = Rack::Handler.get('thin')
       handler.run(self, :Port => port)
     end
     
     def call(env)
-      ensure_reactor_running!
+      Faye.ensure_reactor_running!
       request = Rack::Request.new(env)
       
       unless request.path_info =~ @endpoint_re
@@ -43,6 +52,10 @@ module Faye
                       [404, TYPE_TEXT, ["Sure you're not looking for #{@endpoint} ?"]]
       end
       
+      if env['HTTP_UPGRADE'] == 'WebSocket'
+        return handle_upgrade(request)
+      end
+      
       if request.path_info =~ /\.js$/
         return [200, TYPE_SCRIPT, File.new(SCRIPT_PATH)]
       end
@@ -51,14 +64,22 @@ module Faye
         json_msg = request.post? ? request.body.read : request.params['message']
         message  = JSON.parse(json_msg)
         jsonp    = request.params['jsonp'] || JSONP_CALLBACK
+        type     = request.get? ? TYPE_SCRIPT : TYPE_JSON
+        callback = env['async.callback']
+        body     = DeferredBody.new
         
         @server.flush_connection(message) if request.get?
         
-        on_response(env, message) do |replies|
+        callback.call [200, type, body]
+        
+        @server.process(message, false) do |replies|
           response = JSON.unparse(replies)
           response = "#{ jsonp }(#{ response });" if request.get?
-          response
+          body.succeed(response)
         end
+        
+        ASYNC_RESPONSE
+        
       rescue
         [400, TYPE_TEXT, 'Bad request']
       end
@@ -66,27 +87,19 @@ module Faye
     
   private
     
-    def on_response(env, message, &block)
-      request  = Rack::Request.new(env)
-      type     = request.get? ? TYPE_SCRIPT : TYPE_JSON
-      callback = env['async.callback']
+    def handle_upgrade(request)
+      socket = Faye::WebSocket.new(request)
       
-      if callback
-        body = DeferredBody.new
-        callback.call [200, type, body]
-        @server.process(message, false) { |r| body.succeed block.call(r) }
-        return ASYNC_RESPONSE
+      socket.onmessage = lambda do |message|
+        begin
+          message = JSON.parse(message.data)
+          @server.process(message, socket) do |replies|
+            socket.send(JSON.unparse(replies))
+          end
+        rescue
+        end
       end
-      
-      response = nil
-      @server.process(message, false) { |r| response = block.call(r) }
-      sleep(0.1) while response.nil?
-      [200, type, [response]]
-    end
-    
-    def ensure_reactor_running!
-      Thread.new { EM.run } unless EM.reactor_running?
-      while not EM.reactor_running?; end
+      ASYNC_RESPONSE
     end
     
     class DeferredBody

data/lib/faye/error.rb

@@ -1,13 +1,6 @@
 module Faye
   class Error
     
-    def self.parse(string)
-      return nil unless Grammar::ERROR =~ string
-      parts = string.split(':')
-      args  = parts[1].split(',')
-      new(parts[0].to_i, args, parts[2])
-    end
-    
     def self.method_missing(type, *args)
       code = const_get(type.to_s.upcase)
       new(code[0], args, code[1]).to_s

data/lib/faye/mixins/publisher.rb

@@ -0,0 +1,29 @@
+module Faye
+  module Publisher
+    
+    def count_subscribers(event_type)
+      return 0 unless @subscribers and @subscribers[event_type]
+      @subscribers[event_type].size
+    end
+    
+    def add_subscriber(event_type, listener)
+      @subscribers ||= {}
+      list = @subscribers[event_type] ||= []
+      list << listener
+    end
+    
+    def remove_subscriber(event_type, listener)
+      return unless @subscribers and @subscribers[event_type]
+      @subscribers[event_type].delete_if(&listener.method(:==))
+    end
+    
+    def publish_event(event_type, *args)
+      return unless @subscribers and @subscribers[event_type]
+      @subscribers[event_type].each do |listener|
+        listener.call(*args)
+      end
+    end
+    
+  end
+end
+

data/lib/faye/{timeouts.rb → mixins/timeouts.rb}

@@ -1,6 +1,7 @@
 module Faye
   module Timeouts
     def add_timeout(name, delay, &block)
+      Faye.ensure_reactor_running!
       @timeouts ||= {}
       return if @timeouts.has_key?(name)
       @timeouts[name] = EventMachine.add_timer(delay) do

data/lib/faye/{transport.rb → network/transport.rb}

@@ -8,49 +8,33 @@ module Faye
     include Logging
     
     def initialize(client, endpoint)
-      debug('Created new transport for ?', endpoint)
-      @client   = client
-      @endpoint = endpoint
+      debug('Created new ? transport for ?', connection_type, endpoint)
+      @client    = client
+      @endpoint  = endpoint
     end
     
     def connection_type
       self.class.connection_type
     end
     
-    def send(message, &block)
-      if message.is_a?(Hash) and not message.has_key?('id')
-        message['id'] = @client.namespace.generate
+    def send(messages, timeout)
+      messages = [messages].flatten
+      debug('Client ? sending message to ?: ?', @client.client_id, @endpoint, messages)
+      request(messages, timeout)
+    end
+    
+    def receive(responses)
+      debug('Client ? received from ?: ?', @client.client_id, @endpoint, responses)
+      responses.each { |response| @client.receive_message(response) }
+    end
+    
+    def retry_block(message, timeout)
+      lambda do
+        EventMachine.add_timer(timeout) { request(message, 2 * timeout) }
       end
-      
-      debug('Client ? sending message to ?: ?', @client.client_id, @endpoint, message)
-      
-      request(message) { |responses|
-        debug('Client ? received from ?: ?', @client.client_id, @endpoint, responses)
-        
-        if block_given?
-          messages, deliverable = [], true
-          [responses].flatten.each do |response|
-            
-            if message.is_a?(Hash) and response['id'] == message['id']
-              deliverable = false if block.call(response) == false
-            end
-            
-            if response['advice']
-              @client.handle_advice(response['advice'])
-            end
-            
-            if response['data'] and response['channel']
-              messages << response
-            end
-            
-          end
-          
-          @client.deliver_messages(messages) if deliverable
-        end
-      }
     end
     
-    @transports = {}
+    @transports = []
     
     class << self
       attr_accessor :connection_type
@@ -59,7 +43,7 @@ module Faye
         endpoint = client.endpoint
         connection_types ||= supported_connection_types
         
-        candidate_class = @transports.find do |type, klass|
+        candidate_class = @transports.find do |(type, klass)|
           connection_types.include?(type) and
           klass.usable?(endpoint)
         end
@@ -72,12 +56,12 @@ module Faye
       end
       
       def register(type, klass)
-        @transports[type] = klass
+        @transports << [type, klass]
         klass.connection_type = type
       end
       
       def supported_connection_types
-        @transports.keys
+        @transports.map { |t| t.first }
       end
     end
   end
@@ -87,7 +71,9 @@ module Faye
       endpoint.is_a?(String)
     end
     
-    def request(message, &block)
+    def request(message, timeout)
+      retry_block = retry_block(message, timeout)
+      
       content = JSON.unparse(message)
       params = {
         :head => {
@@ -100,8 +86,13 @@ module Faye
       }
       request = EventMachine::HttpRequest.new(@endpoint).post(params)
       request.callback do
-        block.call(JSON.parse(request.response))
+        begin
+          receive(JSON.parse(request.response))
+        rescue
+          retry_block.call
+        end
       end
+      request.errback { retry_block.call }
     end
   end
   Transport.register 'long-polling', HttpTransport
@@ -111,10 +102,8 @@ module Faye
       endpoint.is_a?(Server)
     end
     
-    def request(message, &block)
-      @endpoint.process(message, true) do |response|
-        block.call(response)
-      end
+    def request(message, timeout)
+      @endpoint.process(message, true, &method(:receive))
     end
   end
   Transport.register 'in-process', LocalTransport

data/lib/faye/{channel.rb → protocol/channel.rb}

@@ -1,7 +1,7 @@
 module Faye
   class Channel
     
-    include Observable
+    include Publisher
     attr_reader :name
     
     def initialize(name)
@@ -9,8 +9,7 @@ module Faye
     end
     
     def <<(message)
-      changed(true)
-      notify_observers(:message, message)
+      publish_event(:message, message)
     end
     
     HANDSHAKE   = '/meta/handshake'
@@ -120,6 +119,27 @@ module Faye
         list << @children[:**].value if @children[:**]
         list.flatten
       end
+      
+      def subscribe(names, callback)
+        return unless callback
+        names.each do |name|
+          channel = self[name] ||= Channel.new(name)
+          channel.add_subscriber(:message, callback)
+        end
+      end
+      
+      def unsubscribe(name, callback)
+        channel = self[name]
+        return false unless channel
+        channel.remove_subscriber(:message, callback)
+        channel.count_subscribers(:message).zero?
+      end
+      
+      def distribute_message(message)
+        glob(message['channel']).each do |channel|
+          channel.publish_event(:message, message['data'])
+        end
+      end
     end
     
   end

data/lib/faye/{client.rb → protocol/client.rb}

@@ -4,6 +4,7 @@ module Faye
     include EventMachine::Deferrable
     include Timeouts
     include Logging
+    include Extensible
     
     UNCONNECTED         = 1
     CONNECTING          = 2
@@ -16,22 +17,27 @@ module Faye
     
     CONNECTION_TIMEOUT  = 60.0
     
-    attr_reader :endpoint, :client_id, :namespace
+    attr_reader :endpoint, :client_id
     
     def initialize(endpoint = nil, options = {})
       info('New client created for ?', endpoint)
       
       @endpoint  = endpoint || RackAdapter::DEFAULT_ENDPOINT
       @options   = options
-      @timeout   = @options[:timeout] || CONNECTION_TIMEOUT
       
-      @transport = Transport.get(self)
+      @transport = Transport.get(self, MANDATORY_CONNECTION_TYPES)
       @state     = UNCONNECTED
-      @namespace = Namespace.new
       @outbox    = []
       @channels  = Channel::Tree.new
       
-      @advice = {'reconnect' => RETRY, 'interval' => Connection::INTERVAL}
+      @namespace = Namespace.new
+      @response_callbacks = {}
+      
+      @advice = {
+        'reconnect' => RETRY,
+        'interval'  => 1000.0 * (@options[:interval] || Connection::INTERVAL),
+        'timeout'   => 1000.0 * (@options[:timeout] || CONNECTION_TIMEOUT)
+      }
     end
     
     # Request
@@ -61,10 +67,10 @@ module Faye
       
       info('Initiating handshake with ?', @endpoint)
       
-      @transport.send({
+      send({
         'channel'     => Channel::HANDSHAKE,
         'version'     => BAYEUX_VERSION,
-        'supportedConnectionTypes' => Transport.supported_connection_types
+        'supportedConnectionTypes' => [@transport.connection_type]
         
       }) do |response|
         
@@ -74,6 +80,8 @@ module Faye
           @transport = Transport.get(self, response['supportedConnectionTypes'])
           
           info('Handshake successful: ?', @client_id)
+          
+          subscribe(@channels.keys)
           block.call if block_given?
           
         else
@@ -97,38 +105,28 @@ module Faye
       return if @advice['reconnect'] == NONE or
                 @state == DISCONNECTED
       
-      if @advice['reconnect'] == HANDSHAKE or @state == UNCONNECTED
-        begin_reconnect_timeout
-        return handshake { connect(&block) }
-      end
+      return handshake { connect(&block) } if @state == UNCONNECTED
       
-      return callback(&block) if @state == CONNECTING
+      callback(&block)
       return unless @state == CONNECTED
       
       info('Calling deferred actions for ?', @client_id)
       set_deferred_status(:succeeded)
       set_deferred_status(:deferred)
-      block.call if block_given?
       
-      return unless @connection_id.nil?
-      @connection_id = @namespace.generate
+      return unless @connect_request.nil?
+      @connect_request = true
+      
       info('Initiating connection for ?', @client_id)
       
-      @transport.send({
+      send({
         'channel'         => Channel::CONNECT,
         'clientId'        => @client_id,
-        'connectionType'  => @transport.connection_type,
-        'id'              => @connection_id
+        'connectionType'  => @transport.connection_type
         
-      }, &verify_client_id { |response|
-        @connection_id = nil
-        remove_timeout(:reconnect)
-        
-        info('Closed connection for ?', @client_id)
-        EventMachine.add_timer(@advice['interval'] / 1000.0) { connect }
-      })
-      
-      begin_reconnect_timeout
+      }) do
+        cycle_connection
+      end
     end
     
     # Request                              Response
@@ -144,14 +142,13 @@ module Faye
       
       info('Disconnecting ?', @client_id)
       
-      @transport.send({
+      send({
         'channel'   => Channel::DISCONNECT,
         'clientId'  => @client_id
       })
       
       info('Clearing channel listeners for ?', @client_id)
       @channels = Channel::Tree.new
-      remove_timeout(:reconnect)
     end
     
     # Request                              Response
@@ -165,27 +162,32 @@ module Faye
     #                                                     * id
     #                                                     * timestamp
     def subscribe(channels, &block)
+      if Array === channels
+        return channels.each do |channel|
+          subscribe(channel, &block)
+        end
+      end
+      
+      validate_channel(channels)
+      
       connect {
-        channels = [channels].flatten
-        validate_channels(channels)
-        
         info('Client ? attempting to subscribe to ?', @client_id, channels)
         
-        @transport.send({
+        send({
           'channel'       => Channel::SUBSCRIBE,
           'clientId'      => @client_id,
           'subscription'  => channels
           
-        }, &verify_client_id { |response|
-          if response['successful'] and block
-            
-            info('Subscription acknowledged for ? to ?', @client_id, channels)
+        }) do |response|
+          if response['successful']
             
             channels = [response['subscription']].flatten
-            channels.each { |channel| @channels[channel] = block }
+            info('Subscription acknowledged for ? to ?', @client_id, channels)
+            @channels.subscribe(channels, block)
           end
-        })
+        end
       }
+      Subscription.new(self, channels, block)
     end
     
     # Request                              Response
@@ -199,26 +201,32 @@ module Faye
     #                                                     * id
     #                                                     * timestamp
     def unsubscribe(channels, &block)
+      if Array === channels
+        return channels.each do |channel|
+          unsubscribe(channel, &block)
+        end
+      end
+      
+      validate_channel(channels)
+      
+      dead = @channels.unsubscribe(channels, block)
+      return unless dead
+      
       connect {
-        channels = [channels].flatten
-        validate_channels(channels)
-        
         info('Client ? attempting to unsubscribe from ?', @client_id, channels)
         
-        @transport.send({
+        send({
           'channel'       => Channel::UNSUBSCRIBE,
           'clientId'      => @client_id,
           'subscription'  => channels
           
-        }, &verify_client_id { |response|
+        }) do |response|
           if response['successful']
             
-            info('Unsubscription acknowledged for ? from ?', @client_id, channels)
-            
             channels = [response['subscription']].flatten
-            channels.each { |channel| @channels[channel] = nil }
+            info('Unsubscription acknowledged for ? from ?', @client_id, channels)
           end
-        })
+        end
       }
     end
     
@@ -229,77 +237,103 @@ module Faye
     #                * id                                 * error
     #                * ext                                * ext
     def publish(channel, data)
+      validate_channel(channel)
+      
       connect {
-        validate_channels([channel])
-        
         info('Client ? queueing published message to ?: ?', @client_id, channel, data)
         
-        enqueue({
+        send({
           'channel'   => channel,
           'data'      => data,
           'clientId'  => @client_id
         })
-        
-        add_timeout(:publish, Connection::MAX_DELAY) { flush! }
       }
     end
     
-    def handle_advice(advice)
-      @advice.update(advice)
-      @client_id = nil if @advice['reconnect'] == HANDSHAKE
-    end
-    
-    def deliver_messages(messages)
-      messages.each do |message|
-        info('Client ? calling listeners for ? with ?', @client_id, message['channel'], message['data'])
-        
-        channels = @channels.glob(message['channel'])
-        channels.each { |callback| callback.call(message['data']) }
+    def receive_message(message)
+      pipe_through_extensions(:incoming, message) do |message|
+        if message
+          handle_advice(message['advice']) if message['advice']
+          
+          callback = @response_callbacks[message['id']]
+          if callback
+            @response_callbacks.delete(message['id'])
+            callback.call(message)
+          end
+          
+          deliver_message(message)
+        end
       end
     end
     
   private
     
-    def begin_reconnect_timeout
-      add_timeout(:reconnect, @timeout) do
-        @connection_id = nil
+    def handle_advice(advice)
+      @advice.update(advice)
+      
+      if @advice['reconnect'] == HANDSHAKE and @state != DISCONNECTED
+        @state     = UNCONNECTED
         @client_id = nil
-        @state = UNCONNECTED
-        
-        info('Server took >?s to reply to connection for ?: attempting to reconnect',
-             @timeout, @client_id)
-        
-        subscribe(@channels.keys)
+        cycle_connection
       end
     end
     
-    def enqueue(message)
-      @outbox << message
+    def deliver_message(message)
+      return unless message['channel'] and message['data']
+      info('Client ? calling listeners for ? with ?', @client_id, message['channel'], message['data'])
+      @channels.distribute_message(message)
     end
     
-    def flush!
-      @transport.send(@outbox)
-      @outbox = []
+    def teardown_connection
+      return unless @connect_request
+      @connect_request = nil
+      info('Closed connection for ?', @client_id)
     end
     
-    def validate_channels(channels)
-      channels.each do |channel|
-        raise "'#{ channel }' is not a valid channel name" unless Channel.valid?(channel)
-        raise "Clients may not subscribe to channel '#{ channel }'" unless Channel.subscribable?(channel)
-      end
+    def cycle_connection
+      teardown_connection
+      EventMachine.add_timer(@advice['interval'] / 1000.0) { connect }
     end
     
-    def verify_client_id(&block)
-      lambda do |response|
-        if response['clientId'] != @client_id
-          false
-        else
-          block.call(response)
-          true
+    def send(message, &callback)
+      message['id'] = @namespace.generate
+      @response_callbacks[message['id']] = callback if callback
+      
+      pipe_through_extensions(:outgoing, message) do |message|
+        if message
+          if message['channel'] == Channel::HANDSHAKE
+            @transport.send(message, @advice['timeout'] / 1000.0)
+          else
+            @outbox << message
+            
+            if message['channel'] == Channel::CONNECT
+              @connect_message = message
+            end
+            
+            add_timeout(:publish, Connection::MAX_DELAY) { flush! }
+          end
         end
       end
     end
     
+    def flush!
+      remove_timeout(:publish)
+      
+      if @outbox.size > 1 and @connect_message
+        @connect_message['advice'] = {'timeout' => 0}
+      end
+      
+      @connect_message = nil
+      
+      @transport.send(@outbox, @advice['timeout'] / 1000.0)
+      @outbox = []
+    end
+    
+    def validate_channel(channel)
+      raise "'#{ channel }' is not a valid channel name" unless Channel.valid?(channel)
+      raise "Clients may not subscribe to channel '#{ channel }'" unless Channel.subscribable?(channel)
+    end
+    
   end
 end