faye-ouvrages 1.1.2

data/lib/faye/protocol/client.rb

@@ -0,0 +1,344 @@
+module Faye
+  class Client
+
+    include Deferrable
+    include Publisher
+    include Logging
+    include Extensible
+
+    UNCONNECTED        = 1
+    CONNECTING         = 2
+    CONNECTED          = 3
+    DISCONNECTED       = 4
+
+    HANDSHAKE          = 'handshake'
+    RETRY              = 'retry'
+    NONE               = 'none'
+
+    CONNECTION_TIMEOUT = 60.0
+
+    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])
+      super()
+      info('New client created for ?', endpoint)
+
+      @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)
+      }
+      @dispatcher.timeout = @advice['timeout'] / 1000.0
+
+      @dispatcher.bind(:message, &method(:receive_message))
+    end
+
+    # Request
+    # MUST include:  * channel
+    #                * version
+    #                * supportedConnectionTypes
+    # MAY include:   * minimumVersion
+    #                * ext
+    #                * id
+    #
+    # Success Response                             Failed Response
+    # MUST include:  * channel                     MUST include:  * channel
+    #                * version                                    * successful
+    #                * supportedConnectionTypes                   * error
+    #                * clientId                    MAY include:   * supportedConnectionTypes
+    #                * successful                                 * advice
+    # MAY include:   * minimumVersion                             * version
+    #                * advice                                     * minimumVersion
+    #                * ext                                        * ext
+    #                * id                                         * id
+    #                * authSuccessful
+    def handshake(&block)
+      return if @advice['reconnect'] == NONE
+      return if @state != UNCONNECTED
+
+      @state = CONNECTING
+
+      info('Initiating handshake with ?', @dispatcher.endpoint.to_s)
+      @dispatcher.select_transport(MANDATORY_CONNECTION_TYPES)
+
+      send_message({
+        'channel'                  => Channel::HANDSHAKE,
+        'version'                  => BAYEUX_VERSION,
+        'supportedConnectionTypes' => @dispatcher.connection_types
+
+      }, {}) do |response|
+
+        if response['successful']
+          @state = CONNECTED
+          @dispatcher.client_id = response['clientId']
+
+          @dispatcher.select_transport(response['supportedConnectionTypes'])
+
+          info('Handshake successful: ?', @dispatcher.client_id)
+
+          subscribe(@channels.keys, true)
+          block.call if block_given?
+
+        else
+          info('Handshake unsuccessful')
+          EventMachine.add_timer(@dispatcher.retry) { handshake(&block) }
+          @state = UNCONNECTED
+        end
+      end
+    end
+
+    # Request                              Response
+    # MUST include:  * channel             MUST include:  * channel
+    #                * clientId                           * successful
+    #                * connectionType                     * clientId
+    # MAY include:   * ext                 MAY include:   * error
+    #                * id                                 * advice
+    #                                                     * ext
+    #                                                     * id
+    #                                                     * timestamp
+    def connect(&block)
+      return if @advice['reconnect'] == NONE or
+                @state == DISCONNECTED
+
+      return handshake { connect(&block) } if @state == UNCONNECTED
+
+      callback(&block)
+      return unless @state == CONNECTED
+
+      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 ?', @dispatcher.client_id)
+
+      send_message({
+        'channel'        => Channel::CONNECT,
+        'clientId'       => @dispatcher.client_id,
+        'connectionType' => @dispatcher.connection_type
+
+      }, {}) do
+        cycle_connection
+      end
+    end
+
+    # Request                              Response
+    # MUST include:  * channel             MUST include:  * channel
+    #                * clientId                           * successful
+    # MAY include:   * ext                                * clientId
+    #                * id                  MAY include:   * error
+    #                                                     * ext
+    #                                                     * id
+    def disconnect
+      return unless @state == CONNECTED
+      @state = DISCONNECTED
+
+      info('Disconnecting ?', @dispatcher.client_id)
+      promise = Publication.new
+
+      send_message({
+        'channel'  => Channel::DISCONNECT,
+        'clientId' => @dispatcher.client_id
+
+      }, {}) 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 ?', @dispatcher.client_id)
+      @channels = Channel::Set.new
+
+      promise
+    end
+
+    # Request                              Response
+    # MUST include:  * channel             MUST include:  * channel
+    #                * clientId                           * successful
+    #                * subscription                       * clientId
+    # MAY include:   * ext                                * subscription
+    #                * id                  MAY include:   * error
+    #                                                     * advice
+    #                                                     * ext
+    #                                                     * id
+    #                                                     * timestamp
+    def subscribe(channel, force = false, &block)
+      if Array === channel
+        return channel.map { |c| subscribe(c, force, &block) }
+      end
+
+      subscription  = Subscription.new(self, channel, block)
+      has_subscribe = @channels.has_subscription?(channel)
+
+      if has_subscribe and not force
+        @channels.subscribe([channel], block)
+        subscription.set_deferred_status(:succeeded)
+        return subscription
+      end
+
+      connect {
+        info('Client ? attempting to subscribe to ?', @dispatcher.client_id, channel)
+        @channels.subscribe([channel], block) unless force
+
+        send_message({
+          'channel'      => Channel::SUBSCRIBE,
+          'clientId'     => @dispatcher.client_id,
+          'subscription' => channel
+
+        }, {}) do |response|
+          unless response['successful']
+            subscription.set_deferred_status(:failed, Error.parse(response['error']))
+            next @channels.unsubscribe(channel, block)
+          end
+
+          channels = [response['subscription']].flatten
+          info('Subscription acknowledged for ? to ?', @dispatcher.client_id, channels)
+          subscription.set_deferred_status(:succeeded)
+        end
+      }
+      subscription
+    end
+
+    # Request                              Response
+    # MUST include:  * channel             MUST include:  * channel
+    #                * clientId                           * successful
+    #                * subscription                       * clientId
+    # MAY include:   * ext                                * subscription
+    #                * id                  MAY include:   * error
+    #                                                     * advice
+    #                                                     * ext
+    #                                                     * id
+    #                                                     * timestamp
+    def unsubscribe(channel, &block)
+      if Array === channel
+        return channel.map { |c| unsubscribe(c, &block) }
+      end
+
+      dead = @channels.unsubscribe(channel, block)
+      return unless dead
+
+      connect {
+        info('Client ? attempting to unsubscribe from ?', @dispatcher.client_id, channel)
+
+        send_message({
+          'channel'      => Channel::UNSUBSCRIBE,
+          'clientId'     => @dispatcher.client_id,
+          'subscription' => channel
+
+        }, {}) do |response|
+          next unless response['successful']
+
+          channels = [response['subscription']].flatten
+          info('Unsubscription acknowledged for ? from ?', @dispatcher.client_id, channels)
+        end
+      }
+    end
+
+    # Request                              Response
+    # MUST include:  * channel             MUST include:  * channel
+    #                * data                               * successful
+    # MAY include:   * clientId            MAY include:   * id
+    #                * id                                 * error
+    #                * ext                                * ext
+    def publish(channel, data, options = {})
+      ::WebSocket::Driver.validate_options(options, [:attempts, :deadline])
+
+      publication = Publication.new
+      connect {
+        info('Client ? queueing published message to ?: ?', @dispatcher.client_id, channel, data)
+
+        send_message({
+          'channel'  => channel,
+          'data'     => data,
+          'clientId' => @dispatcher.client_id
+
+        }, options) do |response|
+          if response['successful']
+            publication.set_deferred_status(:succeeded)
+          else
+            publication.set_deferred_status(:failed, Error.parse(response['error']))
+          end
+        end
+      }
+      publication
+    end
+
+  private
+
+    def send_message(message, options, &callback)
+      message['id'] = generate_message_id
+
+      timeout = [nil, 0].include?(@advice['timeout']) ?
+                1.2 * @dispatcher.retry :
+                1.2 * @advice['timeout'] / 1000.0
+
+      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
+    end
+
+    def generate_message_id
+      @message_id += 1
+      @message_id = 0 if @message_id >= 2**32
+      @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
+        @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 ?', @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 ?', @dispatcher.client_id)
+      end
+      EventMachine.add_timer(@advice['interval'] / 1000.0) { connect }
+    end
+
+  end
+end

data/lib/faye/protocol/dispatcher.rb

@@ -0,0 +1,169 @@
+module Faye
+  class Dispatcher
+
+    class Envelope < Struct.new(:message, :scheduler, :request, :timer)
+    end
+
+    MAX_REQUEST_SIZE = 2048
+    DEFAULT_RETRY    = 5.0
+
+    UP   = 1
+    DOWN = 2
+
+    include Publisher
+    include Logging
+    extend Forwardable
+    def_delegators :@transport, :connection_type
+
+    attr_accessor :client_id, :timeout
+    attr_reader   :cookies, :endpoint, :headers, :max_request_size, :proxy, :retry, :transports, :ws_extensions
+
+    def initialize(client, endpoint, options)
+      super()
+
+      @client     = client
+      @endpoint   = Faye.parse_url(endpoint)
+      @alternates = options[:endpoints] || {}
+
+      @cookies       = CookieJar::Jar.new
+      @disabled      = []
+      @envelopes     = {}
+      @headers       = {}
+      @retry         = options[:retry] || DEFAULT_RETRY
+      @scheduler     = options[:scheduler] || Faye::Scheduler
+      @state         = 0
+      @transports    = {}
+      @ws_extensions = []
+
+      @proxy = options[:proxy] || {}
+      @proxy = {:origin => @proxy} if String === @proxy
+
+      [*options[:websocket_extensions]].each do |extension|
+        add_websocket_extension(extension)
+      end
+
+      @alternates.each do |type, url|
+        @alternates[type] = Faye.parse_url(url)
+      end
+
+      @max_request_size = MAX_REQUEST_SIZE
+    end
+
+    def endpoint_for(connection_type)
+      @alternates[connection_type] || @endpoint
+    end
+
+    def add_websocket_extension(extension)
+      @ws_extensions << extension
+    end
+
+    def disable(feature)
+      @disabled << feature
+    end
+
+    def set_header(name, value)
+      @headers[name.to_s] = value.to_s
+    end
+
+    def close
+      transport = @transport
+      @transport = nil
+      transport.close if transport
+    end
+
+    def connection_types
+      Transport.connection_types
+    end
+
+    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(message, timeout, options = {})
+      id       = message['id']
+      attempts = options[:attempts]
+      deadline = options[:deadline] && Time.now.to_f + options[:deadline]
+      envelope = @envelopes[id]
+
+      unless envelope
+        scheduler = @scheduler.new(message, :timeout => timeout, :interval => @retry, :attempts => attempts, :deadline => deadline)
+        envelope  = @envelopes[id] = Envelope.new(message, scheduler, nil, nil)
+      end
+
+      send_envelope(envelope)
+    end
+
+    def send_envelope(envelope)
+      return unless @transport
+      return if envelope.request or envelope.timer
+
+      message   = envelope.message
+      scheduler = envelope.scheduler
+
+      unless scheduler.deliverable?
+        scheduler.abort!
+        @envelopes.delete(message['id'])
+        return
+      end
+
+      envelope.timer = EventMachine.add_timer(scheduler.timeout) do
+        handle_error(message)
+      end
+
+      scheduler.send!
+      envelope.request = @transport.send_message(message)
+    end
+    private :send_envelope
+
+    def handle_response(reply)
+      envelope = @envelopes.delete(reply['id'])
+
+      if reply.has_key?('successful') and envelope
+        envelope.scheduler.succeed!
+        EventMachine.cancel_timer(envelope.timer) if envelope.timer
+      end
+
+      trigger(:message, reply)
+
+      return if @state == UP
+      @state = UP
+      @client.trigger('transport:up')
+    end
+
+    def handle_error(message, immediate = false)
+      return unless envelope = @envelopes[message['id']]
+      return unless request = envelope.request
+
+      request.callback do |req|
+        req.close if req.respond_to?(:close)
+      end
+
+      scheduler = envelope.scheduler
+      scheduler.fail!
+
+      EventMachine.cancel_timer(envelope.timer)
+      envelope.request = envelope.timer = nil
+
+      if immediate
+        send_envelope(envelope)
+      else
+        envelope.timer = EventMachine.add_timer(scheduler.interval) do
+          envelope.timer = nil
+          send_envelope(envelope)
+        end
+      end
+
+      return if @state == DOWN
+      @state = DOWN
+      @client.trigger('transport:down')
+    end
+
+  end
+end