faye 0.6.8 → 0.7.0

data/lib/faye/protocol/channel.rb

@@ -9,11 +9,11 @@ module Faye
     end
     
     def <<(message)
-      publish_event(:message, message)
+      trigger(:message, message)
     end
     
     def unused?
-      count_subscribers(:message).zero?
+      count_listeners(:message).zero?
     end
     
     HANDSHAKE   = '/meta/handshake'
@@ -22,8 +22,8 @@ module Faye
     UNSUBSCRIBE = '/meta/unsubscribe'
     DISCONNECT  = '/meta/disconnect'
     
-    META        = 'meta'
-    SERVICE     = 'service'
+    META        = :meta
+    SERVICE     = :service
     
     class << self
       def expand(name)
@@ -50,7 +50,7 @@ module Faye
       
       def parse(name)
         return nil unless valid?(name)
-        name.split('/')[1..-1]
+        name.split('/')[1..-1].map { |s| s.to_sym }
       end
       
       def unparse(segments)
@@ -94,14 +94,14 @@ module Faye
         return unless callback
         names.each do |name|
           channel = @channels[name] ||= Channel.new(name)
-          channel.add_subscriber(:message, callback)
+          channel.bind(:message, &callback)
         end
       end
       
       def unsubscribe(name, callback)
         channel = @channels[name]
         return false unless channel
-        channel.remove_subscriber(:message, callback)
+        channel.unbind(:message, &callback)
         if channel.unused?
           remove(name)
           true
@@ -114,7 +114,7 @@ module Faye
         channels = Channel.expand(message['channel'])
         channels.each do |name|
           channel = @channels[name]
-          channel.publish_event(:message, message['data']) if channel
+          channel.trigger(:message, message['data']) if channel
         end
       end
     end

data/lib/faye/protocol/client.rb

@@ -2,6 +2,7 @@ module Faye
   class Client
     
     include EventMachine::Deferrable
+    include Publisher
     include Logging
     include Extensible
     
@@ -16,6 +17,7 @@ module Faye
     
     CONNECTION_TIMEOUT  = 60.0
     
+    attr_accessor :cookies
     attr_reader :endpoint, :client_id
     
     def initialize(endpoint = nil, options = {})
@@ -23,8 +25,10 @@ module Faye
       
       @endpoint   = endpoint || RackAdapter::DEFAULT_ENDPOINT
       @options    = options
+      @disabled   = []
 
-      @transport  = Transport.get(self, MANDATORY_CONNECTION_TYPES)
+      select_transport(MANDATORY_CONNECTION_TYPES)
+      
       @state      = UNCONNECTED
       @channels   = Channel::Set.new
       @message_id = 0
@@ -38,6 +42,10 @@ module Faye
       }
     end
     
+    def disable(feature)
+      @disabled << feature
+    end
+    
     def state
       case @state
       when UNCONNECTED  then :UNCONNECTED
@@ -84,7 +92,9 @@ module Faye
         if response['successful']
           @state     = CONNECTED
           @client_id = response['clientId']
-          @transport = Transport.get(self, response['supportedConnectionTypes'])
+          
+          connection_types = response['supportedConnectionTypes'] - @disabled
+          select_transport(connection_types)
           
           info('Handshake successful: ?', @client_id)
           
@@ -152,7 +162,10 @@ module Faye
       send({
         'channel'   => Channel::DISCONNECT,
         'clientId'  => @client_id
-      })
+        
+      }) do |response|
+        @transport.close if response['successful']
+      end
       
       info('Clearing channel listeners for ?', @client_id)
       @channels = Channel::Set.new
@@ -256,6 +269,7 @@ module Faye
         raise "Cannot publish: '#{channel}' is not a valid channel name"
       end
       
+      publication = Publication.new
       connect {
         info('Client ? queueing published message to ?: ?', @client_id, channel, data)
         
@@ -263,8 +277,15 @@ module Faye
           'channel'   => channel,
           'data'      => data,
           'clientId'  => @client_id
-        })
+        }) do |response|
+          if response['successful']
+            publication.set_deferred_status(:succeeded)
+          else
+            publication.set_deferred_status(:failed, Error.parse(response['error']))
+          end
+        end
       }
+      publication
     end
     
     def receive_message(message)
@@ -285,6 +306,26 @@ module Faye
     
   private
     
+    def select_transport(transport_types)
+      Transport.get(self, transport_types) do |transport|
+        @transport = transport
+        
+        transport.bind :down do
+          if @transport_up.nil? or @transport_up
+            @transport_up = false
+            trigger('transport:down')
+          end
+        end
+        
+        transport.bind :up do
+          if @transport_up.nil? or not @transport_up
+            @transport_up = true
+            trigger('transport:up')
+          end
+        end
+      end
+    end
+    
     def send(message, &callback)
       message['id'] = generate_message_id
       @response_callbacks[message['id']] = callback if callback

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

@@ -3,9 +3,9 @@ module Faye
     
     include Logging
     include Extensible
-
-    META_METHODS = %w[handshake connect disconnect subscribe unsubscribe]
     
+    attr_reader :engine
+
     def initialize(options = {})
       @options    = options || {}
       engine_opts = @options[:engine] || {}
@@ -91,14 +91,7 @@ module Faye
     
     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(&method(:advize))
@@ -132,15 +125,13 @@ module Faye
       
       client_conns = message['supportedConnectionTypes']
       
-      unless local
-        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['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?

data/lib/faye/thin_extensions.rb

@@ -34,6 +34,7 @@ class Thin::Connection
     else
       if @request.parse(data)
         if @request.websocket?
+          @request.env['em.connection'] = self
           @response.persistent!
           @response.websocket = true
           @serving = :websocket
@@ -51,7 +52,6 @@ end
 
 class Thin::Request
   WEBSOCKET_RECEIVE_CALLBACK = 'websocket.receive_callback'.freeze
-
   def websocket?
     @env['HTTP_CONNECTION'] and
     @env['HTTP_CONNECTION'].split(/\s*,\s*/).include?('Upgrade') and

data/lib/faye/transport/http.rb

@@ -1,22 +1,23 @@
-require 'em-http'
-require 'em-http/version'
-
 module Faye
   
   class Transport::Http < Transport
-    def self.usable?(endpoint)
-      endpoint.is_a?(String)
+    def self.usable?(endpoint, &callback)
+      callback.call(endpoint.is_a?(String))
     end
     
     def request(message, timeout)
       retry_block = retry_block(message, timeout)
       
+      @client.cookies ||= CookieJar::Jar.new
+      cookies = @client.cookies.get_cookies(@endpoint)
+      
       content = JSON.unparse(message)
       params = {
         :head => {
+          'Content-Length'  => content.length,
           'Content-Type'    => 'application/json',
-          'host'            => URI.parse(@endpoint).host,
-          'Content-Length'  => content.length
+          'Cookie'          => cookies * '; ',
+          'Host'            => URI.parse(@endpoint).host
         },
         :body    => content,
         :timeout => -1  # for em-http-request < 1.0
@@ -31,12 +32,20 @@ module Faye
       end
       request.callback do
         begin
+          cookies = [*request.response_header['SET_COOKIE']]
+          cookies.each do |cookie|
+            @client.cookies.set_cookie(@endpoint, cookie)
+          end
           receive(JSON.parse(request.response))
+          trigger(:up)
         rescue
           retry_block.call
         end
       end
-      request.errback { retry_block.call }
+      request.errback do
+        retry_block.call
+        trigger(:down)
+      end
     end
   end
   

data/lib/faye/transport/local.rb

@@ -1,8 +1,8 @@
 module Faye
   
   class Transport::Local < Transport
-    def self.usable?(endpoint)
-      endpoint.is_a?(Server)
+    def self.usable?(endpoint, &callback)
+      callback.call(endpoint.is_a?(Server))
     end
     
     def batching?
@@ -10,7 +10,10 @@ module Faye
     end
     
     def request(message, timeout)
-      @endpoint.process(message, true) { |responses| receive(responses) }
+      message = Faye.copy_object(message)
+      @endpoint.process(message, true) do |responses|
+        receive(Faye.copy_object(responses))
+      end
     end
   end
   

data/lib/faye/transport/transport.rb

@@ -1,10 +1,8 @@
-require 'json'
-require 'uri'
-
 module Faye
   class Transport
     
     include Logging
+    include Publisher
     include Timeouts
     
     def initialize(client, endpoint)
@@ -18,6 +16,9 @@ module Faye
       true
     end
     
+    def close
+    end
+    
     def connection_type
       self.class.connection_type
     end
@@ -68,20 +69,29 @@ module Faye
     class << self
       attr_accessor :connection_type
       
-      def get(client, connection_types = nil)
+      def get(client, connection_types = nil, &callback)
         endpoint = client.endpoint
         connection_types ||= supported_connection_types
         
-        candidate_class = @transports.find do |(type, klass)|
-          connection_types.include?(type) and
-          klass.usable?(endpoint)
+        select = lambda do |(conn_type, klass), resume|
+          if connection_types.include?(conn_type)
+            klass.usable?(endpoint) do |is_usable|
+              if is_usable
+                callback.call(klass.new(client, endpoint))
+              else
+                resume.call
+              end
+            end
+          else
+            resume.call
+          end
         end
         
-        unless candidate_class
+        error = lambda do
           raise "Could not find a usable connection type for #{ endpoint }"
         end
         
-        candidate_class.last.new(client, endpoint)
+        Faye.async_each(@transports, select, error)
       end
       
       def register(type, klass)
@@ -94,6 +104,10 @@ module Faye
       end
     end
     
+    %w[local web_socket http].each do |type|
+      require File.join(ROOT, 'faye', 'transport', type)
+    end
+    
   end
 end
 

data/lib/faye/transport/web_socket.rb

@@ -0,0 +1,102 @@
+module Faye
+  
+  class Transport::WebSocket < Transport
+    WEBSOCKET_TIMEOUT = 1
+    
+    UNCONNECTED       = 1
+    CONNECTING        = 2
+    CONNECTED         = 3
+    
+    include EventMachine::Deferrable
+    
+    def self.usable?(endpoint, &callback)
+      connected  = false
+      called     = false
+      socket_url = endpoint.gsub(/^http(s?):/, 'ws\1:')
+      socket     = Faye::WebSocket::Client.new(socket_url)
+      
+      socket.onopen = lambda do |event|
+        connected = true
+        socket.close
+        callback.call(true)
+        called = true
+        socket = nil
+      end
+      
+      notconnected = lambda do |*args|
+        callback.call(false) unless called or connected
+        called = true
+      end
+      
+      socket.onclose = socket.onerror = notconnected
+      EventMachine.add_timer(WEBSOCKET_TIMEOUT, &notconnected)
+    end
+    
+    def batching?
+      false
+    end
+    
+    def request(messages, timeout = nil)
+      @timeout    = timeout || @timeout
+      @messages ||= {}
+      messages.each { |message| @messages[message['id']] = message }
+      with_socket { |socket| socket.send(JSON.unparse(messages)) }
+    end
+    
+    def with_socket(&resume)
+      callback(&resume)
+      connect
+    end
+    
+    def close
+      return if @closed
+      @closed = true
+      @socket.close if @socket
+    end
+    
+    def connect
+      return if @closed
+      
+      @state ||= UNCONNECTED
+      return unless @state == UNCONNECTED
+      
+      @state = CONNECTING
+      
+      @socket = Faye::WebSocket::Client.new(@endpoint.gsub(/^http(s?):/, 'ws\1:'))
+      
+      @socket.onopen = lambda do |*args|
+        @state = CONNECTED
+        set_deferred_status(:succeeded, @socket)
+        trigger(:up)
+      end
+      
+      @socket.onmessage = lambda do |event|
+        messages = [JSON.parse(event.data)].flatten
+        messages.each { |message| @messages.delete(message['id']) }
+        receive(messages)
+      end
+      
+      @socket.onclose = lambda do |*args|
+        was_connected = (@state == CONNECTED)
+        set_deferred_status(:deferred)
+        @state = UNCONNECTED
+        @socket = nil
+        
+        if was_connected
+          resend
+        else
+          EventMachine.add_timer(@timeout) { connect }
+          @timeout = @timeout * 2
+          trigger(:down)
+        end
+      end
+    end
+    
+    def resend
+      request(@messages.values)
+    end
+  end
+  
+  Transport.register 'websocket', Transport::WebSocket
+  
+end