bushido-faye 0.8.1

data/lib/faye/error.rb

@@ -0,0 +1,49 @@
+module Faye
+  class Error
+    
+    def self.method_missing(type, *args)
+      code = const_get(type.to_s.upcase)
+      new(code[0], args, code[1]).to_s
+    end
+    
+    def self.parse(message)
+      message ||= ''
+      return new(nil, [], message) unless Grammar::ERROR =~ message
+
+      parts   = message.split(':')
+      code    = parts[0].to_i
+      params  = parts[1].split(',')
+      message = parts[2]
+
+      new(code, params, message)
+    end
+
+    attr_reader :code, :params, :message
+    
+    def initialize(code, params, message)
+      @code     = code
+      @params   = params
+      @message  = message
+    end
+    
+    def to_s
+      "#{ @code }:#{ @params * ',' }:#{ @message }"
+    end
+    
+    # http://code.google.com/p/cometd/wiki/BayeuxCodes
+    VERSION_MISMATCH    = [300, 'Version mismatch']
+    CONNTYPE_MISMATCH   = [301, 'Connection types not supported']
+    EXT_MISMATCH        = [302, 'Extension mismatch']
+    BAD_REQUEST         = [400, 'Bad request']
+    CLIENT_UNKNOWN      = [401, 'Unknown client']
+    PARAMETER_MISSING   = [402, 'Missing required parameter']
+    CHANNEL_FORBIDDEN   = [403, 'Forbidden channel']
+    CHANNEL_UNKNOWN     = [404, 'Unknown channel']
+    CHANNEL_INVALID     = [405, 'Invalid channel']
+    EXT_UNKNOWN         = [406, 'Unknown extension']
+    PUBLISH_FAILED      = [407, 'Failed to publish']
+    SERVER_ERROR        = [500, 'Internal server error']
+    
+  end
+end
+

data/lib/faye/mixins/logging.rb

@@ -0,0 +1,47 @@
+module Faye
+  module Logging
+    
+    DEFAULT_LOG_LEVEL = :error
+    
+    LOG_LEVELS = {
+      :error  => 3,
+      :warn   => 2,
+      :info   => 1,
+      :debug  => 0
+    }
+    
+    class << self
+      attr_writer :log_level
+      
+      def log_level
+        @log_level || DEFAULT_LOG_LEVEL
+      end
+    end
+    
+    attr_writer :log_level
+    
+    def log_level
+      @log_level || Logging.log_level
+    end
+    
+    def log(message_args, level)
+      return unless Faye.logger
+      return if LOG_LEVELS[log_level] > LOG_LEVELS[level]
+      
+      message = message_args.shift.gsub(/\?/) do
+        Faye.to_json(message_args.shift)
+      end
+      
+      timestamp = Time.now.strftime('%Y-%m-%d %H:%M:%S')
+      banner = " [#{ level.to_s.upcase }] [#{ self.class.name }] "
+      
+      Faye.logger.call(timestamp + banner + message)
+    end
+    
+    LOG_LEVELS.each do |level, value|
+      define_method(level) { |*args| log(args, level) }
+    end
+    
+  end
+end
+

data/lib/faye/mixins/publisher.rb

@@ -0,0 +1,30 @@
+module Faye
+  module Publisher
+    
+    def count_listeners(event_type)
+      return 0 unless @subscribers and @subscribers[event_type]
+      @subscribers[event_type].size
+    end
+    
+    def bind(event_type, &listener)
+      @subscribers ||= {}
+      list = @subscribers[event_type] ||= []
+      list << listener
+    end
+    
+    def unbind(event_type, &listener)
+      return unless @subscribers and @subscribers[event_type]
+      return @subscribers.delete(event_type) unless listener
+      
+      @subscribers[event_type].delete_if(&listener.method(:==))
+    end
+    
+    def trigger(event_type, *args)
+      return unless @subscribers and @subscribers[event_type]
+      listeners = @subscribers[event_type].dup
+      listeners.each { |listener| listener.call(*args) }
+    end
+    
+  end
+end
+

data/lib/faye/mixins/timeouts.rb

@@ -0,0 +1,22 @@
+module Faye
+  module Timeouts
+    def add_timeout(name, delay, &block)
+      Engine.ensure_reactor_running!
+      @timeouts ||= {}
+      return if @timeouts.has_key?(name)
+      @timeouts[name] = EventMachine.add_timer(delay) do
+        @timeouts.delete(name)
+        block.call
+      end
+    end
+    
+    def remove_timeout(name)
+      @timeouts ||= {}
+      timeout = @timeouts[name]
+      return if timeout.nil?
+      EventMachine.cancel_timer(timeout)
+      @timeouts.delete(name)
+    end
+  end
+end
+

data/lib/faye/protocol/channel.rb

@@ -0,0 +1,124 @@
+module Faye
+  class Channel
+    
+    include Publisher
+    attr_reader :name
+    
+    def initialize(name)
+      @name = name
+    end
+    
+    def <<(message)
+      trigger(:message, message)
+    end
+    
+    def unused?
+      count_listeners(:message).zero?
+    end
+    
+    HANDSHAKE   = '/meta/handshake'
+    CONNECT     = '/meta/connect'
+    SUBSCRIBE   = '/meta/subscribe'
+    UNSUBSCRIBE = '/meta/unsubscribe'
+    DISCONNECT  = '/meta/disconnect'
+    
+    META        = :meta
+    SERVICE     = :service
+    
+    class << self
+      def expand(name)
+        segments = parse(name)
+        channels = ['/**', name]
+        
+        copy = segments.dup
+        copy[copy.size - 1] = '*'
+        channels << unparse(copy)
+        
+        1.upto(segments.size - 1) do |i|
+          copy = segments[0...i]
+          copy << '**'
+          channels << unparse(copy)
+        end
+        
+        channels
+      end
+      
+      def valid?(name)
+        Grammar::CHANNEL_NAME =~ name or
+        Grammar::CHANNEL_PATTERN =~ name
+      end
+      
+      def parse(name)
+        return nil unless valid?(name)
+        name.split('/')[1..-1].map { |s| s.to_sym }
+      end
+      
+      def unparse(segments)
+        '/' + segments.join('/')
+      end
+      
+      def meta?(name)
+        segments = parse(name)
+        segments ? (segments.first == META) : nil
+      end
+      
+      def service?(name)
+        segments = parse(name)
+        segments ? (segments.first == SERVICE) : nil
+      end
+      
+      def subscribable?(name)
+        return nil unless valid?(name)
+        not meta?(name) and not service?(name)
+      end
+    end
+    
+    class Set
+      def initialize(parent = nil, value = nil)
+        @channels = {}
+      end
+      
+      def keys
+        @channels.keys
+      end
+      
+      def remove(name)
+        @channels.delete(name)
+      end
+      
+      def has_subscription?(name)
+        @channels.has_key?(name)
+      end
+      
+      def subscribe(names, callback)
+        return unless callback
+        names.each do |name|
+          channel = @channels[name] ||= Channel.new(name)
+          channel.bind(:message, &callback)
+        end
+      end
+      
+      def unsubscribe(name, callback)
+        channel = @channels[name]
+        return false unless channel
+        channel.unbind(:message, &callback)
+        if channel.unused?
+          remove(name)
+          true
+        else
+          false
+        end
+      end
+      
+      def distribute_message(message)
+        channels = Channel.expand(message['channel'])
+        channels.each do |name|
+          channel = @channels[name]
+          channel.trigger(:message, message['data']) if channel
+        end
+      end
+    end
+    
+  end
+end
+

data/lib/faye/protocol/client.rb

@@ -0,0 +1,378 @@
+module Faye
+  class Client
+    
+    include EventMachine::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
+    DEFAULT_RETRY       = 5.0
+    
+    attr_reader :endpoint, :client_id, :retry
+    
+    def initialize(endpoint = nil, options = {})
+      info('New client created for ?', endpoint)
+      
+      @endpoint   = endpoint || RackAdapter::DEFAULT_ENDPOINT
+      @cookies    = CookieJar::Jar.new
+      @headers    = {}
+      @options    = options
+      @disabled   = []
+      @retry      = @options[:retry] || DEFAULT_RETRY
+
+      select_transport(MANDATORY_CONNECTION_TYPES)
+      
+      @state      = UNCONNECTED
+      @channels   = Channel::Set.new
+      @message_id = 0
+      
+      @response_callbacks = {}
+      
+      @advice = {
+        'reconnect' => RETRY,
+        'interval'  => 1000.0 * (@options[:interval] || Engine::INTERVAL),
+        'timeout'   => 1000.0 * (@options[:timeout]  || CONNECTION_TIMEOUT)
+      }
+    end
+    
+    def disable(feature)
+      @disabled << feature
+    end
+    
+    def set_header(name, value)
+      @headers[name.to_s] = value.to_s
+    end
+    
+    def state
+      case @state
+      when UNCONNECTED  then :UNCONNECTED
+      when CONNECTING   then :CONNECTING
+      when CONNECTED    then :CONNECTED
+      when DISCONNECTED then :DISCONNECTED
+      end
+    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 ?', @endpoint)
+      
+      send({
+        'channel'     => Channel::HANDSHAKE,
+        'version'     => BAYEUX_VERSION,
+        'supportedConnectionTypes' => [@transport.connection_type]
+        
+      }) do |response|
+        
+        if response['successful']
+          @state     = CONNECTED
+          @client_id = response['clientId']
+          
+          connection_types = response['supportedConnectionTypes'] - @disabled
+          select_transport(connection_types)
+          
+          info('Handshake successful: ?', @client_id)
+          
+          subscribe(@channels.keys, true)
+          block.call if block_given?
+          
+        else
+          info('Handshake unsuccessful')
+          EventMachine.add_timer(@advice['interval'] / 1000.0) { 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 ?', @client_id)
+      set_deferred_status(:succeeded)
+      set_deferred_status(:deferred)
+      
+      return unless @connect_request.nil?
+      @connect_request = true
+      
+      info('Initiating connection for ?', @client_id)
+      
+      send({
+        'channel'         => Channel::CONNECT,
+        'clientId'        => @client_id,
+        'connectionType'  => @transport.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 ?', @client_id)
+      
+      send({
+        'channel'   => Channel::DISCONNECT,
+        'clientId'  => @client_id
+        
+      }) do |response|
+        @transport.close if response['successful']
+      end
+      
+      info('Clearing channel listeners for ?', @client_id)
+      @channels = Channel::Set.new
+    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.each do |channel|
+          subscribe(channel, force, &block)
+        end
+      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 ?', @client_id, channel)
+        @channels.subscribe([channel], block) unless force
+        
+        send({
+          'channel'       => Channel::SUBSCRIBE,
+          'clientId'      => @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 ?', @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.each do |channel|
+          unsubscribe(channel, &block)
+        end
+      end
+      
+      dead = @channels.unsubscribe(channel, block)
+      return unless dead
+      
+      connect {
+        info('Client ? attempting to unsubscribe from ?', @client_id, channel)
+        
+        send({
+          'channel'       => Channel::UNSUBSCRIBE,
+          'clientId'      => @client_id,
+          'subscription'  => channel
+          
+        }) do |response|
+          next unless response['successful']
+            
+          channels = [response['subscription']].flatten
+          info('Unsubscription acknowledged for ? from ?', @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)
+      publication = Publication.new
+      connect {
+        info('Client ? queueing published message to ?: ?', @client_id, channel, data)
+        
+        send({
+          'channel'   => channel,
+          'data'      => data,
+          'clientId'  => @client_id
+        }) do |response|
+          if response['successful']
+            publication.set_deferred_status(:succeeded)
+          else
+            publication.set_deferred_status(:failed, Error.parse(response['error']))
+          end
+        end
+      }
+      publication
+    end
+    
+    def receive_message(message)
+      pipe_through_extensions(:incoming, message) do |message|
+        next unless message
+        
+        handle_advice(message['advice']) if message['advice']
+        deliver_message(message)
+        
+        next unless message.has_key?('successful')
+        
+        callback = @response_callbacks[message['id']]
+        next unless callback
+        
+        @response_callbacks.delete(message['id'])
+        callback.call(message)
+      end
+    end
+    
+  private
+    
+    def select_transport(transport_types)
+      Transport.get(self, transport_types) do |transport|
+        @transport = transport
+        @transport.cookies = @cookies
+        @transport.headers = @headers
+        
+        transport.bind :down do
+          if @transport_up.nil? or @transport_up
+            @transport_up = false
+            trigger('transport:down')
+          end
+        end
+        
+        transport.bind :up do
+          if @transport_up.nil? or not @transport_up
+            @transport_up = true
+            trigger('transport:up')
+          end
+        end
+      end
+    end
+    
+    def send(message, &callback)
+      message['id'] = generate_message_id
+      @response_callbacks[message['id']] = callback if callback
+
+      pipe_through_extensions(:outgoing, message) do |message|
+        @transport.send(message, @advice['timeout'] / 1000.0) if message
+      end
+    end
+    
+    def generate_message_id
+      @message_id += 1
+      @message_id = 0 if @message_id >= 2**32
+      @message_id.to_s(36)
+    end
+    
+    def handle_advice(advice)
+      @advice.update(advice)
+      
+      if @advice['reconnect'] == HANDSHAKE and @state != DISCONNECTED
+        @state     = UNCONNECTED
+        @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'])
+      @channels.distribute_message(message)
+    end
+    
+    def teardown_connection
+      return unless @connect_request
+      @connect_request = nil
+      info('Closed connection for ?', @client_id)
+    end
+    
+    def cycle_connection
+      teardown_connection
+      EventMachine.add_timer(@advice['interval'] / 1000.0) { connect }
+    end
+    
+  end
+end
+