faye 0.5.5 → 0.6.0

data/lib/faye/engines/redis.rb

@@ -0,0 +1,141 @@
+module Faye
+  module Engine
+    
+    class Redis < Base
+      DEFAULT_HOST = 'localhost'
+      DEFAULT_PORT = 6379
+      
+      def init
+        return if @redis
+        require 'em-hiredis'
+        
+        host = @options[:host] || DEFAULT_HOST
+        port = @options[:port] || DEFAULT_PORT
+        
+        @redis      = EventMachine::Hiredis::Client.connect(host, port)
+        @subscriber = EventMachine::Hiredis::Client.connect(host, port)
+        
+        @subscriber.subscribe('/notifications')
+        @subscriber.on(:message) do |topic, message|
+          empty_queue(message) if topic == '/notifications'
+        end
+      end
+      
+      def disconnect
+        @subscriber.unsubscribe('/notifications')
+      end
+      
+      def create_client(&callback)
+        init
+        client_id = Faye.random
+        @redis.sadd('/clients', client_id) do |added|
+          if added == 0
+            create_client(&callback)
+          else
+            debug 'Created new client ?', client_id
+            ping(client_id)
+            callback.call(client_id)
+          end
+        end
+      end
+      
+      def destroy_client(client_id, &callback)
+        init
+        @redis.srem('/clients', client_id)
+        @redis.del("/clients/#{client_id}/messages")
+        @redis.smembers("/clients/#{client_id}/channels") do |channels|
+          n, i = channels.size, 0
+          if n == 0
+            debug 'Destroyed client ?', client_id
+            callback.call if callback
+          else
+            channels.each do |channel|
+              unsubscribe(client_id, channel) do
+                i += 1
+                if i == n
+                  debug 'Destroyed client ?', client_id
+                  callback.call if callback
+                end
+              end
+            end
+          end
+        end
+      end
+      
+      def client_exists(client_id, &callback)
+        init
+        @redis.sismember('/clients', client_id) do |exists|
+          callback.call(exists != 0)
+        end
+      end
+      
+      def ping(client_id)
+        timeout = @options[:timeout]
+        time    = Time.now.to_i.to_s
+        
+        return unless Numeric === timeout
+        
+        debug 'Ping ?, ?', client_id, timeout
+        remove_timeout(client_id)
+        @redis.set("/clients/#{client_id}/ping", time)
+        add_timeout(client_id, 2 * timeout) do
+          @redis.get("/clients/#{client_id}/ping") do |ping|
+            destroy_client(client_id) if ping == time
+          end
+        end
+      end
+      
+      def subscribe(client_id, channel, &callback)
+        init
+        @redis.sadd("/clients/#{client_id}/channels", channel)
+        @redis.sadd("/channels#{channel}", client_id) do
+          debug 'Subscribed client ? to channel ?', client_id, channel
+          callback.call if callback
+        end
+      end
+      
+      def unsubscribe(client_id, channel, &callback)
+        init
+        @redis.srem("/clients/#{client_id}/channels", channel)
+        @redis.srem("/channels#{channel}", client_id) do
+          debug 'Unsubscribed client ? from channel ?', client_id, channel
+          callback.call if callback
+        end
+      end
+      
+      def publish(message)
+        init
+        debug 'Publishing message ?', message
+        json_message = JSON.dump(message)
+        channels = Channel.expand(message['channel'])
+        channels.each do |channel|
+          @redis.smembers("/channels#{channel}") do |clients|
+            clients.each do |client_id|
+              debug 'Queueing for client ?: ?', client_id, message
+              @redis.sadd("/clients/#{client_id}/messages", json_message)
+              @redis.publish('/notifications', client_id)
+            end
+          end
+        end
+      end
+      
+    private
+      
+      def empty_queue(client_id)
+        return unless conn = connection(client_id, false)
+        init
+        
+        key = "/clients/#{client_id}/messages"
+        @redis.smembers(key) do |json_messages|
+          json_messages.each do |json_message|
+            @redis.srem(key, json_message)
+            conn.deliver(JSON.parse(json_message))
+          end
+        end
+      end
+    end
+    
+    register 'redis', Redis
+    
+  end
+end

data/lib/faye/error.rb

@@ -6,16 +6,28 @@ module Faye
       new(code[0], args, code[1]).to_s
     end
     
-    attr_reader :code, :args, :message
+    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, args, message)
+    def initialize(code, params, message)
       @code     = code
-      @args     = args
+      @params   = params
       @message  = message
     end
     
     def to_s
-      "#{ @code }:#{ @args * ',' }:#{ @message }"
+      "#{ @code }:#{ @params * ',' }:#{ @message }"
     end
     
     # http://code.google.com/p/cometd/wiki/BayeuxCodes

data/lib/faye/mixins/publisher.rb

@@ -14,9 +14,15 @@ module Faye
     
     def remove_subscriber(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 remove_subscribers
+      @subscribers = {}
+    end
+    
     def publish_event(event_type, *args)
       return unless @subscribers and @subscribers[event_type]
       @subscribers[event_type].each do |listener|

data/lib/faye/protocol/channel.rb

@@ -26,6 +26,23 @@ module Faye
     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
@@ -36,6 +53,10 @@ module Faye
         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
@@ -52,110 +73,35 @@ module Faye
       end
     end
     
-    class Tree
-      include Enumerable
-      attr_accessor :value
-      
+    class Set
       def initialize(parent = nil, value = nil)
-        @parent   = parent
-        @value    = value
-        @children = {}
-      end
-      
-      def each_child
-        @children.each { |key, subtree| yield(key, subtree) }
-      end
-      
-      def each(prefix = [], &block)
-        each_child { |path, subtree| subtree.each(prefix + [path], &block) }
-        yield(prefix, @value) unless @value.nil?
+        @channels = {}
       end
       
       def keys
-        map { |key, value| '/' + key * '/' }
-      end
-      
-      def [](name)
-        subtree = traverse(name)
-        subtree ? subtree.value : nil
-      end
-      
-      def []=(name, value)
-        subtree = traverse(name, true)
-        subtree.value = value unless subtree.nil?
+        @channels.keys
       end
       
-      def remove(name = nil)
-        if name
-          subtree = traverse(name)
-          subtree.remove unless subtree.nil?
-        else
-          return unless @parent
-          @parent.remove_child(self)
-          @parent = @value = nil
-        end
-      end
-      
-      def remove_child(subtree)
-        each_child do |key, child|
-          @children.delete(key) if child == subtree
-        end
-        remove if @children.empty? and @value.nil?
-      end
-      
-      def traverse(path, create_if_absent = false)
-        path = Channel.parse(path) if String === path
-        
-        return nil if path.nil?
-        return self if path.empty?
-        
-        subtree = @children[path.first]
-        return nil if subtree.nil? and not create_if_absent
-        subtree = @children[path.first] = Tree.new(self) if subtree.nil?
-        
-        subtree.traverse(path[1..-1], create_if_absent)
+      def remove(name)
+        @channels.delete(name)
       end
       
-      def glob(path = [])
-        path = Channel.parse(path) if String === path
-        
-        return [] if path.nil?
-        return @value.nil? ? [] : [@value] if path.empty?
-        
-        if path == [:*]
-          return @children.inject([]) do |list, (key, subtree)|
-            list << subtree.value unless subtree.value.nil?
-            list
-          end
-        end
-        
-        if path == [:**]
-          list = map { |key, value| value }
-          list.pop unless @value.nil?
-          return list
-        end
-        
-        list = @children.values_at(path.first, :*).
-                         compact.
-                         map { |t| t.glob(path[1..-1]) }
-        
-        list << @children[:**].value if @children[:**]
-        list.flatten
+      def has_subscription?(name)
+        @channels.has_key?(name)
       end
       
       def subscribe(names, callback)
         return unless callback
         names.each do |name|
-          channel = self[name] ||= Channel.new(name)
+          channel = @channels[name] ||= Channel.new(name)
           channel.add_subscriber(:message, callback)
         end
       end
       
       def unsubscribe(name, callback)
-        channel = self[name]
+        channel = @channels[name]
         return false unless channel
         channel.remove_subscriber(:message, callback)
-        
         if channel.unused?
           remove(name)
           true
@@ -165,8 +111,10 @@ module Faye
       end
       
       def distribute_message(message)
-        glob(message['channel']).each do |channel|
-          channel.publish_event(:message, message['data'])
+        channels = Channel.expand(message['channel'])
+        channels.each do |name|
+          channel = @channels[name]
+          channel.publish_event(:message, message['data']) if channel
         end
       end
     end

data/lib/faye/protocol/client.rb

@@ -2,7 +2,6 @@ module Faye
   class Client
     
     include EventMachine::Deferrable
-    include Timeouts
     include Logging
     include Extensible
     
@@ -27,19 +26,27 @@ module Faye
       
       @transport = Transport.get(self, MANDATORY_CONNECTION_TYPES)
       @state     = UNCONNECTED
-      @outbox    = []
-      @channels  = Channel::Tree.new
+      @channels  = Channel::Set.new
       
       @namespace = Namespace.new
       @response_callbacks = {}
       
       @advice = {
         'reconnect' => RETRY,
-        'interval'  => 1000.0 * (@options[:interval] || Connection::INTERVAL),
-        'timeout'   => 1000.0 * (@options[:timeout] || CONNECTION_TIMEOUT)
+        'interval'  => 1000.0 * (@options[:interval] || Engine::INTERVAL),
+        'timeout'   => 1000.0 * (@options[:timeout]  || CONNECTION_TIMEOUT)
       }
     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
@@ -81,7 +88,7 @@ module Faye
           
           info('Handshake successful: ?', @client_id)
           
-          subscribe(@channels.keys)
+          subscribe(@channels.keys, true)
           block.call if block_given?
           
         else
@@ -148,7 +155,7 @@ module Faye
       })
       
       info('Clearing channel listeners for ?', @client_id)
-      @channels = Channel::Tree.new
+      @channels = Channel::Set.new
     end
     
     # Request                              Response
@@ -161,16 +168,21 @@ module Faye
     #                                                     * ext
     #                                                     * id
     #                                                     * timestamp
-    def subscribe(channels, &block)
+    def subscribe(channels, force = false, &block)
       if Array === channels
         return channels.each do |channel|
-          subscribe(channel, &block)
+          subscribe(channel, force, &block)
         end
       end
       
-      validate_channel(channels)
       subscription = Subscription.new(self, channels, block)
       
+      if not force and @channels.has_subscription?(channels)
+        @channels.subscribe([channels], block)
+        subscription.set_deferred_status(:succeeded)
+        return subscription
+      end
+      
       connect {
         info('Client ? attempting to subscribe to ?', @client_id, channels)
         
@@ -187,6 +199,8 @@ module Faye
             @channels.subscribe(channels, block)
             
             subscription.set_deferred_status(:succeeded)
+          else
+            subscription.set_deferred_status(:failed, Error.parse(response['error']))
           end
         end
       }
@@ -210,8 +224,6 @@ module Faye
         end
       end
       
-      validate_channel(channels)
-      
       dead = @channels.unsubscribe(channels, block)
       return unless dead
       
@@ -240,7 +252,9 @@ module Faye
     #                * id                                 * error
     #                * ext                                * ext
     def publish(channel, data)
-      validate_channel(channel)
+      unless Grammar::CHANNEL_NAME =~ channel
+        raise "Cannot publish: '#{channel}' is not a valid channel name"
+      end
       
       connect {
         info('Client ? queueing published message to ?: ?', @client_id, channel, data)
@@ -271,6 +285,15 @@ module Faye
     
   private
     
+    def send(message, &callback)
+      message['id'] = @namespace.generate
+      @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 handle_advice(advice)
       @advice.update(advice)
       
@@ -298,45 +321,6 @@ module Faye
       EventMachine.add_timer(@advice['interval'] / 1000.0) { connect }
     end
     
-    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