faye 0.7.2 → 0.8.0

data/lib/faye/engines/proxy.rb

@@ -0,0 +1,109 @@
+module Faye
+  module Engine
+    
+    METHODS   = %w[create_client client_exists destroy_client ping subscribe unsubscribe]
+    MAX_DELAY = 0.0
+    INTERVAL  = 0.0
+    TIMEOUT   = 60.0
+    ID_LENGTH = 128
+    
+    autoload :Connection, File.expand_path('../connection', __FILE__)
+    autoload :Memory,     File.expand_path('../memory', __FILE__)
+    
+    def self.ensure_reactor_running!
+      Thread.new { EM.run } unless EM.reactor_running?
+      Thread.pass until EM.reactor_running?
+    end
+    
+    def self.get(options)
+      Proxy.new(options)
+    end
+    
+    def self.random(bitlength = ID_LENGTH)
+      limit    = 2 ** bitlength - 1
+      max_size = limit.to_s(36).size
+      string   = rand(limit).to_s(36)
+      string = '0' + string while string.size < max_size
+      string
+    end
+    
+    class Proxy
+      include Publisher
+      include Logging
+      
+      attr_reader :interval, :timeout
+      
+      extend Forwardable
+      def_delegators :@engine, *METHODS
+      
+      def initialize(options)
+        @options     = options
+        @connections = {}
+        @interval    = @options[:interval] || INTERVAL
+        @timeout     = @options[:timeout]  || TIMEOUT
+        
+        engine_class = @options[:type] || Memory
+        @engine      = engine_class.create(self, @options)
+
+        debug 'Created new engine: ?', @options
+      end
+      
+      def connect(client_id, options = {}, &callback)
+        debug 'Accepting connection from ?', client_id
+        @engine.ping(client_id)
+        conn = connection(client_id, true)
+        conn.connect(options, &callback)
+        @engine.empty_queue(client_id)
+      end
+      
+      def has_connection?(client_id)
+        @connections.has_key?(client_id)
+      end
+      
+      def connection(client_id, create)
+        conn = @connections[client_id]
+        return conn if conn or not create
+        @connections[client_id] = Connection.new(self, client_id)
+      end
+      
+      def close_connection(client_id)
+        debug 'Closing connection for ?', client_id
+        @connections.delete(client_id)
+      end
+      
+      def open_socket(client_id, socket)
+        conn = connection(client_id, true)
+        conn.socket = socket
+      end
+      
+      def deliver(client_id, messages)
+        return if !messages || messages.empty?
+        conn = connection(client_id, false)
+        return false unless conn
+        messages.each(&conn.method(:deliver))
+        true
+      end
+      
+      def generate_id
+        Engine.random
+      end
+      
+      def flush(client_id)
+        debug 'Flushing connection for ?', client_id
+        conn = connection(client_id, false)
+        conn.flush!(true) if conn
+      end
+      
+      def disconnect
+        @engine.disconnect if @engine.respond_to?(:disconnect)
+      end
+      
+      def publish(message)
+        channels = Channel.expand(message['channel'])
+        @engine.publish(message, channels)
+      end
+    end
+    
+  end
+end
+

data/lib/faye/mixins/logging.rb

@@ -1,11 +1,4 @@
 module Faye
-  
-  class << self
-    attr_accessor :logger
-  end
-  
-  self.logger = method(:puts)
-  
   module Logging
     
     DEFAULT_LOG_LEVEL = :error
@@ -42,7 +35,7 @@ module Faye
       timestamp = Time.now.strftime('%Y-%m-%d %H:%M:%S')
       banner = " [#{ level.to_s.upcase }] [#{ self.class.name }] "
       
-      puts(timestamp + banner + message)
+      Faye.logger.call(timestamp + banner + message)
     end
     
     LOG_LEVELS.each do |level, value|

data/lib/faye/mixins/timeouts.rb

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

data/lib/faye/protocol/channel.rb

@@ -22,8 +22,8 @@ module Faye
     UNSUBSCRIBE = '/meta/unsubscribe'
     DISCONNECT  = '/meta/disconnect'
     
-    META        = 'meta'
-    SERVICE     = 'service'
+    META        = :meta
+    SERVICE     = :service
     
     class << self
       def expand(name)
@@ -50,7 +50,7 @@ module Faye
       
       def parse(name)
         return nil unless valid?(name)
-        name.split('/')[1..-1]
+        name.split('/')[1..-1].map { |s| s.to_sym }
       end
       
       def unparse(segments)

data/lib/faye/protocol/client.rb

@@ -16,16 +16,19 @@ module Faye
     NONE                = 'none'
     
     CONNECTION_TIMEOUT  = 60.0
+    DEFAULT_RETRY       = 5.0
     
-    attr_accessor :cookies
-    attr_reader :endpoint, :client_id
+    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)
       
@@ -46,6 +49,10 @@ module Faye
       @disabled << feature
     end
     
+    def set_header(name, value)
+      @headers[name.to_s] = value.to_s
+    end
+    
     def state
       case @state
       when UNCONNECTED  then :UNCONNECTED
@@ -181,40 +188,41 @@ module Faye
     #                                                     * ext
     #                                                     * id
     #                                                     * timestamp
-    def subscribe(channels, force = false, &block)
-      if Array === channels
-        return channels.each do |channel|
+    def subscribe(channel, force = false, &block)
+      if Array === channel
+        return channel.each do |channel|
           subscribe(channel, force, &block)
         end
       end
       
-      subscription = Subscription.new(self, channels, block)
+      subscription  = Subscription.new(self, channel, block)
+      has_subscribe = @channels.has_subscription?(channel)
       
-      if not force and @channels.has_subscription?(channels)
-        @channels.subscribe([channels], block)
-        subscription.set_deferred_status(:succeeded)
-        return subscription
+      unless force
+        @channels.subscribe([channel], block)
+        if has_subscribe
+          subscription.set_deferred_status(:succeeded)
+          return subscription
+        end
       end
       
       connect {
-        info('Client ? attempting to subscribe to ?', @client_id, channels)
+        info('Client ? attempting to subscribe to ?', @client_id, channel)
         
         send({
           'channel'       => Channel::SUBSCRIBE,
           'clientId'      => @client_id,
-          'subscription'  => channels
+          'subscription'  => channel
           
         }) do |response|
-          if response['successful']
-            
-            channels = [response['subscription']].flatten
-            info('Subscription acknowledged for ? to ?', @client_id, channels)
-            @channels.subscribe(channels, block)
-            
-            subscription.set_deferred_status(:succeeded)
-          else
+          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
@@ -230,30 +238,29 @@ module Faye
     #                                                     * ext
     #                                                     * id
     #                                                     * timestamp
-    def unsubscribe(channels, &block)
-      if Array === channels
-        return channels.each do |channel|
+    def unsubscribe(channel, &block)
+      if Array === channel
+        return channel.each do |channel|
           unsubscribe(channel, &block)
         end
       end
       
-      dead = @channels.unsubscribe(channels, block)
+      dead = @channels.unsubscribe(channel, block)
       return unless dead
       
       connect {
-        info('Client ? attempting to unsubscribe from ?', @client_id, channels)
+        info('Client ? attempting to unsubscribe from ?', @client_id, channel)
         
         send({
           'channel'       => Channel::UNSUBSCRIBE,
           'clientId'      => @client_id,
-          'subscription'  => channels
+          'subscription'  => channel
           
         }) do |response|
-          if response['successful']
+          next unless response['successful']
             
-            channels = [response['subscription']].flatten
-            info('Unsubscription acknowledged for ? from ?', @client_id, channels)
-          end
+          channels = [response['subscription']].flatten
+          info('Unsubscription acknowledged for ? from ?', @client_id, channels)
         end
       }
     end
@@ -265,10 +272,6 @@ module Faye
     #                * id                                 * error
     #                * ext                                * ext
     def publish(channel, data)
-      unless Grammar::CHANNEL_NAME =~ channel
-        raise "Cannot publish: '#{channel}' is not a valid channel name"
-      end
-      
       publication = Publication.new
       connect {
         info('Client ? queueing published message to ?: ?', @client_id, channel, data)
@@ -290,17 +293,17 @@ module Faye
     
     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)
+        next unless 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
     
@@ -309,6 +312,8 @@ module Faye
     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
@@ -352,7 +357,7 @@ module Faye
     end
     
     def deliver_message(message)
-      return unless message['channel'] and message['data']
+      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

data/lib/faye/protocol/extensible.rb

@@ -11,12 +11,9 @@ module Faye
     def remove_extension(extension)
       return unless @extensions
       @extensions.delete_if do |ext|
-        if ext == extension
-          extension.removed(self) if extension.respond_to?(:removed)
-          true
-        else
-          false
-        end
+        next false unless ext == extension
+        extension.removed(self) if extension.respond_to?(:removed)
+        true
       end
     end
     
@@ -27,19 +24,15 @@ module Faye
       extensions = @extensions.dup
       
       pipe = lambda do |message|
-        if !message
-          callback.call(message)
+        next callback.call(message) unless message
+        
+        extension = extensions.shift
+        next callback.call(message) unless extension
+        
+        if extension.respond_to?(stage)
+          extension.__send__(stage, message, pipe)
         else
-          extension = extensions.shift
-          if (!extension)
-            callback.call(message)
-          else
-            if extension.respond_to?(stage)
-              extension.__send__(stage, message, pipe)
-            else
-              pipe.call(message)
-            end
-          end
+          pipe.call(message)
         end
       end
       pipe.call(message)

data/lib/faye/protocol/server.rb

@@ -3,8 +3,6 @@ module Faye
     
     include Logging
     include Extensible
-
-    META_METHODS = %w[handshake connect disconnect subscribe unsubscribe]
     
     attr_reader :engine
 
@@ -18,11 +16,18 @@ module Faye
     end
     
     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
+      client_id = [messages].flatten.first['clientId']
+      return unless client_id
+      info 'Flushing connection for ?', client_id
+      @engine.flush(client_id) if client_id
+    end
+    
+    def open_socket(client_id, socket)
+      @engine.open_socket(client_id, socket)
+    end
+    
+    def close_socket(client_id)
+      @engine.flush(client_id)
     end
     
     def process(messages, local = false, &callback)
@@ -63,11 +68,12 @@ module Faye
     
     def make_response(message)
       response = {}
-      %w[id clientId channel error].each do |field|
-        if message[field]
-          response[field] = message[field]
-        end
-      end
+      
+      response['id']       = message['id']       if message['id']
+      response['clientId'] = message['clientId'] if message['clientId']
+      response['channel']  = message['channel']  if message['channel']
+      response['error']    = message['error']    if message['error']
+      
       response['successful'] = !response['error']
       response
     end
@@ -77,47 +83,51 @@ module Faye
       info 'Handling message: ? (local: ?)', message, local
       
       channel_name = message['channel']
+      error        = message['error']
       
       return handle_meta(message, local, &callback) if Channel.meta?(channel_name)
       
-      @engine.publish(message) unless message['error'] or Grammar::CHANNEL_NAME !~ channel_name
-      
-      if message['clientId']
-        response = make_response(message)
-        response['successful'] = !response['error']
-        callback.call([response])
-      else
-        callback.call([])
+      if Grammar::CHANNEL_NAME !~ channel_name
+        error = Faye::Error.channel_invalid(channel_name)
       end
+      
+      @engine.publish(message) unless error
+      
+      response = make_response(message)
+      response['error'] = error if error
+      response['successful'] = !response['error']
+      callback.call([response])
     end
     
     def handle_meta(message, local, &callback)
-      method = Channel.parse(message['channel'])[1]
+      method    = Channel.parse(message['channel'])[1]
+      client_id = message['clientId']
       
-      unless META_METHODS.include?(method)
-        response = make_response(message)
-        response['error'] = Faye::Error.channel_forbidden(message['channel'])
-        response['successful'] = false
-        return callback.call([response])
-      end
-
       __send__(method, message, local) do |responses|
         responses = [responses].flatten
-        responses.each(&method(:advize))
+        responses.each { |r| advize(r, message['connectionType']) }
         callback.call(responses)
       end
     end
     
-    def advize(response)
+    def advize(response, connection_type)
       return unless [Channel::HANDSHAKE, Channel::CONNECT].include?(response['channel'])
       
+      if connection_type == 'eventsource'
+        interval = (@engine.timeout * 1000).floor
+        timeout  = 0
+      else
+        interval = (@engine.interval * 1000).floor
+        timeout  = (@engine.timeout * 1000).floor
+      end
+      
       advice = response['advice'] ||= {}
       if response['error']
         advice['reconnect'] ||= 'handshake'
       else
         advice['reconnect'] ||= 'retry'
-        advice['interval']  ||= (@engine.interval * 1000).floor
-        advice['timeout']   ||= (@engine.timeout * 1000).floor
+        advice['interval']  ||= interval
+        advice['timeout']   ||= timeout
       end
     end
     
@@ -173,13 +183,18 @@ module Faye
         
         response['successful'] = response['error'].nil?
         
-        if response['successful']
-          @engine.connect(response['clientId'], message['advice']) do |events|
-            callback.call([response] + events)
-          end
-        else
+        if !response['successful']
           response.delete('clientId')
-          callback.call(response)
+          next callback.call(response)
+        end
+        
+        if message['connectionType'] == 'eventsource'
+          message['advice'] ||= {}
+          message['advice']['timeout'] = 0
+        end
+        
+        @engine.connect(response['clientId'], message['advice']) do |events|
+          callback.call([response] + events)
         end
       end
     end