faye-huboard 1.0.4

data/lib/faye/engines/memory.rb

@@ -0,0 +1,121 @@
+module Faye
+  module Engine
+
+    class Memory
+      include Timeouts
+
+      def self.create(server, options)
+        new(server, options)
+      end
+
+      def initialize(server, options)
+        @server    = server
+        @options   = options
+        reset
+      end
+
+      def disconnect
+        reset
+        remove_all_timeouts
+      end
+
+      def reset
+        @namespace = Namespace.new
+        @clients   = {}
+        @channels  = {}
+        @messages  = {}
+      end
+
+      def create_client(&callback)
+        client_id = @namespace.generate
+        @server.debug('Created new client ?', client_id)
+        ping(client_id)
+        @server.trigger(:handshake, client_id)
+        callback.call(client_id)
+      end
+
+      def destroy_client(client_id, &callback)
+        return unless @namespace.exists?(client_id)
+
+        if @clients.has_key?(client_id)
+          @clients[client_id].each { |channel| unsubscribe(client_id, channel) }
+        end
+
+        remove_timeout(client_id)
+        @namespace.release(client_id)
+        @messages.delete(client_id)
+        @server.debug('Destroyed client ?', client_id)
+        @server.trigger(:disconnect, client_id)
+        @server.trigger(:close, client_id)
+        callback.call if callback
+      end
+
+      def client_exists(client_id, &callback)
+        callback.call(@namespace.exists?(client_id))
+      end
+
+      def ping(client_id)
+        timeout = @server.timeout
+        return unless Numeric === timeout
+        @server.debug('Ping ?, ?', client_id, timeout)
+        remove_timeout(client_id)
+        add_timeout(client_id, 2 * timeout) { destroy_client(client_id) }
+      end
+
+      def subscribe(client_id, channel, &callback)
+        @clients[client_id] ||= Set.new
+        should_trigger = @clients[client_id].add?(channel)
+
+        @channels[channel] ||= Set.new
+        @channels[channel].add(client_id)
+
+        @server.debug('Subscribed client ? to channel ?', client_id, channel)
+        @server.trigger(:subscribe, client_id, channel) if should_trigger
+        callback.call(true) if callback
+      end
+
+      def unsubscribe(client_id, channel, &callback)
+        if @clients.has_key?(client_id)
+          should_trigger = @clients[client_id].delete?(channel)
+          @clients.delete(client_id) if @clients[client_id].empty?
+        end
+
+        if @channels.has_key?(channel)
+          @channels[channel].delete(client_id)
+          @channels.delete(channel) if @channels[channel].empty?
+        end
+
+        @server.debug('Unsubscribed client ? from channel ?', client_id, channel)
+        @server.trigger(:unsubscribe, client_id, channel) if should_trigger
+        callback.call(true) if callback
+      end
+
+      def publish(message, channels)
+        @server.debug('Publishing message ?', message)
+
+        clients = Set.new
+
+        channels.each do |channel|
+          next unless subs = @channels[channel]
+          subs.each(&clients.method(:add))
+        end
+
+        clients.each do |client_id|
+          @server.debug('Queueing for client ?: ?', client_id, message)
+          @messages[client_id] ||= []
+          @messages[client_id] << Faye.copy_object(message)
+          empty_queue(client_id)
+        end
+
+        @server.trigger(:publish, message['clientId'], message['channel'], message['data'])
+      end
+
+      def empty_queue(client_id)
+        return unless @server.has_connection?(client_id)
+        @server.deliver(client_id, @messages[client_id])
+        @messages.delete(client_id)
+      end
+    end
+
+  end
+end

data/lib/faye/engines/proxy.rb

@@ -0,0 +1,126 @@
+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 = 160
+
+    autoload :Connection, File.expand_path('../connection', __FILE__)
+    autoload :Memory,     File.expand_path('../memory', __FILE__)
+
+    def self.ensure_reactor_running!
+      Thread.new { EventMachine.run } unless EventMachine.reactor_running?
+      Thread.pass until EventMachine.reactor_running?
+    end
+
+    def self.get(options)
+      Proxy.new(options)
+    end
+
+    def self.random(bitlength = ID_LENGTH)
+      limit    = 2 ** bitlength
+      max_size = (bitlength * Math.log(2) / Math.log(36)).ceil
+      string   = SecureRandom.random_number(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)
+        super()
+
+        @options     = options
+        @connections = {}
+        @interval    = @options[:interval] || INTERVAL
+        @timeout     = @options[:timeout]  || TIMEOUT
+
+        engine_class = @options[:type] || Memory
+        @engine      = engine_class.create(self, @options)
+
+        bind :close do |client_id|
+          EventMachine.next_tick { flush_connection(client_id) }
+        end
+
+        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)
+        trigger('connection:open', client_id)
+        @connections[client_id]
+      end
+
+      def close_connection(client_id)
+        debug('Closing connection for ?', client_id)
+        return unless conn = @connections[client_id]
+        conn.socket.close if conn.socket
+        trigger('connection:close', 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?
+        return false unless conn = connection(client_id, false)
+        messages.each(&conn.method(:deliver))
+        true
+      end
+
+      def generate_id
+        Engine.random
+      end
+
+      def flush_connection(client_id, close = true)
+        return unless client_id
+        debug('Flushing connection for ?', client_id)
+        return unless conn = connection(client_id, false)
+        conn.socket = nil unless close
+        conn.flush
+        close_connection(client_id)
+      end
+
+      def close
+        @connections.keys.each { |client_id| flush_connection(client_id) }
+        @engine.disconnect
+      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/error.rb

@@ -0,0 +1,48 @@
+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/deferrable.rb

@@ -0,0 +1,14 @@
+module Faye
+  module Deferrable
+
+    include EventMachine::Deferrable
+
+    def set_deferred_status(status, *args)
+      if status == :unknown
+        @deferred_status = @deferred_args = @callbacks = @errbacks = nil
+      end
+      super
+    end
+
+  end
+end

data/lib/faye/mixins/logging.rb

@@ -0,0 +1,35 @@
+module Faye
+  module Logging
+
+    LOG_LEVELS = {
+      :fatal  => 4,
+      :error  => 3,
+      :warn   => 2,
+      :info   => 1,
+      :debug  => 0
+    }
+
+    LOG_LEVELS.each do |level, value|
+      define_method(level) { |*args| write_log(args, level) }
+    end
+
+  private
+
+    def write_log(message_args, level)
+      return unless Faye.logger
+
+      message = message_args.shift.gsub(/\?/) do
+        Faye.to_json(message_args.shift)
+      end
+
+      banner = "[#{ self.class.name }] "
+
+      if Faye.logger.respond_to?(level)
+        Faye.logger.__send__(level, banner + message)
+      elsif Faye.logger.respond_to?(:call)
+        Faye.logger.call(banner + message)
+      end
+    end
+
+  end
+end

data/lib/faye/mixins/publisher.rb

@@ -0,0 +1,18 @@
+module Faye
+  module Publisher
+
+    include ::WebSocket::Driver::EventEmitter
+
+    alias :bind    :add_listener
+    alias :trigger :emit
+
+    def unbind(event, &listener)
+      if listener
+        remove_listener(event, &listener)
+      else
+        remove_all_listeners(event)
+      end
+    end
+
+  end
+end

data/lib/faye/mixins/timeouts.rb

@@ -0,0 +1,26 @@
+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
+
+    def remove_all_timeouts
+      @timeouts ||= {}
+      @timeouts.keys.each { |name| remove_timeout(name) }
+    end
+  end
+end

data/lib/faye/protocol/channel.rb

@@ -0,0 +1,123 @@
+module Faye
+  class Channel
+
+    include Publisher
+    attr_reader :name
+
+    def initialize(name)
+      super()
+      @name = name
+    end
+
+    def <<(message)
+      trigger(:message, message)
+    end
+
+    def unused?
+      listener_count(: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]
+      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
+        @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)
+        names.each do |name|
+          channel = @channels[name] ||= Channel.new(name)
+          channel.bind(:message, &callback) if 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