faye 0.3.4 → 0.5.0

data/lib/faye/{connection.rb → protocol/connection.rb}

@@ -1,42 +1,54 @@
 module Faye
   class Connection
     include EventMachine::Deferrable
-    include Observable
+    include Publisher
     include Timeouts
     
     MAX_DELAY = 0.1
-    INTERVAL  = 1.0
+    INTERVAL  = 0.0
     TIMEOUT   = 60.0
     
-    attr_reader :id   
+    attr_reader :id, :interval, :timeout
     
     def initialize(id, options = {})
       @id        = id
       @options   = options
+      @interval  = @options[:interval] || INTERVAL
       @timeout   = @options[:timeout] || TIMEOUT
       @channels  = Set.new
       @inbox     = Set.new
       @connected = false
+      
+      begin_deletion_timeout
     end
     
-    def update(message, event)
-      return unless message == :message
-      @inbox.add(event)
-      begin_delivery_timeout!
+    def socket=(socket)
+      @connected = true
+      @socket    = socket
+    end
+    
+    def on_message(event)
+      return unless @inbox.add?(event)
+      @socket.send(JSON.unparse(event)) if @socket
+      begin_delivery_timeout
     end
     
     def subscribe(channel)
-      channel.add_observer(self) if @channels.add?(channel)
+      return unless @channels.add?(channel)
+      channel.add_subscriber(:message, method(:on_message))
     end
     
     def unsubscribe(channel)
       return @channels.each(&method(:unsubscribe)) if channel == :all
       return unless @channels.member?(channel)
       @channels.delete(channel)
-      channel.delete_observer(self)
+      channel.remove_subscriber(:message, method(:on_message))
     end
     
-    def connect(&block)
+    def connect(options, &block)
+      options = options || {}
+      timeout = options['timeout'] ? options['timeout'] / 1000.0 : @timeout
+      
       set_deferred_status(:deferred)
       
       callback(&block)
@@ -45,8 +57,8 @@ module Faye
       @connected = true
       remove_timeout(:deletion)
       
-      begin_delivery_timeout!
-      begin_connection_timeout!
+      begin_delivery_timeout
+      begin_connection_timeout(timeout)
     end
     
     def flush!
@@ -67,24 +79,30 @@ module Faye
     
   private
     
-    def begin_delivery_timeout!
+    def release_connection!
+      return if @socket
+      
+      remove_timeout(:connection)
+      remove_timeout(:delivery)
+      @connected = false
+      
+      begin_deletion_timeout
+    end
+    
+    def begin_delivery_timeout
       return unless @connected and not @inbox.empty?
       add_timeout(:delivery, MAX_DELAY) { flush! }
     end
     
-    def begin_connection_timeout!
+    def begin_connection_timeout(timeout)
       return unless @connected
-      add_timeout(:connection, @timeout) { flush! }
+      add_timeout(:connection, timeout) { flush! }
     end
     
-    def release_connection!
-      remove_timeout(:connection)
-      remove_timeout(:delivery)
-      @connected = false
-      
-      add_timeout(:deletion, 10 * INTERVAL) do
-        changed(true)
-        notify_observers(:stale_connection, self)
+    def begin_deletion_timeout
+      return if @connected
+      add_timeout(:deletion, TIMEOUT + 10 * @timeout) do
+        publish_event(:stale_connection, self)
       end
     end
     

data/lib/faye/protocol/extensible.rb

@@ -0,0 +1,47 @@
+module Faye
+  module Extensible
+    
+    def add_extension(extension)
+      @extensions ||= []
+      @extensions << extension
+      extension.added if extension.respond_to?(:added)
+    end
+    
+    def remove_extension(extension)
+      return unless @extensions
+      @extensions.delete_if do |ext|
+        if ext == extension
+          extension.removed if extension.respond_to?(:removed)
+          true
+        else
+          false
+        end
+      end
+    end
+    
+    def pipe_through_extensions(stage, message, &callback)
+      return callback.call(message) unless @extensions
+      extensions = @extensions.dup
+      
+      pipe = lambda do |message|
+        if !message
+          callback.call(message)
+        else
+          extension = extensions.shift
+          if (!extension)
+            callback.call(message)
+          else
+            if extension.respond_to?(stage)
+              extension.__send__(stage, message, pipe)
+            else
+              pipe.call(message)
+            end
+          end
+        end
+      end
+      pipe.call(message)
+    end
+    
+  end
+end
+

data/lib/faye/{server.rb → protocol/server.rb}

@@ -2,6 +2,7 @@ module Faye
   class Server
     
     include Logging
+    include Extensible
     
     def initialize(options = {})
       info('New server created')
@@ -11,28 +12,41 @@ module Faye
       @namespace   = Namespace.new
     end
     
-    # Notifies the server of stale connections that should be deleted
-    def update(message, connection)
-      return unless message == :stale_connection
-      destroy_connection(connection)
-    end
-    
     def client_ids
       @connections.keys
     end
     
-    def process(messages, local = false, &callback)
+    def process(messages, local_or_remote = false, &callback)
+      socket = local_or_remote.is_a?(WebSocket) ? local_or_remote : nil
+      local  = (local_or_remote == true)
+      
       debug('Processing messages from ? client', local ? 'LOCAL' : 'REMOTE')
       
       messages = [messages].flatten
       processed, responses = 0, []
       
+      gather_replies = lambda do |replies|
+        responses.concat(replies)
+        processed += 1
+        callback.call(responses.compact) 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|
+          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|
-        handle(message, local) do |reply|
-          reply = [reply].flatten
-          responses.concat(reply)
-          processed += 1
-          callback[responses] if processed == messages.size
+        pipe_through_extensions(:incoming, message) do |piped_message|
+          handle(piped_message, socket, local, &handle_reply)
         end
       end
     end
@@ -49,59 +63,93 @@ module Faye
     def connection(id)
       return @connections[id] if @connections.has_key?(id)
       connection = Connection.new(id, @options)
-      connection.add_observer(self)
+      connection.add_subscriber(:stale_connection, method(:destroy_connection))
       @connections[id] = connection
     end
     
     def destroy_connection(connection)
       connection.disconnect!
-      connection.delete_observer(self)
+      connection.remove_subscriber(:stale_connection, method(:destroy_connection))
       @connections.delete(connection.id)
     end
     
-    def handle(message, local = false, &callback)
-      channel_name = message['channel']
-      
-      @channels.glob(channel_name).each do |channel|
+    def make_response(message)
+      response = {}
+      %w[id clientId channel error].each do |field|
+        if message[field]
+          response[field] = message[field]
+        end
+      end
+      response['successful'] = !response['error']
+      response
+    end
+    
+    def distribute_message(message)
+      @channels.glob(message['channel']).each do |channel|
         channel << message
         info('Publishing message ? from client ? to ?', message['data'], message['clientId'], channel.name)
       end
+    end
+    
+    def handle(message, socket = nil, local = false, &callback)
+      return callback.call([]) if !message
+      return callback.call([make_response(message)]) if message['error']
+      
+      distribute_message(message)
+      channel_name = message['channel']
       
       if Channel.meta?(channel_name)
-        response = __send__(Channel.parse(channel_name)[1], message, local)
-        
-        client_id = response['clientId']
-        response['advice'] ||= {}
-        response['advice']['reconnect'] ||= @connections.has_key?(client_id) ? 'retry' : 'handshake'
-        response['advice']['interval']  ||= (Connection::INTERVAL * 1000).floor
-        
-        return callback.call(response) unless response['channel'] == Channel::CONNECT and
-                                              response['successful'] == true
-        
-        info('Accepting connection from ?', response['clientId'])
-        
-        return connection(response['clientId']).connect do |events|
-          info('Sending event messages to ?', response['clientId'])
-          debug('Events for ?: ?', response['clientId'], events)
-          callback.call([response] + events)
-        end
+        handle_meta(message, socket, local, &callback)
+      elsif message['clientId'].nil?
+        callback.call([])
+      else
+        response = make_response(message)
+        response['successful'] = true
+        callback.call([response])
       end
+    end
+    
+    def handle_meta(message, socket, local, &callback)
+      response = __send__(Channel.parse(message['channel'])[1], message, local)
       
-      return callback.call([]) if message['clientId'].nil? or Channel.service?(channel_name)
+      advize(response)
       
-      response = make_response(message)
-      response['successful'] = true
-      callback.call(response)
+      if response['channel'] == Channel::CONNECT and response['successful'] == true
+        return accept_connection(message['advice'], response, socket, &callback)
+      end
+      
+      callback.call([response])
     end
     
-    def make_response(message)
-      response = {}
-      %w[id clientId channel].each do |field|
-        if message[field]
-          response[field] = message[field]
-        end
+    def accept_connection(options, response, socket, &callback)
+      info('Accepting connection from ?', response['clientId'])
+      
+      connection = connection(response['clientId'])
+      
+      # Disabled because CometD doesn't like messages not being
+      # delivered as part of a /meta/* response
+      # if socket
+      #   return connection.socket = socket
+      # end
+      
+      connection.connect(options) do |events|
+        info('Sending event messages to ?', response['clientId'])
+        debug('Events for ?: ?', response['clientId'], events)
+        callback.call([response] + events)
+      end
+    end
+    
+    def advize(response)
+      connection = @connections[response['clientId']]
+      
+      advice = response['advice'] ||= {}
+      if connection
+        advice['reconnect'] ||= 'retry'
+        advice['interval']  ||= (connection.interval * 1000).floor
+        advice['timeout']   ||= (connection.timeout * 1000).floor
+      else
+        advice['reconnect'] ||= 'handshake'
       end
-      response
     end
     
     # MUST contain  * version
@@ -142,7 +190,7 @@ module Faye
     # MAY contain   * ext
     #               * id
     def connect(message, local = false)
-      response  = make_response(message)
+      response   = make_response(message)
       
       client_id  = message['clientId']
       connection = client_id ? @connections[client_id] : nil
@@ -164,7 +212,7 @@ module Faye
     # MAY contain   * ext
     #               * id
     def disconnect(message, local = false)
-      response  = make_response(message)
+      response   = make_response(message)
       
       client_id  = message['clientId']
       connection = client_id ? @connections[client_id] : nil
@@ -192,9 +240,7 @@ module Faye
       
       client_id     = message['clientId']
       connection    = client_id ? @connections[client_id] : nil
-      
-      subscription  = message['subscription']
-      subscription  = [subscription].flatten
+      subscription  = [message['subscription']].flatten
       
       response['error'] = Error.client_unknown(client_id) if connection.nil?
       response['error'] = Error.parameter_missing('clientId') if client_id.nil?
@@ -227,9 +273,7 @@ module Faye
       
       client_id     = message['clientId']
       connection    = client_id ? @connections[client_id] : nil
-      
-      subscription  = message['subscription']
-      subscription  = [subscription].flatten
+      subscription  = [message['subscription']].flatten
       
       response['error'] = Error.client_unknown(client_id) if connection.nil?
       response['error'] = Error.parameter_missing('clientId') if client_id.nil?

data/lib/faye/protocol/subscription.rb

@@ -0,0 +1,23 @@
+module Faye
+  class Subscription
+    
+    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/util/web_socket.rb

@@ -0,0 +1,119 @@
+module Faye
+  class WebSocket
+    
+    include Publisher
+    
+    CONNECTING = 0
+    OPEN       = 1
+    CLOSING    = 2
+    CLOSED     = 3
+    
+    attr_reader   :url, :ready_state, :buffered_amount
+    attr_accessor :onopen, :onmessage, :onerror, :onclose
+    
+    def initialize(request)
+      @request  = request
+      @callback = @request.env['async.callback']
+      @stream   = Stream.new
+      @callback.call [200, RackAdapter::TYPE_JSON, @stream]
+      
+      @url = @request.env['websocket.url']
+      @ready_state = OPEN
+      @buffered_amount = 0
+      
+      event = Event.new
+      event.init_event('open', false, false)
+      dispatch_event(event)
+      
+      @buffer = []
+      @buffering = false
+      
+      @request.env[Thin::Request::WEBSOCKET_RECEIVE_CALLBACK] = lambda do |data|
+        data.each_char(&method(:handle_char))
+      end
+    end
+    
+    def send(data)
+      @stream.write("\x00#{ data }\xFF")
+    end
+    
+    def close
+    end
+    
+    def add_event_listener(type, listener, use_capture)
+      add_subscriber(type, listener)
+    end
+    
+    def remove_event_listener(type, listener, use_capture)
+      remove_subscriber(type, listener)
+    end
+    
+    def dispatch_event(event)
+      event.target = event.current_target = self
+      event.event_phase = Event::AT_TARGET
+      
+      publish_event(event.type, event)
+      callback = __send__("on#{ event.type }")
+      callback.call(event) if callback
+    end
+    
+  private
+    
+    def handle_char(data)
+      case data
+        when "\x00" then
+          @buffering = true
+          
+        when "\xFF" then
+          event = Event.new
+          event.init_event('message', false, false)
+          event.data = @buffer.join('')
+          
+          dispatch_event(event)
+          
+          @buffer = []
+          @buffering = false
+          
+        else
+          @buffer.push(data) if @buffering
+      end
+    end
+    
+  end
+  
+  class WebSocket::Stream
+    include EventMachine::Deferrable
+    
+    def each(&callback)
+      @data_callback = callback
+    end
+    
+    def write(data)
+      return unless @data_callback
+      @data_callback.call(data)
+    end
+  end
+  
+  class WebSocket::Event
+    attr_reader   :type, :bubbles, :cancelable
+    attr_accessor :target, :current_target, :event_phase, :data
+    
+    CAPTURING_PHASE = 1
+    AT_TARGET       = 2
+    BUBBLING_PHASE  = 3
+    
+    def init_event(event_type, can_bubble, cancelable)
+      @type       = event_type
+      @bubbles    = can_bubble
+      @cancelable = cancelable
+    end
+    
+    def stop_propagation
+    end
+    
+    def prevent_default
+    end
+  end
+  
+end
+