faye-huboard 1.0.4

data/lib/faye/protocol/extensible.rb

@@ -0,0 +1,45 @@
+module Faye
+  module Extensible
+    include Logging
+
+    def add_extension(extension)
+      @extensions ||= []
+      @extensions << extension
+      extension.added(self) if extension.respond_to?(:added)
+    end
+
+    def remove_extension(extension)
+      return unless @extensions
+      @extensions.delete_if do |ext|
+        next false unless ext == extension
+        extension.removed(self) if extension.respond_to?(:removed)
+        true
+      end
+    end
+
+    def pipe_through_extensions(stage, message, env, &callback)
+      debug('Passing through ? extensions: ?', stage, message)
+
+      return callback.call(message) unless @extensions
+      extensions = @extensions.dup
+
+      pipe = lambda do |message|
+        next callback.call(message) unless message
+
+        extension = extensions.shift
+        next callback.call(message) unless extension
+
+        next pipe.call(message) unless extension.respond_to?(stage)
+
+        arity = extension.method(stage).arity
+        if arity >= 3
+          extension.__send__(stage, message, env, pipe)
+        else
+          extension.__send__(stage, message, pipe)
+        end
+      end
+      pipe.call(message)
+    end
+
+  end
+end

data/lib/faye/protocol/grammar.rb

@@ -0,0 +1,57 @@
+module Faye
+  module Grammar
+
+    def self.rule(&block)
+      source = instance_eval(&block)
+      %r{^#{string(source)}$}
+    end
+
+    def self.choice(*list)
+      '(' + list.map(&method(:string)) * '|' + ')'
+    end
+
+    def self.repeat(*pattern)
+      '(' + string(pattern) + ')*'
+    end
+
+    def self.oneormore(*pattern)
+      '(' + string(pattern) + ')+'
+    end
+
+    def self.string(item)
+      return item.map(&method(:string)) * '' if Array === item
+      String === item ? item : item.source.gsub(/^\^/, '').gsub(/\$$/, '')
+    end
+
+    LOWALPHA          = rule {[ '[a-z]' ]}
+    UPALPHA           = rule {[ '[A-Z]' ]}
+    ALPHA             = rule {[ choice(LOWALPHA, UPALPHA) ]}
+    DIGIT             = rule {[ '[0-9]' ]}
+    ALPHANUM          = rule {[ choice(ALPHA, DIGIT) ]}
+    MARK              = rule {[ choice(*%w[\\- \\_ \\! \\~ \\( \\) \\$ \\@]) ]}
+    STRING            = rule {[ repeat(choice(ALPHANUM, MARK, ' ', '\\/', '\\*', '\\.')) ]}
+    TOKEN             = rule {[ oneormore(choice(ALPHANUM, MARK)) ]}
+    INTEGER           = rule {[ oneormore(DIGIT) ]}
+
+    CHANNEL_SEGMENT   = rule {[ TOKEN ]}
+    CHANNEL_SEGMENTS  = rule {[ CHANNEL_SEGMENT, repeat('\\/', CHANNEL_SEGMENT) ]}
+    CHANNEL_NAME      = rule {[ '\\/', CHANNEL_SEGMENTS ]}
+
+    WILD_CARD         = rule {[ '\\*{1,2}' ]}
+    CHANNEL_PATTERN   = rule {[ repeat('\\/', CHANNEL_SEGMENT), '\\/', WILD_CARD ]}
+
+    VERSION_ELEMENT   = rule {[ ALPHANUM, repeat(choice(ALPHANUM, '\\-', '\\_')) ]}
+    VERSION           = rule {[ INTEGER, repeat('\\.', VERSION_ELEMENT) ]}
+
+    CLIENT_ID         = rule {[ oneormore(ALPHANUM) ]}
+
+    ID                = rule {[ oneormore(ALPHANUM) ]}
+
+    ERROR_MESSAGE     = rule {[ STRING ]}
+    ERROR_ARGS        = rule {[ STRING, repeat(',', STRING) ]}
+    ERROR_CODE        = rule {[ DIGIT, DIGIT, DIGIT ]}
+    ERROR             = rule {[ choice(string([ERROR_CODE, ':', ERROR_ARGS, ':', ERROR_MESSAGE]),
+                                       string([ERROR_CODE, ':', ':', ERROR_MESSAGE])) ]}
+
+  end
+end

data/lib/faye/protocol/publication.rb

@@ -0,0 +1,5 @@
+module Faye
+  class Publication
+    include Deferrable
+  end
+end

data/lib/faye/protocol/server.rb

@@ -0,0 +1,291 @@
+module Faye
+  class Server
+
+    autoload :Socket, File.join(ROOT, 'faye', 'protocol', 'socket')
+
+    include Logging
+    include Extensible
+
+    META_METHODS = %w[handshake connect disconnect subscribe unsubscribe]
+
+    attr_reader :engine
+
+    def initialize(options = {})
+      @options    = options || {}
+      engine_opts = @options[:engine] || {}
+      engine_opts[:timeout] = @options[:timeout]
+      @engine     = Faye::Engine.get(engine_opts)
+
+      info('Created new server: ?', @options)
+    end
+
+    def close
+      @engine.close
+    end
+
+    def open_socket(client_id, socket, env)
+      return unless client_id and socket
+      @engine.open_socket(client_id, Socket.new(self, socket, env))
+    end
+
+    def close_socket(client_id, close = true)
+      @engine.flush_connection(client_id, close)
+    end
+
+    def process(messages, env, &callback)
+      local    = env.nil?
+      messages = [messages].flatten
+      info('Processing messages: ? (local: ?)', messages, local)
+
+      return callback.call([]) if messages.size == 0
+      processed, responses = 0, []
+
+      gather_replies = lambda do |replies|
+        responses.concat(replies)
+        processed += 1
+        responses.compact!
+        info('Returning replies: ?', responses)
+        callback.call(responses) if processed == messages.size
+      end
+
+      handle_reply = lambda do |replies|
+        extended, expected = 0, replies.size
+        gather_replies.call(replies) if expected == 0
+
+        replies.each_with_index do |reply, i|
+          debug('Processing reply: ?', reply)
+          pipe_through_extensions(:outgoing, reply, env) do |message|
+            replies[i] = message
+            extended  += 1
+            gather_replies.call(replies) if extended == expected
+          end
+        end
+      end
+
+      messages.each do |message|
+        pipe_through_extensions(:incoming, message, env) do |piped_message|
+          handle(piped_message, local, &handle_reply)
+        end
+      end
+    end
+
+    def make_response(message)
+      response = {}
+
+      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
+
+    def handle(message, local = false, &callback)
+      return callback.call([]) if !message
+      info('Handling message: ? (local: ?)', message, local)
+
+      channel_name = message['channel']
+      error        = message['error']
+
+      return handle_meta(message, local, &callback) if Channel.meta?(channel_name)
+
+      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]
+
+      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 { |r| advize(r, message['connectionType']) }
+        callback.call(responses)
+      end
+    end
+
+    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']  ||= interval
+        advice['timeout']   ||= timeout
+      end
+    end
+
+    # MUST contain  * version
+    #               * supportedConnectionTypes
+    # MAY contain   * minimumVersion
+    #               * ext
+    #               * id
+    def handshake(message, local = false, &callback)
+      response = make_response(message)
+      response['version'] = BAYEUX_VERSION
+
+      response['error'] = Error.parameter_missing('version') if message['version'].nil?
+
+      client_conns = message['supportedConnectionTypes']
+
+      response['supportedConnectionTypes'] = CONNECTION_TYPES
+
+      if client_conns
+        common_conns = client_conns.select { |c| CONNECTION_TYPES.include?(c) }
+        response['error'] = Error.conntype_mismatch(*client_conns) if common_conns.empty?
+      else
+        response['error'] = Error.parameter_missing('supportedConnectionTypes')
+      end
+
+      response['successful'] = response['error'].nil?
+      return callback.call(response) unless response['successful']
+
+      @engine.create_client do |client_id|
+        response['clientId'] = client_id
+        callback.call(response)
+      end
+    end
+
+    # MUST contain  * clientId
+    #               * connectionType
+    # MAY contain   * ext
+    #               * id
+    def connect(message, local = false, &callback)
+      response        = make_response(message)
+      client_id       = message['clientId']
+      connection_type = message['connectionType']
+
+      @engine.client_exists(client_id) do |exists|
+        response['error'] = Error.client_unknown(client_id) unless exists
+        response['error'] = Error.parameter_missing('clientId') if client_id.nil?
+
+        unless CONNECTION_TYPES.include?(connection_type)
+          response['error'] = Error.conntype_mismatch(connection_type)
+        end
+
+        response['error'] = Error.parameter_missing('connectionType') if connection_type.nil?
+
+        response['successful'] = response['error'].nil?
+
+        if !response['successful']
+          response.delete('clientId')
+          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
+
+    # MUST contain  * clientId
+    # MAY contain   * ext
+    #               * id
+    def disconnect(message, local = false, &callback)
+      response   = make_response(message)
+      client_id  = message['clientId']
+
+      @engine.client_exists(client_id) do |exists|
+        response['error'] = Error.client_unknown(client_id) unless exists
+        response['error'] = Error.parameter_missing('clientId') if client_id.nil?
+
+        response['successful'] = response['error'].nil?
+        response.delete('clientId') unless response['successful']
+
+        @engine.destroy_client(client_id) if response['successful']
+        callback.call(response)
+      end
+    end
+
+    # MUST contain  * clientId
+    #               * subscription
+    # MAY contain   * ext
+    #               * id
+    def subscribe(message, local = false, &callback)
+      response     = make_response(message)
+      client_id    = message['clientId']
+      subscription = [message['subscription']].flatten
+
+      @engine.client_exists(client_id) do |exists|
+        response['error'] = Error.client_unknown(client_id) unless exists
+        response['error'] = Error.parameter_missing('clientId') if client_id.nil?
+        response['error'] = Error.parameter_missing('subscription') if message['subscription'].nil?
+
+        response['subscription'] = message['subscription'] || []
+
+        subscription.each do |channel|
+          next if response['error']
+          response['error'] = Error.channel_forbidden(channel) unless local or Channel.subscribable?(channel)
+          response['error'] = Error.channel_invalid(channel) unless Channel.valid?(channel)
+
+          next if response['error']
+          @engine.subscribe(client_id, channel)
+        end
+
+        response['successful'] = response['error'].nil?
+        callback.call(response)
+      end
+    end
+
+    # MUST contain  * clientId
+    #               * subscription
+    # MAY contain   * ext
+    #               * id
+    def unsubscribe(message, local = false, &callback)
+      response     = make_response(message)
+      client_id    = message['clientId']
+      subscription = [message['subscription']].flatten
+
+      @engine.client_exists(client_id) do |exists|
+        response['error'] = Error.client_unknown(client_id) unless exists
+        response['error'] = Error.parameter_missing('clientId') if client_id.nil?
+        response['error'] = Error.parameter_missing('subscription') if message['subscription'].nil?
+
+        response['subscription'] = message['subscription'] || []
+
+        subscription.each do |channel|
+          next if response['error']
+          response['error'] = Error.channel_forbidden(channel) unless local or Channel.subscribable?(channel)
+          response['error'] = Error.channel_invalid(channel) unless Channel.valid?(channel)
+
+          next if response['error']
+          @engine.unsubscribe(client_id, channel)
+        end
+
+        response['successful'] = response['error'].nil?
+        callback.call(response)
+      end
+    end
+
+  end
+end

data/lib/faye/protocol/socket.rb

@@ -0,0 +1,24 @@
+module Faye
+  class Server
+
+    class Socket
+      def initialize(server, socket, env)
+        @server = server
+        @socket = socket
+        @env    = env
+      end
+
+      def send(message)
+        @server.pipe_through_extensions(:outgoing, message, @env) do |piped_message|
+          @socket.send(Faye.to_json([piped_message])) if @socket
+        end
+      end
+
+      def close
+        @socket.close if @socket
+        @socket = nil
+      end
+    end
+
+  end
+end

data/lib/faye/protocol/subscription.rb

@@ -0,0 +1,23 @@
+module Faye
+  class Subscription
+    include Deferrable
+
+    def initialize(client, channels, callback)
+      @client    = client
+      @channels  = channels
+      @callback  = callback
+      @cancelled = false
+    end
+
+    def cancel
+      return if @cancelled
+      @client.unsubscribe(@channels, &@callback)
+      @cancelled = true
+    end
+
+    def unsubscribe
+      cancel
+    end
+
+  end
+end