wwl-websocket-rails 0.7.1

data/lib/websocket_rails/controller_factory.rb

@@ -0,0 +1,80 @@
+module WebsocketRails
+  class ControllerFactory
+
+    attr_reader :controller_stores, :dispatcher
+
+    def initialize(dispatcher)
+      @dispatcher = dispatcher
+      @controller_stores = {}
+      @initialized_controllers = {}
+    end
+
+    # TODO: Add deprecation notice for user defined
+    # instance variables.
+    def new_for_event(event, controller_class, method)
+      controller_class = reload!(controller_class)
+      controller = controller_class.new
+
+      prepare(controller, event, method)
+
+      controller
+    end
+
+    private
+
+    def store_for_controller(controller)
+      @controller_stores[controller.class] ||= DataStore::Controller.new(controller)
+    end
+
+    def prepare(controller, event, method)
+      set_event(controller, event)
+      set_dispatcher(controller, dispatcher)
+      set_controller_store(controller)
+      set_action_name(controller, method)
+      initialize_controller(controller)
+    end
+
+    def set_event(controller, event)
+      set_ivar :@_event, controller, event
+    end
+
+    def set_dispatcher(controller, dispatcher)
+      set_ivar :@_dispatcher, controller, dispatcher
+    end
+
+    def set_controller_store(controller)
+      set_ivar :@_controller_store, controller, store_for_controller(controller)
+    end
+
+    def set_action_name(controller, method)
+      set_ivar :@_action_name, controller, method.to_s
+    end
+
+    def set_ivar(ivar, object, value)
+      object.instance_variable_set(ivar, value)
+    end
+
+    def initialize_controller(controller)
+      unless @initialized_controllers[controller.class] == true
+        controller.send(:initialize_session) if controller.respond_to?(:initialize_session)
+        @initialized_controllers[controller.class] = true
+      end
+    end
+
+    # Reloads the controller class to pick up code changes
+    # while in the development environment.
+    def reload!(controller)
+      return controller unless defined?(Rails) and !Rails.configuration.cache_classes
+      # we don't reload our own controller as we assume it provide as 'library'
+      unless controller.name == "WebsocketRails::InternalController"
+        class_name = controller.name
+        filename = class_name.underscore
+        load "#{filename}.rb"
+        return class_name.constantize
+      end
+
+      return controller
+    end
+
+  end
+end

data/lib/websocket_rails/data_store.rb

@@ -0,0 +1,145 @@
+module WebsocketRails
+  # The {DataStore} provides a convenient way to persist information between
+  # execution of events. Since every event is executed within a new instance
+  # of the controller class, instance variables set while processing an
+  # action will be lost after the action finishes executing.
+  #
+  # There are two different {DataStore} classes that you can use:
+  #
+  # The {DataStore::Connection} class is unique for every active connection.
+  # You can use it similar to the Rails session store. The connection data
+  # store can be accessed within your controller using the `#connection_store`
+  # method.
+  #
+  # The {DataStore::Controller} class is unique for every controller. You
+  # can use it similar to how you would use instance variables within a
+  # plain ruby class. The values set within the controller store will be
+  # persisted between events. The controller store can be accessed within
+  # your controller using the `#controller_store` method.
+  module DataStore
+    class Base < ActiveSupport::HashWithIndifferentAccess
+
+      cattr_accessor :all_instances
+      @@all_instances = Hash.new { |h,k| h[k] = [] }
+
+      def self.clear_all_instances
+        @@all_instances = Hash.new { |h,k| h[k] = [] }
+      end
+
+      def initialize
+        instances << self
+      end
+
+      def instances
+        all_instances[self.class]
+      end
+
+      def collect_all(key)
+        collection = instances.each_with_object([]) do |instance, array|
+          array << instance[key]
+        end
+
+        if block_given?
+          collection.each do |item|
+            yield(item)
+          end
+        else
+          collection
+        end
+      end
+
+      def destroy!
+        instances.delete_if {|store| store.object_id == self.object_id }
+      end
+
+    end
+
+    # The connection data store operates much like the {Controller} store. The
+    # biggest difference is that the data placed inside is private for
+    # individual users and accessible from any controller. Anything placed
+    # inside the connection data store will be deleted when a user disconnects.
+    #
+    # The connection data store is accessed through the `#connection_store`
+    # instance method inside your controller.
+    #
+    # If we were writing a basic chat system, we could use the connection data
+    # store to hold onto a user's current screen name.
+    #
+    #
+    #     class UserController < WebsocketRails::BaseController
+    #
+    #       def set_screen_name
+    #         connection_store[:screen_name] = message[:screen_name]
+    #       end
+    #
+    #     end
+    #
+    #     class ChatController < WebsocketRails::BaseController
+    #
+    #       def say_hello
+    #         screen_name = connection_store[:screen_name]
+    #         send_message :new_message, "#{screen_name} says hello"
+    #       end
+    #
+    #     end
+    class Connection < Base
+
+      attr_accessor :connection
+
+      def initialize(connection)
+        super()
+        @connection = connection
+      end
+
+    end
+
+    # The Controller DataStore acts as a stand-in for instance variables in your
+    # controller. At it's core, it is a Hash which is accessible inside your
+    # controller through the `#controller_store` instance method. Any values
+    # set in the controller store will be visible by all connected users which
+    # trigger events that use that controller. However, values set in one
+    # controller will not be visible by other controllers.
+    #
+    #
+    #     class AccountController < WebsocketRails::BaseController
+    #       # We will use a before filter to set the initial value
+    #       before_action { controller_store[:event_count] ||= 0 }
+    #
+    #       # Mapped as `accounts.important_event` in the Event Router
+    #       def important_event
+    #         # This will be private for each controller
+    #         controller_store[:event_count] += 1
+    #         trigger_success controller_store[:event_count]
+    #       end
+    #     end
+    #
+    #     class ProductController < WebsocketRails::BaseController
+    #       # We will use a before filter to set the initial value
+    #       before_action { controller_store[:event_count] ||= 0 }
+    #
+    #       # Mapped as `products.boring_event` in the Event Router
+    #       def boring_event
+    #         # This will be private for each controller
+    #         controller_store[:event_count] += 1
+    #         trigger_success controller_store[:event_count]
+    #       end
+    #     end
+    #
+    #     # trigger `accounts.important_event`
+    #     => 1
+    #     # trigger `accounts.important_event`
+    #     => 2
+    #     # trigger `products.boring_event`
+    #     => 1
+    class Controller < Base
+
+      attr_accessor :controller
+
+      def initialize(controller)
+        super()
+        @controller = controller
+      end
+
+    end
+  end
+end

data/lib/websocket_rails/dispatcher.rb

@@ -0,0 +1,129 @@
+module WebsocketRails
+  class Dispatcher
+
+    include Logging
+
+    attr_reader :event_map, :connection_manager, :controller_factory
+
+    delegate :filtered_channels, to: WebsocketRails
+
+    def initialize(connection_manager)
+      @connection_manager = connection_manager
+      @controller_factory = ControllerFactory.new(self)
+      @event_map = EventMap.new(self)
+    end
+
+    def receive_encoded(encoded_data,connection)
+      event = Event.new_from_json( encoded_data, connection )
+      dispatch( event )
+    end
+
+    def receive(event_name,data,connection)
+      event = Event.new event_name, data, connection
+      dispatch( event )
+    end
+
+    def dispatch(event)
+      return if event.is_invalid?
+
+      if event.is_channel?
+        filter_channel(event)
+      else
+        reload_event_map! unless event.is_internal?
+        route event
+      end
+    end
+
+    def send_message(event)
+      event.connection.trigger event
+    end
+
+    def broadcast_message(event)
+      connection_manager.connections.map do |_, connection|
+        connection.trigger event
+      end
+    end
+
+    def reload_event_map!
+      return unless defined?(Rails) and !Rails.configuration.cache_classes
+      begin
+        load "#{Rails.root}/config/events.rb"
+        @event_map = EventMap.new(self)
+      rescue Exception => ex
+        log(:warn, "EventMap reload failed: #{ex.message}")
+      end
+    end
+
+    private
+
+    def route(event)
+      actions = []
+      event_map.routes_for event do |controller_class, method|
+        actions << Fiber.new do
+          begin
+            log_event(event) do
+              controller = controller_factory.new_for_event(event, controller_class, method)
+
+              controller.process_action(method, event)
+            end
+          rescue Exception => ex
+            event.success = false
+            event.data = extract_exception_data ex
+            event.trigger
+          end
+        end
+      end
+      execute actions
+    end
+
+    def filter_channel(event)
+      actions = []
+      actions << Fiber.new do
+        begin
+          log_event(event) do
+            controller_class, catch_all = filtered_channels[event.channel]
+
+            controller = controller_factory.new_for_event(event, controller_class, event.name)
+            # send to the method of the event name
+            # silently skip routing to the controller on event.name if it doesnt respond
+            controller.process_action(event.name, event) if controller.respond_to?(event.name)
+            # send to our defined catch all method
+            controller.process_action(catch_all, event) if catch_all
+
+          end
+        rescue Exception => ex
+          event.success = false
+          event.data = extract_exception_data ex
+          event.trigger
+        end
+      end if filtered_channels[event.channel]
+
+      actions << Fiber.new{ WebsocketRails[event.channel].trigger_event(event) }
+      execute actions
+    end
+
+    def execute(actions)
+      actions.map do |action|
+        EM.next_tick { action.resume }
+      end
+    end
+
+    def extract_exception_data(ex)
+      if record_invalid_defined? and ex.is_a? ActiveRecord::RecordInvalid
+        {
+          :record => ex.record.attributes,
+          :errors => ex.record.errors,
+          :full_messages => ex.record.errors.full_messages
+        }
+      else
+        ex if ex.respond_to?(:to_json)
+      end
+    end
+
+    def record_invalid_defined?
+      Object.const_defined?('ActiveRecord') and ActiveRecord.const_defined?('RecordInvalid')
+    end
+
+
+  end
+end

data/lib/websocket_rails/engine.rb

@@ -0,0 +1,26 @@
+module WebsocketRails
+
+  class Engine < Rails::Engine
+
+    config.autoload_paths += [File.expand_path("../../lib", __FILE__)]
+
+    paths["app"] << "lib/rails/app"
+    paths["app/controllers"] << "lib/rails/app/controllers"
+
+    if ::Rails.version >= '4.0.0'
+      paths["config/routes.rb"]   << "lib/rails/config/routes.rb"
+    else
+      paths["config/routes"]   << "lib/rails/config/routes.rb"
+    end
+
+    initializer 'websocket_rails.load_event_routes', :before => :preload_frameworks do |app|
+      load "#{Rails.root}/config/events.rb" if File.exists?("#{Rails.root}/config/events.rb")
+    end
+
+    rake_tasks do
+      require 'websocket-rails'
+      load 'rails/tasks/websocket_rails.tasks'
+    end
+
+  end
+end

data/lib/websocket_rails/event.rb

@@ -0,0 +1,193 @@
+module WebsocketRails
+
+  module StaticEvents
+
+    def new_on_open(connection,data=nil)
+      connection_id = {
+        :connection_id => connection.id
+      }
+      data = data.is_a?(Hash) ? data.merge( connection_id ) : connection_id
+      Event.new :client_connected, :data => data, :connection => connection
+    end
+
+    def new_on_close(connection,data=nil)
+      Event.new :client_disconnected, :data => data, :connection => connection
+    end
+
+    def new_on_error(connection,data=nil)
+      Event.new :client_error, :data => data, :connection => connection
+    end
+
+    def new_on_ping(connection)
+      Event.new :ping, :data => {}, :connection => connection, :namespace => :websocket_rails
+    end
+
+    def new_on_invalid_event_received(connection,data=nil)
+      Event.new :invalid_event, :data => data, :connection => connection
+    end
+
+  end
+
+  # Contains all of the relevant information for incoming and outgoing events.
+  # All events except for channel events will have a connection object associated.
+  #
+  # Events require an event name and hash of options:
+  #
+  # :data =>
+  # The data object will be passed to any callback functions bound on the
+  # client side.
+  #
+  # You can also pass a Hash of options to specify:
+  #
+  # :connection =>
+  # Connection that will be receiving or that sent this event.
+  #
+  # :namespace =>
+  # The namespace this event is under. Will default to :global
+  # If the namespace is nested under multiple levels pass them as an array.
+  # For instance, if the namespace route looks like the following:
+  #
+  #   namespace :products do
+  #     namespace :hats do
+  #       # events
+  #     end
+  #   end
+  #
+  # Then you would pass the namespace argument as [:products,:hats]
+  #
+  # :channel =>
+  # The name of the channel that this event is destined for.
+  class Event
+
+    class UnknownDataType < StandardError; end;
+
+    extend Logging
+
+    SUCCEEDED = 0
+    FAILED = 1
+    FINISHED_WITHOUT_RESULT = 2
+
+    def self.log_header
+      "Event"
+    end
+
+    def self.new_from_json(encoded_data, connection)
+      case encoded_data
+      when String
+        event_name, data = JSON.parse encoded_data
+
+        unless event_name.is_a?(String) && data.is_a?(Hash)
+          raise UnknownDataType
+        end
+
+        data = data.merge(:connection => connection).with_indifferent_access
+        Event.new event_name, data
+        # when Array
+        # TODO: Handle file
+        #File.open("/tmp/test#{rand(100)}.jpg", "wb") do |file|
+        #  encoded_data.each do |byte|
+        #    file << byte.chr
+        #  end
+        #end
+      else
+        raise UnknownDataType
+      end
+    rescue JSON::ParserError, UnknownDataType => ex
+      warn "Invalid Event Received: #{ex}"
+      debug "Event Data: #{encoded_data}"
+      log_exception(ex)
+      Event.new_on_invalid_event_received(connection, nil)
+    end
+
+    include Logging
+    extend StaticEvents
+
+    attr_reader :id, :name, :connection, :namespace, :channel, :user_id, :token
+
+    attr_accessor :data, :result, :success, :server_token, :propagate
+
+    def initialize(event_name, options={})
+      case event_name
+      when String
+        namespace   = event_name.split('.')
+        @name       = namespace.pop.to_sym
+      when Symbol
+        @name       = event_name
+        namespace   = [:global]
+      end
+      @id           = options[:id]
+      @data         = options[:data].is_a?(Hash) ? options[:data].with_indifferent_access : options[:data]
+      @channel      = options[:channel].to_sym rescue options[:channel].to_s.to_sym if options[:channel]
+      @token        = options[:token] if options[:token]
+      @connection   = options[:connection]
+      @server_token = options[:server_token]
+      @user_id      = options[:user_id]
+      @propagate    = options[:propagate].nil? ? true : options[:propagate]
+      @namespace    = validate_namespace( options[:namespace] || namespace )
+    end
+
+    def as_json
+      [
+        encoded_name,
+        {
+          :id => id,
+          :channel => channel,
+          :user_id => user_id,
+          :data => data,
+          :success => success,
+          :result => result,
+          :token => token,
+          :server_token => server_token
+        }
+      ]
+    end
+
+    def serialize
+      as_json.to_json
+    end
+
+    def is_channel?
+      !@channel.nil?
+    end
+
+    def is_user?
+      !@user_id.nil? && !is_channel?
+    end
+
+    def is_invalid?
+      name == :invalid_event
+    end
+
+    def is_internal?
+      namespace.include?(:websocket_rails)
+    end
+
+    def should_propagate?
+      @propagate
+    end
+
+    def trigger
+      connection.trigger self if connection
+    end
+
+    def encoded_name
+      if namespace.size > 1
+        child_namespace = namespace.dup[1..-1]
+        child_namespace << name
+        combined_name = child_namespace.join('.')
+      else
+        combined_name = name
+      end
+      combined_name
+    end
+
+    private
+
+    def validate_namespace(namespace)
+      namespace = [namespace] unless namespace.is_a?(Array)
+      namespace.unshift :global unless namespace.first == :global
+      namespace.map(&:to_sym) rescue [:global]
+    end
+
+  end
+end