faye 1.0.3 → 1.4.0

data/lib/faye/error.rb

@@ -46,4 +46,3 @@ module Faye
 
   end
 end
-

data/lib/faye/mixins/deferrable.rb

@@ -12,4 +12,3 @@ module Faye
 
   end
 end
-

data/lib/faye/mixins/logging.rb

@@ -33,4 +33,3 @@ module Faye
 
   end
 end
-

data/lib/faye/mixins/publisher.rb

@@ -16,4 +16,3 @@ module Faye
 
   end
 end
-

data/lib/faye/mixins/timeouts.rb

@@ -24,4 +24,3 @@ module Faye
     end
   end
 end
-

data/lib/faye/protocol/channel.rb

@@ -75,7 +75,7 @@ module Faye
     end
 
     class Set
-      def initialize(parent = nil, value = nil)
+      def initialize
         @channels = {}
       end
 
@@ -91,18 +91,17 @@ module Faye
         @channels.has_key?(name)
       end
 
-      def subscribe(names, callback)
-        return unless callback
+      def subscribe(names, subscription)
         names.each do |name|
           channel = @channels[name] ||= Channel.new(name)
-          channel.bind(:message, &callback)
+          channel.bind(:message, &subscription)
         end
       end
 
-      def unsubscribe(name, callback)
+      def unsubscribe(name, subscription)
         channel = @channels[name]
         return false unless channel
-        channel.unbind(:message, &callback)
+        channel.unbind(:message, &subscription)
         if channel.unused?
           remove(name)
           true
@@ -115,11 +114,10 @@ module Faye
         channels = Channel.expand(message['channel'])
         channels.each do |name|
           channel = @channels[name]
-          channel.trigger(:message, message['data']) if channel
+          channel.trigger(:message, message) if channel
         end
       end
     end
 
   end
 end
-

data/lib/faye/protocol/client.rb

@@ -6,59 +6,41 @@ module Faye
     include Logging
     include Extensible
 
-    UNCONNECTED         = 1
-    CONNECTING          = 2
-    CONNECTED           = 3
-    DISCONNECTED        = 4
+    UNCONNECTED  = 1
+    CONNECTING   = 2
+    CONNECTED    = 3
+    DISCONNECTED = 4
 
-    HANDSHAKE           = 'handshake'
-    RETRY               = 'retry'
-    NONE                = 'none'
+    HANDSHAKE = 'handshake'
+    RETRY     = 'retry'
+    NONE      = 'none'
 
-    CONNECTION_TIMEOUT  = 60.0
-    DEFAULT_RETRY       = 5.0
-    MAX_REQUEST_SIZE    = 2048
+    CONNECTION_TIMEOUT = 60.0
 
-    attr_reader :cookies, :endpoint, :endpoints, :headers, :max_request_size, :retry, :transports
+    extend Forwardable
+    def_delegators :@dispatcher, :add_websocket_extension, :disable, :set_header
 
     def initialize(endpoint = nil, options = {})
+      ::WebSocket::Driver.validate_options(options, [:interval, :timeout, :endpoints, :proxy, :retry, :scheduler, :websocket_extensions, :tls])
       super()
       info('New client created for ?', endpoint)
 
-      @options    = options
-      @endpoint   = Faye.parse_url(endpoint || RackAdapter::DEFAULT_ENDPOINT)
-      @endpoints  = @options[:endpoints] || {}
-      @transports = {}
-      @cookies    = CookieJar::Jar.new
-      @headers    = {}
-      @disabled   = []
-      @retry      = @options[:retry] || DEFAULT_RETRY
-
-      @endpoints.each do |key, value|
-        @endpoints[key] = Faye.parse_url(value)
-      end
-
-      @max_request_size = MAX_REQUEST_SIZE
-
-      @state      = UNCONNECTED
       @channels   = Channel::Set.new
+      @dispatcher = Dispatcher.new(self, endpoint || RackAdapter::DEFAULT_ENDPOINT, options)
+
       @message_id = 0
+      @state      = UNCONNECTED
 
       @response_callbacks = {}
 
       @advice = {
         'reconnect' => RETRY,
-        'interval'  => 1000.0 * (@options[:interval] || Engine::INTERVAL),
-        'timeout'   => 1000.0 * (@options[:timeout]  || CONNECTION_TIMEOUT)
+        'interval'  => 1000.0 * (options[:interval] || Engine::INTERVAL),
+        'timeout'   => 1000.0 * (options[:timeout]  || CONNECTION_TIMEOUT)
       }
-    end
+      @dispatcher.timeout = @advice['timeout'] / 1000.0
 
-    def disable(feature)
-      @disabled << feature
-    end
-
-    def set_header(name, value)
-      @headers[name.to_s] = value.to_s
+      @dispatcher.bind(:message, &method(:receive_message))
     end
 
     # Request
@@ -86,30 +68,30 @@ module Faye
 
       @state = CONNECTING
 
-      info('Initiating handshake with ?', @endpoint)
-      select_transport(MANDATORY_CONNECTION_TYPES)
+      info('Initiating handshake with ?', @dispatcher.endpoint.to_s)
+      @dispatcher.select_transport(MANDATORY_CONNECTION_TYPES)
 
-      send({
-        'channel'                   => Channel::HANDSHAKE,
-        'version'                   => BAYEUX_VERSION,
-        'supportedConnectionTypes'  => [@transport.connection_type]
+      send_message({
+        'channel'                  => Channel::HANDSHAKE,
+        'version'                  => BAYEUX_VERSION,
+        'supportedConnectionTypes' => @dispatcher.connection_types
 
-      }) do |response|
+      }, {}) do |response|
 
         if response['successful']
-          @state     = CONNECTED
-          @client_id = response['clientId']
+          @state = CONNECTED
+          @dispatcher.client_id = response['clientId']
 
-          select_transport(response['supportedConnectionTypes'])
+          @dispatcher.select_transport(response['supportedConnectionTypes'])
 
-          info('Handshake successful: ?', @client_id)
+          info('Handshake successful: ?', @dispatcher.client_id)
 
           subscribe(@channels.keys, true)
           block.call if block_given?
 
         else
           info('Handshake unsuccessful')
-          EventMachine.add_timer(@advice['interval'] / 1000.0) { handshake(&block) }
+          EventMachine.add_timer(@dispatcher.retry) { handshake(&block) }
           @state = UNCONNECTED
         end
       end
@@ -133,21 +115,21 @@ module Faye
       callback(&block)
       return unless @state == CONNECTED
 
-      info('Calling deferred actions for ?', @client_id)
+      info('Calling deferred actions for ?', @dispatcher.client_id)
       set_deferred_status(:succeeded)
       set_deferred_status(:unknown)
 
       return unless @connect_request.nil?
       @connect_request = true
 
-      info('Initiating connection for ?', @client_id)
+      info('Initiating connection for ?', @dispatcher.client_id)
 
-      send({
-        'channel'         => Channel::CONNECT,
-        'clientId'        => @client_id,
-        'connectionType'  => @transport.connection_type
+      send_message({
+        'channel'        => Channel::CONNECT,
+        'clientId'       => @dispatcher.client_id,
+        'connectionType' => @dispatcher.connection_type
 
-      }) do
+      }, {}) do
         cycle_connection
       end
     end
@@ -163,18 +145,26 @@ module Faye
       return unless @state == CONNECTED
       @state = DISCONNECTED
 
-      info('Disconnecting ?', @client_id)
+      info('Disconnecting ?', @dispatcher.client_id)
+      promise = Publication.new
 
-      send({
-        'channel'   => Channel::DISCONNECT,
-        'clientId'  => @client_id
+      send_message({
+        'channel'  => Channel::DISCONNECT,
+        'clientId' => @dispatcher.client_id
 
-      }) do |response|
-        @transport.close if response['successful']
+      }, {}) do |response|
+        if response['successful']
+          @dispatcher.close
+          promise.set_deferred_status(:succeeded)
+        else
+          promise.set_deferred_status(:failed, Error.parse(response['error']))
+        end
       end
 
-      info('Clearing channel listeners for ?', @client_id)
+      info('Clearing channel listeners for ?', @dispatcher.client_id)
       @channels = Channel::Set.new
+
+      promise
     end
 
     # Request                              Response
@@ -196,28 +186,28 @@ module Faye
       has_subscribe = @channels.has_subscription?(channel)
 
       if has_subscribe and not force
-        @channels.subscribe([channel], block)
+        @channels.subscribe([channel], subscription)
         subscription.set_deferred_status(:succeeded)
         return subscription
       end
 
       connect {
-        info('Client ? attempting to subscribe to ?', @client_id, channel)
-        @channels.subscribe([channel], block) unless force
+        info('Client ? attempting to subscribe to ?', @dispatcher.client_id, channel)
+        @channels.subscribe([channel], subscription) unless force
 
-        send({
-          'channel'       => Channel::SUBSCRIBE,
-          'clientId'      => @client_id,
-          'subscription'  => channel
+        send_message({
+          'channel'      => Channel::SUBSCRIBE,
+          'clientId'     => @dispatcher.client_id,
+          'subscription' => channel
 
-        }) do |response|
+        }, {}) do |response|
           unless response['successful']
             subscription.set_deferred_status(:failed, Error.parse(response['error']))
-            next @channels.unsubscribe(channel, block)
+            next @channels.unsubscribe(channel, subscription)
           end
 
           channels = [response['subscription']].flatten
-          info('Subscription acknowledged for ? to ?', @client_id, channels)
+          info('Subscription acknowledged for ? to ?', @dispatcher.client_id, channels)
           subscription.set_deferred_status(:succeeded)
         end
       }
@@ -234,27 +224,29 @@ module Faye
     #                                                     * ext
     #                                                     * id
     #                                                     * timestamp
-    def unsubscribe(channel, &block)
+    def unsubscribe(channel, subscription = nil, &block)
+      subscription ||= block
+
       if Array === channel
-        return channel.map { |c| unsubscribe(c, &block) }
+        return channel.map { |c| unsubscribe(c, subscription) }
       end
 
-      dead = @channels.unsubscribe(channel, block)
+      dead = @channels.unsubscribe(channel, subscription)
       return unless dead
 
       connect {
-        info('Client ? attempting to unsubscribe from ?', @client_id, channel)
+        info('Client ? attempting to unsubscribe from ?', @dispatcher.client_id, channel)
 
-        send({
-          'channel'       => Channel::UNSUBSCRIBE,
-          'clientId'      => @client_id,
-          'subscription'  => channel
+        send_message({
+          'channel'      => Channel::UNSUBSCRIBE,
+          'clientId'     => @dispatcher.client_id,
+          'subscription' => channel
 
-        }) do |response|
+        }, {}) do |response|
           next unless response['successful']
 
           channels = [response['subscription']].flatten
-          info('Unsubscription acknowledged for ? from ?', @client_id, channels)
+          info('Unsubscription acknowledged for ? from ?', @dispatcher.client_id, channels)
         end
       }
     end
@@ -265,17 +257,19 @@ module Faye
     # MAY include:   * clientId            MAY include:   * id
     #                * id                                 * error
     #                * ext                                * ext
-    def publish(channel, data)
+    def publish(channel, data, options = {})
+      ::WebSocket::Driver.validate_options(options, [:attempts, :deadline])
+
       publication = Publication.new
       connect {
-        info('Client ? queueing published message to ?: ?', @client_id, channel, data)
+        info('Client ? queueing published message to ?: ?', @dispatcher.client_id, channel, data)
 
-        send({
-          'channel'   => channel,
-          'data'      => data,
-          'clientId'  => @client_id
+        send_message({
+          'channel'  => channel,
+          'data'     => data,
+          'clientId' => @dispatcher.client_id
 
-        }) do |response|
+        }, options) do |response|
           if response['successful']
             publication.set_deferred_status(:succeeded)
           else
@@ -286,81 +280,20 @@ module Faye
       publication
     end
 
-    def receive_message(message)
-      id = message['id']
-
-      if message.has_key?('successful')
-        callback = @response_callbacks.delete(id)
-      end
-
-      pipe_through_extensions(:incoming, message, nil) do |message|
-        next unless message
-
-        handle_advice(message['advice']) if message['advice']
-        deliver_message(message)
-
-        callback.call(message) if callback
-      end
-
-      return if @transport_up == true
-      @transport_up = true
-      trigger('transport:up')
-    end
-
-    def message_error(messages, immediate = false)
-      messages.each do |message|
-        id = message['id']
-
-        if immediate
-          transport_send(message)
-        else
-          EventMachine.add_timer(@retry) { transport_send(message) }
-        end
-      end
-
-      return if immediate or @transport_up == false
-      @transport_up = false
-      trigger('transport:down')
-    end
-
   private
 
-    def select_transport(transport_types)
-      Transport.get(self, transport_types, @disabled) do |transport|
-        debug('Selected ? transport for ?', transport.connection_type, transport.endpoint)
-
-        next if transport == @transport
-        @transport.close if @transport
-
-        @transport = transport
-      end
-    end
-
-    def send(message, &callback)
-      return unless @transport
+    def send_message(message, options, &callback)
       message['id'] = generate_message_id
 
-      pipe_through_extensions(:outgoing, message, nil) do |message|
-        next unless message
-        @response_callbacks[message['id']] = callback if callback
-        transport_send(message)
-      end
-    end
-
-    def transport_send(message)
-      return unless @transport
-
       timeout = [nil, 0].include?(@advice['timeout']) ?
-                1.2 * @retry :
+                1.2 * @dispatcher.retry :
                 1.2 * @advice['timeout'] / 1000.0
 
-      envelope = Envelope.new(message, timeout)
-
-      envelope.errback do |immediate|
-        message_error([message], immediate)
+      pipe_through_extensions(:outgoing, message, nil) do |message|
+        next unless message
+        @response_callbacks[message['id']] = callback if callback
+        @dispatcher.send_message(message, timeout, options)
       end
-
-      @transport.send(envelope)
     end
 
     def generate_message_id
@@ -369,30 +302,45 @@ module Faye
       @message_id.to_s(36)
     end
 
+    def receive_message(message)
+      id = message['id']
+
+      if message.has_key?('successful')
+        callback = @response_callbacks.delete(id)
+      end
+
+      pipe_through_extensions(:incoming, message, nil) do |message|
+        next unless message
+        handle_advice(message['advice']) if message['advice']
+        deliver_message(message)
+        callback.call(message) if callback
+      end
+    end
+
     def handle_advice(advice)
       @advice.update(advice)
+      @dispatcher.timeout = @advice['timeout'] / 1000.0
 
       if @advice['reconnect'] == HANDSHAKE and @state != DISCONNECTED
-        @state     = UNCONNECTED
-        @client_id = nil
+        @state = UNCONNECTED
+        @dispatcher.client_id = nil
         cycle_connection
       end
     end
 
     def deliver_message(message)
       return unless message.has_key?('channel') and message.has_key?('data')
-      info('Client ? calling listeners for ? with ?', @client_id, message['channel'], message['data'])
+      info('Client ? calling listeners for ? with ?', @dispatcher.client_id, message['channel'], message['data'])
       @channels.distribute_message(message)
     end
 
     def cycle_connection
       if @connect_request
         @connect_request = nil
-        info('Closed connection for ?', @client_id)
+        info('Closed connection for ?', @dispatcher.client_id)
       end
       EventMachine.add_timer(@advice['interval'] / 1000.0) { connect }
     end
 
   end
 end
-