face-faye 0.8.9

data/lib/faye/protocol/publication.rb

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

data/lib/faye/protocol/server.rb

@@ -0,0 +1,293 @@
+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 flush_connection(messages)
+      client_id = Faye.client_id_from_messages(messages)
+      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.new(self, socket))
+    end
+
+    def close_socket(client_id)
+      @engine.flush(client_id)
+    end
+
+    def process(messages, local = false, &callback)
+      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) 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) 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]
+      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 { |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,23 @@
+module Faye
+  class Server
+
+    class Socket
+      def initialize(server, socket)
+        @server = server
+        @socket = socket
+      end
+
+      def send(message)
+        @server.pipe_through_extensions(:outgoing, message) do |piped_message|
+          @socket.send(Faye.to_json([piped_message]))
+        end
+      end
+
+      def close
+        @socket.close
+      end
+    end
+
+  end
+end
+

data/lib/faye/protocol/subscription.rb

@@ -0,0 +1,24 @@
+module Faye
+  class Subscription
+    include EventMachine::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
+

data/lib/faye/transport/http.rb

@@ -0,0 +1,76 @@
+module Faye
+
+  class Transport::Http < Transport
+    def self.usable?(client, endpoint, &callback)
+      callback.call(endpoint.is_a?(String))
+    end
+
+    def request(message, timeout)
+      retry_block = retry_block(message, timeout)
+
+      content = Faye.to_json(message)
+      cookies = @cookies.get_cookies(@endpoint)
+      params  = build_params(URI.parse(@endpoint), content, cookies)
+      request = create_request(params)
+
+      request.callback do
+        handle_response(request.response, retry_block)
+        store_cookies([*request.response_header['SET_COOKIE']].compact)
+      end
+      request.errback do
+        retry_block.call
+        trigger(:down)
+      end
+    end
+
+  private
+
+    def build_params(uri, content, cookies)
+      {
+        :head => {
+          'Content-Length'  => content.bytesize,
+          'Content-Type'    => 'application/json',
+          'Cookie'          => cookies * '; ',
+          'Host'            => uri.host
+        }.merge(@headers),
+
+        :body    => content,
+        :timeout => -1  # for em-http-request < 1.0
+      }
+    end
+
+    def create_request(params)
+      version = EventMachine::HttpRequest::VERSION.split('.')[0].to_i
+      client  = if version >= 1
+                  options = {                 # for em-http-request >= 1.0
+                    :inactivity_timeout => 0  # connection inactivity (post-setup) timeout (0 = disable timeout)
+                  }
+                  EventMachine::HttpRequest.new(@endpoint, options)
+                else
+                  EventMachine::HttpRequest.new(@endpoint)
+                end
+
+      client.post(params)
+    end
+
+    def handle_response(response, retry_block)
+      message = MultiJson.load(response) rescue nil
+      if message
+        receive(message)
+        trigger(:up)
+      else
+        retry_block.call
+        trigger(:down)
+      end
+    end
+
+    def store_cookies(cookies)
+      cookies.each do |cookie|
+        @cookies.set_cookie(@endpoint, cookie)
+      end
+    end
+  end
+
+  Transport.register 'long-polling', Transport::Http
+
+end

data/lib/faye/transport/local.rb

@@ -0,0 +1,22 @@
+module Faye
+
+  class Transport::Local < Transport
+    def self.usable?(client, endpoint, &callback)
+      callback.call(endpoint.is_a?(Server))
+    end
+
+    def batching?
+      false
+    end
+
+    def request(message, timeout)
+      message = Faye.copy_object(message)
+      @endpoint.process(message, true) do |responses|
+        receive(Faye.copy_object(responses))
+      end
+    end
+  end
+
+  Transport.register 'in-process', Transport::Local
+
+end