websocket-rails 0.5.0 → 0.6.0

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # WebsocketRails Change Log
 
+## Version 0.6.0
+
+September 3 2013
+
+* Added the UserManager accessible through the `WebsocketRails.users`
+method. This allows for triggering events on individual logged in users
+from anywhere inside of your application without the need to create a
+channel for that user.
+
 ## Version 0.5.0
 
 September 2 2013
@@ -8,13 +17,13 @@ September 2 2013
 shcheme. - Thanks to @depili
 * Override ConnectionManager#inspect to clean up the output from `rake
 routes`
-* Add a basic Global UserManager for triggering events on specific users
+* Added a basic Global UserManager for triggering events on specific users
 from anywhere inside your app without creating a dedicated user channel.
 * Deprecate the old controller observer system and implement full Rails
 AbstractController::Callbacks support. - Thanks to @pitr
 * Reload the events.rb event route file each time an event is fired. -
 Thanks to @moaa
-* Separate the event route file and WebsocketRails configuration files.
+* Separated the event route file and WebsocketRails configuration files.
 The events.rb now lives in `config/events.rb`. The configuration should
 remain in an initializer located at `config/initializers/websocket_rails.rb`. - Thanks to @moaa
 

data/lib/generators/websocket_rails/install/templates/websocket_rails.rb

@@ -38,4 +38,11 @@ WebsocketRails.setup do |config|
   # if one exists. If `current_user` does not exist or does not
   # respond to the identifier, the key will default to `connection.id`
   # config.user_identifier = :id
+
+  # Uncomment and change this option to override the class associated
+  # with your `current_user` object. This class will be used when
+  # synchronization is enabled and you trigger events from background
+  # jobs using the WebsocketRails.users UserManager.
+  # config.user_class = User
+
 end

data/lib/websocket_rails/configuration.rb

@@ -9,6 +9,14 @@ module WebsocketRails
       @user_identifier = identifier
     end
 
+    def user_class
+      @user_class ||= User
+    end
+
+    def user_class=(klass)
+      @user_class = klass
+    end
+
     def keep_subscribers_when_private?
       @keep_subscribers_when_private ||= false
     end

data/lib/websocket_rails/connection_adapters.rb

@@ -10,7 +10,7 @@ module WebsocketRails
     end
 
     def self.establish_connection(request, dispatcher)
-      adapter = adapters.detect { |a| a.accepts?( request.env ) } || (raise InvalidConnectionError)
+      adapter = adapters.detect { |a| a.accepts?(request.env) } || raise(InvalidConnectionError)
       adapter.new request, dispatcher
     end
 
@@ -28,6 +28,10 @@ module WebsocketRails
 
       attr_reader :dispatcher, :queue, :env, :request, :data_store
 
+      # The ConnectionManager will set the connection ID when the
+      # connection is opened.
+      attr_accessor :id
+
       def initialize(request, dispatcher)
         @env        = request.env.dup
         @request    = request
@@ -39,7 +43,6 @@ module WebsocketRails
         @delegate.instance_variable_set(:@_env, request.env)
         @delegate.instance_variable_set(:@_request, request)
 
-        WebsocketRails.users[user_identifier] = self
         start_ping_timer
       end
 
@@ -70,28 +73,16 @@ module WebsocketRails
         @queue << event
       end
 
-      attr_accessor :flush_scheduled
-
       def trigger(event)
-        # Uncomment when implementing history queueing with redis
-        #enqueue event
-        #unless flush_scheduled
-        #  EM.next_tick { flush; flush_scheduled = false }
-        #  flush_scheduled = true
-        #end
         send "[#{event.serialize}]"
       end
 
       def flush
-        count = 1
-        message = "["
+        message = []
         @queue.flush do |event|
-          message << event.serialize
-          message << "," unless count == @queue.size
-          count += 1
+          message << event.as_json
         end
-        message << "]"
-        send message
+        send message.to_json
       end
 
       def send_message(event_name, data = {}, options = {})
@@ -110,14 +101,14 @@ module WebsocketRails
         [ -1, {}, [] ]
       end
 
-      def id
-        object_id.to_i
-      end
-
       def controller_delegate
         @delegate
       end
 
+      def connected?
+        true & @connected
+      end
+
       def inspect
         "#<Connection::#{id}>"
       end
@@ -126,31 +117,46 @@ module WebsocketRails
         inspect
       end
 
-      private
+      def user_connection?
+        not user_identifier.nil?
+      end
+
+      def user
+        return unless user_connection?
+        controller_delegate.current_user
+      end
 
       def user_identifier
         @user_identifier ||= begin
           identifier = WebsocketRails.config.user_identifier
 
-          unless @delegate.respond_to?(:current_user) &&
-                 @delegate.current_user &&
-                 @delegate.current_user.respond_to?(identifier)
-            return id
-          end
+          return unless current_user_responds_to?(identifier)
 
           controller_delegate.current_user.send(identifier)
          end
       end
 
+      private
+
       def dispatch(event)
         dispatcher.dispatch event
       end
 
+      def connection_manager
+        dispatcher.connection_manager
+      end
+
       def close_connection
         @data_store.destroy!
         @ping_timer.try(:cancel)
         dispatcher.connection_manager.close_connection self
-        WebsocketRails.users.delete(user_identifier)
+      end
+
+      def current_user_responds_to?(identifier)
+        controller_delegate                            &&
+        controller_delegate.respond_to?(:current_user) &&
+        controller_delegate.current_user               &&
+        controller_delegate.current_user.respond_to?(identifier)
       end
 
       attr_accessor :pong
@@ -171,6 +177,5 @@ module WebsocketRails
       end
 
     end
-
   end
 end

data/lib/websocket_rails/connection_manager.rb

@@ -15,8 +15,8 @@ module WebsocketRails
     BadRequestResponse = [400,{'Content-Type' => 'text/plain'},['invalid']].freeze
     ExceptionResponse  = [500,{'Content-Type' => 'text/plain'},['exception']].freeze
 
-    # Contains an Array of currently open connections.
-    # @return [Array]
+    # Contains a Hash of currently open connections.
+    # @return [Hash]
     attr_reader :connections
 
     # Contains the {Dispatcher} instance for the active server.
@@ -28,7 +28,7 @@ module WebsocketRails
     attr_reader :synchronization
 
     def initialize
-      @connections = []
+      @connections = {}
       @dispatcher  = Dispatcher.new(self)
 
       if WebsocketRails.synchronize?
@@ -63,31 +63,57 @@ module WebsocketRails
     private
 
     def parse_incoming_event(params)
-      connection = find_connection_by_id params["client_id"]
+      connection = find_connection_by_id(params["client_id"].to_i)
       connection.on_message params["data"]
       SuccessfulResponse
     end
 
     def find_connection_by_id(id)
-      connections.detect { |connection| connection.id == id.to_i } || (raise InvalidConnectionError)
+      connections[id] || raise(InvalidConnectionError)
     end
 
     # Opens a persistent connection using the appropriate {ConnectionAdapter}. Stores
-    # active connections in the {connections} array.
+    # active connections in the {connections} Hash.
     def open_connection(request)
-      connection = ConnectionAdapters.establish_connection( request, dispatcher )
-      connections << connection
+      connection = ConnectionAdapters.establish_connection(request, dispatcher)
+
+      assign_connection_id connection
+      register_user_connection connection
+
+      connections[connection.id] = connection
+
       info "Connection opened: #{connection}"
       connection.rack_response
     end
 
     def close_connection(connection)
       WebsocketRails.channel_manager.unsubscribe connection
-      connections.delete connection
+      destroy_user_connection connection
+
+      connections.delete connection.id
+
       info "Connection closed: #{connection}"
       connection = nil
     end
     public :close_connection
 
+    def assign_connection_id(connection)
+      begin
+        id = SecureRandom.hex(10)
+      end while connections.has_key?(id)
+
+      connection.id = id
+    end
+
+    def register_user_connection(connection)
+      return unless connection.user_connection?
+      WebsocketRails.users[connection.user_identifier] = connection
+    end
+
+    def destroy_user_connection(connection)
+      return unless connection.user_connection?
+      WebsocketRails.users.delete(connection)
+    end
+
   end
 end

data/lib/websocket_rails/event.rb

@@ -115,7 +115,7 @@ module WebsocketRails
       @namespace    = validate_namespace( options[:namespace] || namespace )
     end
 
-    def serialize
+    def as_json
       [
         encoded_name,
         {
@@ -127,7 +127,11 @@ module WebsocketRails
           :result => result,
           :server_token => server_token
         }
-      ].to_json
+      ]
+    end
+
+    def serialize
+      as_json.to_json
     end
 
     def is_channel?

data/lib/websocket_rails/synchronization.rb

@@ -5,6 +5,22 @@ require "redis/connection/ruby"
 module WebsocketRails
   class Synchronization
 
+    def self.all_users
+      singleton.all_users
+    end
+
+    def self.find_user(connection)
+      singleton.find_user connection
+    end
+
+    def self.register_user(connection)
+      singleton.register_user connection
+    end
+
+    def self.destroy_user(connection)
+      singleton.destroy_user connection
+    end
+
     def self.publish(event)
       singleton.publish event
     end
@@ -48,7 +64,7 @@ module WebsocketRails
 
     def synchronize!
       unless @synchronizing
-        @server_token = generate_unique_token
+        @server_token = generate_server_token
         register_server(@server_token)
 
         synchro = Fiber.new do
@@ -94,7 +110,7 @@ module WebsocketRails
       when event.is_channel?
         WebsocketRails[event.channel].trigger_event(event)
       when event.is_user?
-        connection = WebsocketRails.users[event.user_id]
+        connection = WebsocketRails.users[event.user_id.to_s]
         return if connection.nil?
         connection.trigger event
       end
@@ -104,7 +120,7 @@ module WebsocketRails
       remove_server(server_token)
     end
 
-    def generate_unique_token
+    def generate_server_token
       begin
         token = SecureRandom.urlsafe_base64
       end while redis.sismember("websocket_rails.active_servers", token)
@@ -125,5 +141,34 @@ module WebsocketRails
       EM.stop
     end
 
+    def register_user(connection)
+      Fiber.new do
+        id = connection.user_identifier
+        user = connection.user
+        redis.hset 'websocket_rails.users', id, user.as_json(root: false).to_json
+      end.resume
+    end
+
+    def destroy_user(identifier)
+      Fiber.new do
+        redis.hdel 'websocket_rails.users', identifier
+      end.resume
+    end
+
+    def find_user(identifier)
+      Fiber.new do
+        redis_client = EM.reactor_running? ? redis : ruby_redis
+        raw_user = redis_client.hget('websocket_rails.users', identifier)
+        raw_user ? JSON.parse(raw_user) : nil
+      end.resume
+    end
+
+    def all_users
+      Fiber.new do
+        redis_client = EM.reactor_running? ? redis : ruby_redis
+        redis_client.hgetall('websocket_rails.users')
+      end.resume
+    end
+
   end
 end

data/lib/websocket_rails/user_manager.rb

@@ -27,8 +27,8 @@ module WebsocketRails
   #
   # If no `current_user` method is defined or the
   # user is not signed in when the WebsocketRails
-  # connection is opened, the key will default to
-  # `connection.id`.
+  # connection is opened, the connection will not be
+  # stored in the UserManager.
   def self.users
     @user_manager ||= UserManager.new
   end
@@ -42,37 +42,228 @@ module WebsocketRails
     end
 
     def [](identifier)
-      unless user = @users[identifier]
-        user = MissingUser.new(identifier)
+      unless user = (@users[identifier.to_s] || find_remote_user(identifier.to_s))
+        user = MissingConnection.new(identifier.to_s)
       end
       user
     end
 
     def []=(identifier, connection)
-      @users[identifier] = connection
+      @users[identifier.to_s] ||= LocalConnection.new
+      @users[identifier.to_s] << connection
+      Synchronization.register_user(connection) if WebsocketRails.synchronize?
     end
 
-    def delete(identifier)
-      @users.delete(identifier)
+    def delete(connection)
+      identifier = connection.user_identifier.to_s
+
+      if (@users.has_key?(identifier) && @users[identifier].connections.count > 1)
+        @users[identifier].delete(connection)
+      else
+        @users.delete(identifier)
+        Synchronization.destroy_user(identifier) if WebsocketRails.synchronize?
+      end
     end
 
-    class MissingUser
+    # Behaves similarly to Ruby's Array#each, yielding each connection
+    # object stored in the {UserManager}. If synchronization is enabled,
+    # each connection from every active worker will be yielded.
+    #
+    # You can access the `current_user` object through the #user method.
+    #
+    # You can trigger an event on this user using the #send_message method
+    # which behaves identically to BaseController#send_message.
+    #
+    # If Synchronization is enabled, the state of the `current_user` object
+    # will be equivalent to it's state at the time the connection was opened.
+    # It will not reflect changes made after the connection has been opened.
+    def each(&block)
+      if WebsocketRails.synchronize?
+        users_hash = Synchronization.all_users || return
+        users_hash.each do |identifier, user_json|
+          connection = remote_connection_from_json(identifier, user_json)
+          block.call(connection) if block
+        end
+      else
+        users.each do |_, connection|
+          block.call(connection) if block
+        end
+      end
+    end
 
-      def initialize(identifier)
-        @identifier = identifier
+    # Behaves similarly to Ruby's Array#map, invoking the given block with
+    # each active connection object and returning a new array with the results.
+    #
+    # See UserManager#each for details on the current usage and limitations.
+    def map(&block)
+      collection = []
+
+      each do |connection|
+        collection << block.call(connection) if block
+      end
+
+      collection
+    end
+
+    private
+
+    def find_remote_user(identifier)
+      return unless WebsocketRails.synchronize?
+      user_hash = Synchronization.find_user(identifier) || return
+
+      remote_connection identifier, user_hash
+    end
+
+    def remote_connection_from_json(identifier, user_json)
+      user_hash = JSON.parse(user_json)
+      remote_connection identifier, user_hash
+    end
+
+    def remote_connection(identifier, user_hash)
+      RemoteConnection.new identifier, user_hash
+    end
+
+    # The UserManager::LocalConnection Class serves as a proxy object
+    # for storing multiple connections that belong to the same
+    # user. It implements the same basic interface as a Connection.
+    # This allows you to work with the object as though it is a
+    # single connection, but still trigger the events on all
+    # active connections belonging to the user.
+    class LocalConnection
+
+      attr_reader :connections
+
+      def initialize
+        @connections = []
+      end
+
+      def <<(connection)
+        @connections << connection
+      end
+
+      def delete(connection)
+        @connections.delete(connection)
+      end
+
+      def connected?
+        true
+      end
+
+      def user_identifier
+        latest_connection.user_identifier
+      end
+
+      def user
+        latest_connection.user
+      end
+
+      def trigger(event)
+        connections.each do |connection|
+          connection.trigger event
+        end
       end
 
       def send_message(event_name, data = {}, options = {})
-        if WebsocketRails.synchronize?
-          options.merge! :user_id => @identifier
-          options[:data] = data
-
-          event = Event.new(event_name, options)
-          Synchronization.publish event
-          true
-        else
-          false
+        options.merge! :user_id => user_identifier
+        options[:data] = data
+
+        event = Event.new(event_name, options)
+
+        # Trigger the event on all active connections for this user.
+        connections.each do |connection|
+          connection.trigger event
         end
+
+        # Still publish the event in case the user is connected to
+        # other workers as well.
+        Synchronization.publish event if WebsocketRails.synchronize?
+        true
+      end
+
+      private
+
+      def latest_connection
+        @connections.last
+      end
+
+    end
+
+    class RemoteConnection
+
+      attr_reader :user_identifier, :user
+
+      def initialize(identifier, user_hash)
+        @user_identifier = identifier.to_s
+        @user_hash = user_hash
+      end
+
+      def connected?
+        true
+      end
+
+      def user
+        @user ||= load_user
+      end
+
+      def send_message(event_name, data = {}, options = {})
+        options.merge! :user_id => @user_identifier
+        options[:data] = data
+
+        event = Event.new(event_name, options)
+
+        # If the user is connected to this worker, trigger the event
+        # immediately as the event will be ignored by the Synchronization
+        ## dispatcher since the server_token will match.
+        if connection = WebsocketRails.users.users[@user_identifier]
+          connection.trigger event
+        end
+
+        # Still publish the event in case the user is connected to
+        # other workers as well.
+        #
+        # No need to check for Synchronization being enabled here.
+        # If a RemoteConnection has been fetched, Synchronization
+        # must be enabled.
+        Synchronization.publish event
+        true
+      end
+
+      private
+
+      def load_user
+        user = WebsocketRails.config.user_class.new
+        set_user_attributes user, @user_hash
+        user
+      end
+
+      def set_user_attributes(user, attr)
+        attr.each do |k, v|
+          user.send "#{k}=", v
+        end
+        user.instance_variable_set(:@new_record, false)
+        user.instance_variable_set(:@destroyed, false)
+      end
+
+    end
+
+    class MissingConnection
+
+      attr_reader :identifier
+
+      def initialize(identifier)
+        @user_identifier = identifier.to_s
+      end
+
+      def connected?
+        false
+      end
+
+      def user
+        nil
+      end
+
+      def send_message(*args)
+        false
       end
 
       def nil?