hkroger-websocket-rails 0.7.1

data/lib/websocket_rails/event_map.rb

@@ -0,0 +1,184 @@
+module WebsocketRails
+  # Provides a DSL for mapping client events to controller actions.
+  #
+  # == Example events.rb file
+  #   # located in config/initializers/events.rb
+  #   WebsocketRails::EventMap.describe do
+  #     subscribe :client_connected, to: ChatController, with_method: :client_connected
+  #   end
+  #
+  # A single event can be mapped to any number of controller actions.
+  #
+  #   subscribe :new_message, :to => ChatController, :with_method => :rebroadcast_message
+  #   subscribe :new_message, :to => LogController, :with_method => :log_message
+  #
+  # Events can be nested underneath namesapces.
+  #
+  #   namespace :product do
+  #     subscribe :new, :to => ProductController, :with_method => :new
+  #   end
+  class EventMap
+
+    def self.describe(&block)
+      WebsocketRails.config.route_block = block
+    end
+
+    attr_reader :namespace
+
+    def initialize(dispatcher)
+      @dispatcher = dispatcher
+      @namespace  = DSL.new(dispatcher).evaluate WebsocketRails.config.route_block
+      @namespace  = DSL.new(dispatcher,@namespace).evaluate InternalEvents.events
+    end
+
+    def routes_for(event, &block)
+      @namespace.routes_for event, &block
+    end
+
+    # Proxy the reload_controllers! method to the global namespace.
+    def reload_controllers!
+      @namespace.reload_controllers!
+    end
+
+    # Provides the DSL methods available to the Event routes file
+    class DSL
+
+      def initialize(dispatcher,namespace=nil)
+        if namespace
+          @namespace = namespace
+        else
+          @namespace = Namespace.new :global, dispatcher
+        end
+      end
+
+      def evaluate(route_block)
+        instance_eval &route_block unless route_block.nil?
+        @namespace
+      end
+
+      def subscribe(event_name,options)
+        @namespace.store event_name, options
+      end
+
+      def namespace(new_namespace,&block)
+        @namespace = @namespace.find_or_create new_namespace
+        instance_eval &block if block.present?
+        @namespace = @namespace.parent
+      end
+
+      def private_channel(channel)
+        WebsocketRails[channel].make_private
+      end
+
+    end
+
+    # Stores route map for nested namespaces
+    class Namespace
+
+      include Logging
+
+      attr_reader :name, :controllers, :actions, :namespaces, :parent
+
+      def initialize(name,dispatcher,parent=nil)
+        @name        = name
+        @parent      = parent
+        @dispatcher  = dispatcher
+        @actions     = Hash.new {|h,k| h[k] = Array.new}
+        @controllers = Hash.new
+        @namespaces  = Hash.new
+      end
+
+      def find_or_create(namespace)
+        unless child = namespaces[namespace]
+          child = Namespace.new namespace, @dispatcher, self
+          namespaces[namespace] = child
+        end
+        child
+      end
+
+      # Stores controller/action pairs for events subscribed under
+      # this namespace.
+      def store(event_name,options)
+        klass, action = TargetValidator.validate_target options
+        actions[event_name] << [klass,action]
+      end
+
+      # Iterates through the namespace tree and yields all
+      # controller/action pairs stored for the target event.
+      def routes_for(event, event_namespace=nil, &block)
+
+        # Grab the first level namespace from the namespace array
+        # and remove it from the copy.
+        event_namespace = copy_event_namespace( event, event_namespace ) || return
+        namespace       = event_namespace.shift
+
+        # If the namespace matches the current namespace and we are
+        # at the last namespace level, yield any controller/action
+        # pairs for this event.
+        #
+        # If the namespace does not match, search the list of child
+        # namespaces stored at this level for a match and delegate
+        # to it's #routes_for method, passing along the current
+        # copy of the event's namespace array.
+        if namespace == @name and event_namespace.empty?
+          actions[event.name].each do |klass,action|
+            block.call klass, action
+          end
+        else
+          child_namespace = event_namespace.first
+          child = namespaces[child_namespace]
+          child.routes_for event, event_namespace, &block unless child.nil?
+        end
+      end
+
+      private
+
+      def copy_event_namespace(event, namespace=nil)
+        namespace = event.namespace.dup if namespace.nil?
+        namespace
+      end
+
+    end
+
+  end
+
+  class TargetValidator
+
+    # Parses the target and extracts controller/action pair or raises an error if target is invalid
+    def self.validate_target(target)
+      case target
+        when Hash
+          validate_hash_target target
+        when String
+          validate_string_target target
+      else
+        raise('Must specify the event target either as a string product#new_product or as a Hash to: ProductController, with_method: :new_product')
+      end
+    end
+
+  private
+
+    # Parses the target as a Hash, expecting keys to: and with_method:
+    def self.validate_hash_target(target)
+      klass  = target[:to] || raise("Must specify a class for to: option in event route")
+      action = target[:with_method] || raise("Must specify a method for with_method: option in event route")
+      [klass, action]
+    end
+
+    # Parses the target as a String, expecting it to be in the format "product#new_product"
+    def self.validate_string_target(target)
+      strings = target.split('#')
+      raise('The string must be in a format like product#new_product') unless strings.count == 2
+      klass = constantize_controller strings[0]
+      action = strings[1].to_sym
+      [klass, action]
+    end
+
+    def self.constantize_controller(controller_string)
+      strings = (controller_string << '_controller').split('/')
+      strings.map{|string| string.camelize}.join('::').constantize
+    end
+
+  end
+
+end

data/lib/websocket_rails/event_queue.rb

@@ -0,0 +1,33 @@
+module WebsocketRails
+  class EventQueue
+
+    attr_reader :queue
+
+    def initialize
+      @queue = []
+    end
+
+    def enqueue(event)
+      @queue << event
+    end
+    alias :<< :enqueue
+
+    def last
+      @queue.last
+    end
+
+    def size
+      @queue.size
+    end
+
+    def flush(&block)
+      unless block.nil?
+        @queue.each do |item|
+          block.call item
+        end
+      end
+      @queue = []
+    end
+
+  end
+end

data/lib/websocket_rails/internal_events.rb

@@ -0,0 +1,37 @@
+module WebsocketRails
+  class InternalEvents
+    def self.events
+      Proc.new do
+        namespace :websocket_rails do
+          subscribe :pong, :to => InternalController, :with_method => :do_pong
+          subscribe :subscribe, :to => InternalController, :with_method => :subscribe_to_channel
+          subscribe :unsubscribe, :to => InternalController, :with_method => :unsubscribe_to_channel
+        end
+      end
+    end
+  end
+
+  class InternalController < BaseController
+    include Logging
+
+    def subscribe_to_channel
+      channel_name = event.data[:channel]
+      unless WebsocketRails[channel_name].is_private?
+        WebsocketRails[channel_name].subscribe connection
+        trigger_success
+      else
+        trigger_failure( { :reason => "channel is private", :hint => "use subscribe_private instead." } )
+      end
+    end
+
+    def unsubscribe_to_channel
+      channel_name = event.data[:channel]
+      WebsocketRails[channel_name].unsubscribe connection
+      trigger_success
+    end
+
+    def do_pong
+      connection.pong = true
+    end
+  end
+end

data/lib/websocket_rails/logging.rb

@@ -0,0 +1,133 @@
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/hash'
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+module WebsocketRails
+  module Logging
+    # Logging module heavily influenced by Travis-Support library
+
+    LOGGABLE_DATA = [
+      String,
+      Hash,
+      ActiveSupport::HashWithIndifferentAccess
+    ]
+
+    ANSI = {
+      :red    => 31,
+      :green  => 32,
+      :yellow => 33,
+      :cyan   => 36
+    }
+
+    class << self
+      def configure(logger)
+        logger.tap do
+          logger.formatter = proc { |*args| Format.format(*args) }
+          logger.level = Logger.const_get(log_level.to_s.upcase)
+        end
+      end
+
+      def log_level
+        WebsocketRails.config.log_level || :debug
+      end
+    end
+
+    delegate :logger, :to => WebsocketRails
+
+    [:fatal, :error, :warn, :info, :debug].each do |level|
+      define_method(level) do |*args|
+        message, options = *args
+        log(level, message, options)
+      end
+    end
+
+    def log(level, message, options = {})
+      message.chomp.split("\n").each do |line|
+        logger.send(level, wrap(level, self, line, options || {}))
+      end
+    end
+
+    def log_event_start(event)
+      message = "Started Event: #{event.encoded_name}\n"
+      message << "#{colorize(:cyan, "Name:")} #{event.encoded_name}\n"
+      message << "#{colorize(:cyan, "Data:")} #{event.data.inspect}\n" if log_data?(event)
+      message << "#{colorize(:cyan, "Connection:")} #{event.connection}\n\n"
+      info message
+    end
+
+    def log_event_end(event, time)
+      info "Event #{event.encoded_name} Finished in #{time.to_f.to_d.to_s} seconds\n\n"
+    end
+
+    def log_event(event, &block)
+      log_event_start(event) if log_event?(event)
+      start_time = Time.now
+      block.call
+      total_time = Time.now - start_time
+      log_event_end(event, total_time) if log_event?(event)
+    rescue Exception => ex
+      log_exception(ex)
+      raise
+    end
+
+    def log_event?(event)
+      if event.is_internal?
+        WebsocketRails.config.log_internal_events?
+      else
+        true
+      end
+    end
+
+    def log_data?(event)
+      LOGGABLE_DATA.include?(event.data.class)
+    end
+
+    def log_exception(exception)
+      logger.error(wrap(:error, self, "#{exception.class.name}: #{exception.message}"))
+      exception.backtrace.each { |line| logger.error(wrap(:error, self, line)) } if exception.backtrace
+      logger << "\n"
+    rescue Exception => ex
+      puts '--- FATAL ---'
+      puts 'an exception occured while logging an exception'
+      puts ex.message, ex.backtrace
+      puts exception.message, exception.backtrace
+    end
+
+    def wrap(level, object, message, options = {})
+      header = options[:header] || object.log_header
+      color = color_for_level(level)
+      "[#{colorize(color, header)}] #{message.chomp}"
+    end
+
+    def colorize(color, text)
+      "\e[#{ANSI[color]}m#{text}\e[0m"
+    end
+
+    def color_for_level(level)
+      case level
+      when :info then :green
+      when :debug then :yellow
+      else
+        :red
+      end
+    end
+
+    def log_header
+      self.class.name.split('::').last
+    end
+
+    module Format
+      class << self
+        def format(severity, time, progname, msg)
+          "#{severity[0, 1]} [#{format_time(time)}] #{msg}\n"
+        end
+
+        def format_time(time)
+          time.strftime("%Y-%m-%d %H:%M:%S.") << time.usec.to_s[0, 3]
+        end
+      end
+    end
+
+  end
+end

data/lib/websocket_rails/spec_helpers.rb

@@ -0,0 +1,3 @@
+require 'spec_helpers/spec_helper_event'
+require 'spec_helpers/matchers/route_matchers'
+require 'spec_helpers/matchers/trigger_matchers'

data/lib/websocket_rails/synchronization.rb

@@ -0,0 +1,182 @@
+require "redis/connection/synchrony"
+require "redis"
+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
+
+    def self.synchronize!
+      singleton.synchronize!
+    end
+
+    def self.shutdown!
+      singleton.shutdown!
+    end
+
+    def self.redis
+      singleton.redis
+    end
+
+    def self.singleton
+      @singleton ||= new
+    end
+
+    include Logging
+
+    def redis
+      @redis ||= begin
+        redis_options = WebsocketRails.config.redis_options
+        debug "Reactor is not running - engaging ruby redis" unless EM.reactor_running?
+        debug "Reactor is running - engaging standard redis new" if EM.reactor_running?
+        EM.reactor_running? ? Redis.new(redis_options) : ruby_redis
+      end
+    end
+
+    def ruby_redis
+      @ruby_redis ||= begin
+        WebsocketRails.config.redis_options.merge(:driver => :ruby) unless WebsocketRails.config.redis_options.has_key? :driver
+        redis_options = WebsocketRails.config.redis_options
+        Redis.new(redis_options)
+      end
+    end
+
+    def publish(event)
+      Fiber.new do
+        event.server_token = server_token
+        redis.publish "websocket_rails.events", event.serialize
+      end.resume
+    end
+
+    def server_token
+      @server_token
+    end
+
+    def synchronize!
+      unless @synchronizing
+        @server_token = generate_server_token
+        register_server(@server_token)
+
+        synchro = Fiber.new do
+          EM.defer do
+            fiber_redis = Redis.new(WebsocketRails.config.redis_options)
+            fiber_redis.subscribe "websocket_rails.events" do |on|
+              debug "Subscribed to websocket_rails events"
+
+              on.message do |_, encoded_event|
+                event = Event.new_from_json(encoded_event, nil)
+
+                # Do nothing if this is the server that sent this event.
+                next if event.server_token == server_token
+
+                # Ensure an event never gets triggered twice. Events added to the
+                # redis queue from other processes may not have a server token
+                # attached.
+                event.server_token = server_token if event.server_token.nil?
+
+                trigger_incoming event
+              end
+            end
+          end
+          info "Beginning Synchronization"
+        end
+        @synchronizing = true
+
+        EM.next_tick { synchro.resume }
+
+        trap('TERM') do
+          Thread.new { shutdown! }
+        end
+        trap('INT') do
+          Thread.new { shutdown! }
+        end
+        trap('QUIT') do
+          Thread.new { shutdown! }
+        end
+      end
+    end
+
+    def trigger_incoming(event)
+      case
+      when event.is_channel?
+        WebsocketRails[event.channel].trigger_event(event)
+      when event.is_user?
+        connection = WebsocketRails.users[event.user_id.to_s]
+        return if connection.nil?
+        connection.trigger event
+      end
+    end
+
+    def shutdown!
+      remove_server(server_token)
+    end
+
+    def generate_server_token
+      begin
+        token = SecureRandom.urlsafe_base64
+      end while redis.sismember("websocket_rails.active_servers", token)
+
+      token
+    end
+
+    def register_server(token)
+      Fiber.new do
+        redis.sadd "websocket_rails.active_servers", token
+        info "Server Registered: #{token}"
+      end.resume
+    end
+
+    def remove_server(token)
+      ruby_redis.srem "websocket_rails.active_servers", token
+      info "Server Removed: #{token}"
+      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
+        raw_user = redis.hget('websocket_rails.users', identifier)
+        raw_user ? JSON.parse(raw_user) : nil
+      end.resume
+    end
+
+    def all_users
+      Fiber.new do
+        redis.hgetall('websocket_rails.users')
+      end.resume
+    end
+
+  end
+end