faye 0.8.11 → 1.0.0

data/lib/faye/mixins/publisher.rb

@@ -1,28 +1,17 @@
 module Faye
   module Publisher
 
-    def count_listeners(event_type)
-      return 0 unless @subscribers and @subscribers[event_type]
-      @subscribers[event_type].size
-    end
-
-    def bind(event_type, &listener)
-      @subscribers ||= {}
-      list = @subscribers[event_type] ||= []
-      list << listener
-    end
+    include ::WebSocket::Driver::EventEmitter
 
-    def unbind(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
+    alias :bind    :add_listener
+    alias :trigger :emit
 
-    def trigger(event_type, *args)
-      return unless @subscribers and @subscribers[event_type]
-      listeners = @subscribers[event_type].dup
-      listeners.each { |listener| listener.call(*args) }
+    def unbind(event, &listener)
+      if listener
+        remove_listener(event, &listener)
+      else
+        remove_all_listeners(event)
+      end
     end
 
   end

data/lib/faye/protocol/channel.rb

@@ -5,6 +5,7 @@ module Faye
     attr_reader :name
 
     def initialize(name)
+      super()
       @name = name
     end
 
@@ -13,7 +14,7 @@ module Faye
     end
 
     def unused?
-      count_listeners(:message).zero?
+      listener_count(:message).zero?
     end
 
     HANDSHAKE   = '/meta/handshake'

data/lib/faye/protocol/client.rb

@@ -1,7 +1,7 @@
 module Faye
   class Client
 
-    include EventMachine::Deferrable
+    include Deferrable
     include Publisher
     include Logging
     include Extensible
@@ -17,14 +17,16 @@ module Faye
 
     CONNECTION_TIMEOUT  = 60.0
     DEFAULT_RETRY       = 5.0
+    MAX_REQUEST_SIZE    = 2048
 
-    attr_reader :client_id, :endpoint, :endpoints, :retry, :transports
+    attr_reader :cookies, :endpoint, :endpoints, :headers, :max_request_size, :retry, :transports
 
     def initialize(endpoint = nil, options = {})
+      super()
       info('New client created for ?', endpoint)
 
       @options    = options
-      @endpoint   = endpoint || RackAdapter::DEFAULT_ENDPOINT
+      @endpoint   = Faye.parse_url(endpoint || RackAdapter::DEFAULT_ENDPOINT)
       @endpoints  = @options[:endpoints] || {}
       @transports = {}
       @cookies    = CookieJar::Jar.new
@@ -32,6 +34,12 @@ module Faye
       @disabled   = []
       @retry      = @options[:retry] || DEFAULT_RETRY
 
+      @endpoints.each do |key, value|
+        @endpoints[key] = Faye.parse_url(value)
+      end
+
+      @max_request_size = MAX_REQUEST_SIZE
+
       @state      = UNCONNECTED
       @channels   = Channel::Set.new
       @message_id = 0
@@ -53,15 +61,6 @@ module Faye
       @headers[name.to_s] = value.to_s
     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
@@ -91,9 +90,9 @@ module Faye
       select_transport(MANDATORY_CONNECTION_TYPES)
 
       send({
-        'channel'     => Channel::HANDSHAKE,
-        'version'     => BAYEUX_VERSION,
-        'supportedConnectionTypes' => [@transport.connection_type]
+        'channel'                   => Channel::HANDSHAKE,
+        'version'                   => BAYEUX_VERSION,
+        'supportedConnectionTypes'  => [@transport.connection_type]
 
       }) do |response|
 
@@ -136,7 +135,7 @@ module Faye
 
       info('Calling deferred actions for ?', @client_id)
       set_deferred_status(:succeeded)
-      set_deferred_status(:deferred)
+      set_deferred_status(:unknown)
 
       return unless @connect_request.nil?
       @connect_request = true
@@ -275,6 +274,7 @@ module Faye
           'channel'   => channel,
           'data'      => data,
           'clientId'  => @client_id
+
         }) do |response|
           if response['successful']
             publication.set_deferred_status(:succeeded)
@@ -287,20 +287,40 @@ module Faye
     end
 
     def receive_message(message)
-      pipe_through_extensions(:incoming, message) do |message|
+      id = message['id']
+
+      if message.has_key?('successful')
+        callback = @response_callbacks.delete(id)
+      end
+
+      pipe_through_extensions(:incoming, message, nil) do |message|
         next unless message
 
         handle_advice(message['advice']) if message['advice']
         deliver_message(message)
 
-        next unless message.has_key?('successful')
+        callback.call(message) if callback
+      end
+
+      return if @transport_up == true
+      @transport_up = true
+      trigger('transport:up')
+    end
 
-        callback = @response_callbacks[message['id']]
-        next unless callback
+    def message_error(messages, immediate = false)
+      messages.each do |message|
+        id = message['id']
 
-        @response_callbacks.delete(message['id'])
-        callback.call(message)
+        if immediate
+          transport_send(message)
+        else
+          EventMachine.add_timer(@retry) { transport_send(message) }
+        end
       end
+
+      return if immediate or @transport_up == false
+      @transport_up = false
+      trigger('transport:down')
     end
 
   private
@@ -309,35 +329,40 @@ module Faye
       Transport.get(self, transport_types, @disabled) do |transport|
         debug('Selected ? transport for ?', transport.connection_type, transport.endpoint)
 
-        @transport = transport
-        @transport.cookies = @cookies
-        @transport.headers = @headers
-
-        transport.bind :down do
-          if @transport_up.nil? or @transport_up
-            @transport_up = false
-            trigger('transport:down')
-          end
-        end
+        next if transport == @transport
+        @transport.close if @transport
 
-        transport.bind :up do
-          if @transport_up.nil? or not @transport_up
-            @transport_up = true
-            trigger('transport:up')
-          end
-        end
+        @transport = transport
       end
     end
 
     def send(message, &callback)
+      return unless @transport
       message['id'] = generate_message_id
-      @response_callbacks[message['id']] = callback if callback
 
-      pipe_through_extensions(:outgoing, message) do |message|
-        @transport.send(message, @advice['timeout'] / 1000.0) if message
+      pipe_through_extensions(:outgoing, message, nil) do |message|
+        next unless message
+        @response_callbacks[message['id']] = callback if callback
+        transport_send(message)
       end
     end
 
+    def transport_send(message)
+      return unless @transport
+
+      timeout = [nil, 0].include?(@advice['timeout']) ?
+                1.2 * @retry :
+                1.2 * @advice['timeout'] / 1000.0
+
+      envelope = Envelope.new(message, timeout)
+
+      envelope.errback do |immediate|
+        message_error([message], immediate)
+      end
+
+      @transport.send(envelope)
+    end
+
     def generate_message_id
       @message_id += 1
       @message_id = 0 if @message_id >= 2**32
@@ -360,14 +385,11 @@ module Faye
       @channels.distribute_message(message)
     end
 
-    def teardown_connection
-      return unless @connect_request
-      @connect_request = nil
-      info('Closed connection for ?', @client_id)
-    end
-
     def cycle_connection
-      teardown_connection
+      if @connect_request
+        @connect_request = nil
+        info('Closed connection for ?', @client_id)
+      end
       EventMachine.add_timer(@advice['interval'] / 1000.0) { connect }
     end
 

data/lib/faye/protocol/envelope.rb

@@ -0,0 +1,24 @@
+module Faye
+  class Envelope
+
+    include Deferrable
+    attr_reader :id, :message
+
+    def initialize(message, timeout = nil)
+      @id      = message['id']
+      @message = message
+      
+      self.timeout(timeout, false) if timeout
+    end
+
+    def eql?(other)
+      Envelope === other and @id == other.id
+    end
+
+    def hash
+      @id.hash
+    end
+
+  end
+end
+

data/lib/faye/protocol/extensible.rb

@@ -17,7 +17,7 @@ module Faye
       end
     end
 
-    def pipe_through_extensions(stage, message, &callback)
+    def pipe_through_extensions(stage, message, env, &callback)
       debug 'Passing through ? extensions: ?', stage, message
 
       return callback.call(message) unless @extensions
@@ -29,10 +29,13 @@ module Faye
         extension = extensions.shift
         next callback.call(message) unless extension
 
-        if extension.respond_to?(stage)
-          extension.__send__(stage, message, pipe)
+        next pipe.call(message) unless extension.respond_to?(stage)
+
+        arity = extension.method(stage).arity
+        if arity >= 3
+          extension.__send__(stage, message, env, pipe)
         else
-          pipe.call(message)
+          extension.__send__(stage, message, pipe)
         end
       end
       pipe.call(message)

data/lib/faye/protocol/publication.rb

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

data/lib/faye/protocol/server.rb

@@ -19,21 +19,17 @@ module Faye
       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))
+    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)
       @engine.flush(client_id)
     end
 
-    def process(messages, local = false, &callback)
+    def process(messages, env, &callback)
+      local    = env.nil?
       messages = [messages].flatten
       info 'Processing messages: ? (local: ?)', messages, local
 
@@ -54,7 +50,7 @@ module Faye
 
         replies.each_with_index do |reply, i|
           debug 'Processing reply: ?', reply
-          pipe_through_extensions(:outgoing, reply) do |message|
+          pipe_through_extensions(:outgoing, reply, env) do |message|
             replies[i] = message
             extended  += 1
             gather_replies.call(replies) if extended == expected
@@ -63,7 +59,7 @@ module Faye
       end
 
       messages.each do |message|
-        pipe_through_extensions(:incoming, message) do |piped_message|
+        pipe_through_extensions(:incoming, message, env) do |piped_message|
           handle(piped_message, local, &handle_reply)
         end
       end
@@ -94,6 +90,7 @@ module Faye
         error = Faye::Error.channel_invalid(channel_name)
       end
 
+      message.delete('clientId')
       @engine.publish(message) unless error
 
       response = make_response(message)

data/lib/faye/protocol/socket.rb

@@ -2,19 +2,21 @@ module Faye
   class Server
 
     class Socket
-      def initialize(server, socket)
+      def initialize(server, socket, env)
         @server = server
         @socket = socket
+        @env    = env
       end
 
       def send(message)
-        @server.pipe_through_extensions(:outgoing, message) do |piped_message|
-          @socket.send(Faye.to_json([piped_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
+        @socket.close if @socket
+        @socket = nil
       end
     end
 

data/lib/faye/protocol/subscription.rb

@@ -1,6 +1,6 @@
 module Faye
   class Subscription
-    include EventMachine::Deferrable
+    include Deferrable
 
     def initialize(client, channels, callback)
       @client    = client

data/lib/faye/transport/http.rb

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