hkroger-websocket-rails 0.7.1

data/lib/websocket_rails/base_controller.rb

@@ -0,0 +1,197 @@
+require "websocket_rails/data_store"
+require 'abstract_controller/callbacks'
+
+module WebsocketRails
+  # Provides controller helper methods for developing a WebsocketRails controller. Action methods
+  # defined on a WebsocketRails controller can be mapped to events using the {EventMap} class.
+  #
+  # == Example WebsocketRails controller
+  #   class ChatController < WebsocketRails::BaseController
+  #     # Can be mapped to the :client_connected event in the events.rb file.
+  #     def new_user
+  #       send_message :new_message, {:message => 'Welcome to the Chat Room!'}
+  #     end
+  #   end
+  #
+  # It is best to use the provided {DataStore} to temporarily persist data for each client between
+  # events. Read more about it in the {DataStore} documentation.
+  #
+  #
+  class BaseController
+
+    # We need process_action to be in a module loaded before AbstractController::Callbacks
+    # to get inheritance properly
+    module Metal
+      def process_action(method, event)
+        if respond_to?(method)
+          self.send(method)
+        else
+          raise EventRoutingError.new(event, self, method)
+        end
+      end
+      def response_body
+        false
+      end
+    end
+
+    include Metal
+    include AbstractController::Callbacks
+
+    # Tell Rails that BaseController and children can be reloaded when in
+    # the Development environment.
+    def self.inherited(controller)
+      unless controller.name == "WebsocketRails::InternalController" || Rails.version =~/^4/
+        unloadable controller
+      end
+    end
+
+    # Tell the dispatcher to use channel filtering on specific channels.
+    # If supplied, the :catch_all => :method will be processed for every
+    # event that comes into the channel(s).
+    #
+    #
+    # Example:
+    # To process events based upon the event_name inside :channel_one
+    #
+    #  filter_for_channels :channel_one
+    #
+    # To process events based upon the event_name and a catch all
+    #
+    #  filter_for_channels :channel_one, :catch_all => :logger_method
+    #
+    def self.filter_for_channels(*channels)
+      options = channels.last.is_a?(Hash) ? channels.pop : {}
+      channels.each do |channel|
+        WebsocketRails.filtered_channels[channel] = options[:catch_all].nil? ? self : [self, options[:catch_all]]
+      end
+    end
+
+    # Provides direct access to the connection object for the client that
+    # initiated the event that is currently being executed.
+    def connection
+      @_event.connection
+    end
+
+    # The numerical ID for the client connection that initiated the event. The ID is unique
+    # for each currently active connection but can not be used to associate a client between
+    # multiple connection attempts.
+    def client_id
+      connection.id
+    end
+
+    # The {Event} object that triggered this action.
+    # Find the current event name with event.name
+    # Access the data sent with the event with event.data
+    # Find the event's namespace with event.namespace
+    def event
+      @_event
+    end
+
+    # The current message that was passed from the client when the event was initiated. The
+    # message is typically a standard ruby Hash object. See the README for more information.
+    def message
+      @_event.data
+    end
+    alias_method :data, :message
+
+    # Trigger the success callback function attached to the client event that triggered
+    # this action. The object passed to this method will be passed as an argument to
+    # the callback function on the client.
+    def trigger_success(data=nil)
+      event.success = true
+      event.data = data
+      event.trigger
+    end
+
+    # Trigger the failure callback function attached to the client event that triggered
+    # this action. The object passed to this method will be passed as an argument to
+    # the callback function on the client.
+    def trigger_failure(data=nil)
+      event.success = false
+      event.data = data
+      event.trigger
+    end
+
+    def accept_channel(data=nil)
+      channel_name = event.data[:channel]
+      WebsocketRails[channel_name].subscribe connection
+      trigger_success data
+    end
+
+    def deny_channel(data=nil)
+      trigger_failure data
+    end
+
+    def stop_event_propagation!
+      event.propagate = false
+    end
+
+    # Sends a message to the client that initiated the current event being executed. Messages
+    # are serialized as JSON into a two element Array where the first element is the event
+    # and the second element is the message that was passed, typically a Hash.
+    #
+    # To send an event under a namespace, add the `:namespace => :target_namespace` option.
+    #
+    #   send_message :new_message, message_hash, :namespace => :product
+    #
+    # Nested namespaces can be passed as an array like the following:
+    #
+    #   send_message :new, message_hash, :namespace => [:products,:glasses]
+    #
+    # See the {EventMap} documentation for more on mapping namespaced actions.
+    def send_message(event_name, message, options={})
+      options.merge! :connection => connection, :data => message
+      event = Event.new( event_name, options )
+      @_dispatcher.send_message event if @_dispatcher.respond_to?(:send_message)
+    end
+
+    # Broadcasts a message to all connected clients. See {#send_message} for message passing details.
+    def broadcast_message(event_name, message, options={})
+      options.merge! :connection => connection, :data => message
+      event = Event.new( event_name, options )
+      @_dispatcher.broadcast_message event if @_dispatcher.respond_to?(:broadcast_message)
+    end
+
+    def request
+      connection.request
+    end
+
+    def action_name
+      @_action_name
+    end
+
+    # Provides access to the {DataStore} for the current controller. The {DataStore} provides convenience
+    # methods for keeping track of data associated with active connections. See it's documentation for
+    # more information.
+    def controller_store
+      @_controller_store
+    end
+
+    def connection_store
+      connection.data_store
+    end
+
+    def self.controller_name
+      self.name.underscore.gsub(/_controller$/,'')
+    end
+
+    def controller_name
+      self.class.controller_name
+    end
+
+    private
+
+    def delegate
+      connection.controller_delegate
+    end
+
+    def method_missing(method,*args,&block)
+      if delegate.respond_to? method
+        delegate.send method, *args, &block
+      else
+        super
+      end
+    end
+
+  end
+end

data/lib/websocket_rails/channel.rb

@@ -0,0 +1,97 @@
+module WebsocketRails
+  class Channel
+
+    include Logging
+
+    delegate :config, :channel_tokens, :channel_manager, :filtered_channels, :to => WebsocketRails
+
+    attr_reader :name, :subscribers
+
+    def initialize(channel_name)
+      @subscribers = []
+      @name        = channel_name
+      @private     = false
+    end
+
+    def subscribe(connection)
+      info "#{connection} subscribed to channel #{@name}"
+      trigger 'subscriber_join', connection.user if config.broadcast_subscriber_events?
+      @subscribers << connection
+      send_token connection
+    end
+
+    def unsubscribe(connection)
+      return unless @subscribers.include? connection
+      info "#{connection} unsubscribed from channel #{@name}"
+      @subscribers.delete connection
+      trigger 'subscriber_part', connection.user if config.broadcast_subscriber_events?
+    end
+
+    def trigger(event_name,data={},options={})
+      options.merge! :channel => @name, :token => token
+      options[:data] = data
+
+      event = Event.new event_name, options
+
+      info "[#{@name}] #{event.data.inspect}"
+      send_data event
+    end
+
+    def trigger_event(event)
+      return if event.token != token
+      info "[#{@name}] #{event.data.inspect}"
+      send_data event
+    end
+
+    def make_private
+      unless config.keep_subscribers_when_private?
+        @subscribers.clear
+      end
+      @private = true
+    end
+
+    def filter_with(controller, catch_all=nil)
+      filtered_channels[@name] = catch_all.nil? ? controller : [controller, catch_all]
+    end
+
+    def is_private?
+      @private
+    end
+
+    def token
+      @token ||= channel_tokens[@name] ||= generate_unique_token
+    end
+
+    private
+
+    def generate_unique_token
+      begin
+        new_token = SecureRandom.uuid
+      end while channel_tokens.values.include?(new_token)
+
+      new_token
+    end
+
+    def send_token(connection)
+      options = {
+        :channel => @name,
+        :data => {:token => token},
+        :connection => connection
+      }
+      info 'sending token'
+      Event.new('websocket_rails.channel_token', options).trigger
+    end
+
+    def send_data(event)
+      return unless event.should_propagate?
+      if WebsocketRails.synchronize? && event.server_token.nil?
+        Synchronization.publish event
+      end
+
+      @subscribers.each do |subscriber|
+        subscriber.trigger event
+      end
+    end
+
+  end
+end

data/lib/websocket_rails/channel_manager.rb

@@ -0,0 +1,55 @@
+require 'redis-objects'
+
+module WebsocketRails
+
+  class << self
+
+    def channel_manager
+      @channel_manager ||= ChannelManager.new
+    end
+
+    def [](channel)
+      channel_manager[channel]
+    end
+
+    def channel_tokens
+      channel_manager.channel_tokens
+    end
+
+    def filtered_channels
+      channel_manager.filtered_channels
+    end
+
+  end
+
+  class ChannelManager
+
+    attr_reader :channels, :filtered_channels
+
+    def initialize
+      @channels = {}.with_indifferent_access
+      @filtered_channels = {}.with_indifferent_access
+    end
+
+    def channel_tokens
+      @channel_tokens ||= begin
+        if WebsocketRails.synchronize?
+          ::Redis::HashKey.new('websocket_rails.channel_tokens', Synchronization.redis)
+        else
+          {}
+        end
+      end
+    end
+
+    def [](channel)
+      @channels[channel] ||= Channel.new channel
+    end
+
+    def unsubscribe(connection)
+      @channels.each do |channel_name, channel|
+        channel.unsubscribe(connection)
+      end
+    end
+
+  end
+end

data/lib/websocket_rails/configuration.rb

@@ -0,0 +1,169 @@
+module WebsocketRails
+  class Configuration
+
+    def user_identifier
+      @user_identifier ||= :id
+    end
+
+    def user_identifier=(identifier)
+      @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
+
+    def keep_subscribers_when_private=(value)
+      @keep_subscribers_when_private = value
+    end
+
+    def allowed_origins
+      # allows the value to be string or array
+      [@allowed_origins].flatten.compact.uniq ||= []
+    end
+
+    def allowed_origins=(value)
+      @allowed_origins = value
+    end
+
+    def broadcast_subscriber_events?
+      @broadcast_subscriber_events ||= false
+    end
+
+    def broadcast_subscriber_events=(value)
+      @broadcast_subscriber_events = value
+    end
+
+    def route_block=(routes)
+      @event_routes = routes
+    end
+
+    def route_block
+      @event_routes
+    end
+
+    def log_level
+      @log_level ||= begin
+        case Rails.env.to_sym
+        when :production then :info
+        when :development then :debug
+        end
+      end
+    end
+
+    def log_level=(level)
+      @log_level = level
+    end
+
+    def logger
+      @logger ||= begin
+        logger = Logger.new(log_path)
+        Logging.configure(logger)
+      end
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    def log_path
+      @log_path ||= "#{Rails.root}/log/websocket_rails.log"
+    end
+
+    def log_path=(path)
+      @log_path = path
+    end
+
+    def log_internal_events?
+      @log_internal_events ||= false
+    end
+
+    def log_internal_events=(value)
+      @log_internal_events = value
+    end
+
+    def daemonize?
+      @daemonize.nil? ? true : @daemonize
+    end
+
+    def daemonize=(value)
+      @daemonize = value
+    end
+
+    def synchronize
+      @synchronize ||= false
+    end
+
+    def synchronize=(synchronize)
+      @synchronize = synchronize
+    end
+
+    def redis_options
+      @redis_options ||= redis_defaults
+    end
+
+    def redis_options=(options = {})
+      @redis_options = redis_defaults.merge(options)
+    end
+
+    def redis_defaults
+      {:host => '127.0.0.1', :port => 6379, :driver => :synchrony}
+    end
+
+    def standalone
+      @standalone ||= false
+    end
+
+    def standalone=(standalone)
+      @standalone = standalone
+    end
+
+    def standalone_port
+      @standalone_port ||= '3001'
+    end
+
+    def standalone_port=(port)
+      @standalone_port = port
+    end
+
+    def thin_options
+      @thin_options ||= thin_defaults
+    end
+
+    def thin_options=(options = {})
+      @thin_options = thin_defaults.merge(options)
+    end
+
+    def thin_defaults
+      {
+        :port => standalone_port,
+        :pid => "#{Rails.root}/tmp/pids/websocket_rails.pid",
+        :log => "#{Rails.root}/log/websocket_rails_server.log",
+        :tag => 'websocket_rails',
+        :rackup => "#{Rails.root}/config.ru",
+        :threaded => false,
+        :daemonize => daemonize?,
+        :dirname => Rails.root,
+        :max_persistent_conns => 1024,
+        :max_conns => 1024
+      }
+    end
+
+    def default_ping_interval
+      @default_ping_interval ||= 10
+    end
+
+    def default_ping_interval=(interval)
+      @default_ping_interval = interval.to_i
+    end
+
+  end
+end