websocket-rails 0.1.5 → 0.1.6

data/lib/assets/javascripts/websocket_rails/websocket_rails.js.coffee

@@ -18,9 +18,10 @@ Listening for new events from the server
 ###
 class window.WebSocketRails
   constructor: (@url, @use_websockets = true) ->
-    @state          = 'connecting'
-    @callbacks      = {}
-    @channels       = {}
+    @state     = 'connecting'
+    @callbacks = {}
+    @channels  = {}
+    @queue     = {}
 
     unless @supports_websockets() and @use_websockets
       @_conn = new WebSocketRails.HttpConnection url, @
@@ -31,21 +32,24 @@ class window.WebSocketRails
 
   new_message: (data) =>
     for socket_message in data
-      if socket_message.length > 2
-        event_name = socket_message[1]
-        message    = socket_message[2]
-        @dispatch_channel socket_message...
+      event = new WebSocketRails.Event( socket_message )
+      if event.is_result()
+        @queue[event.id]?.run_callbacks(event.success, event.data)
+        @queue[event.id] = null
+      else if event.is_channel()
+        @dispatch_channel event
+      else if event.is_ping()
+        @pong()
       else
-        event_name = socket_message[0]
-        message    = socket_message[1]
-        @dispatch socket_message...
+        @dispatch event
 
-      if @state == 'connecting' and event_name == 'client_connected'
-        @connection_established message
+      if @state == 'connecting' and event.name == 'client_connected'
+        @connection_established event.data
 
   connection_established: (data) =>
     @state         = 'connected'
     @connection_id = data.connection_id
+    @_conn.flush_queue data.connection_id
     if @on_open?
       @on_open(data)
 
@@ -53,13 +57,19 @@ class window.WebSocketRails
     @callbacks[event_name] ?= []
     @callbacks[event_name].push callback
 
-  trigger: (event_name, data) =>
-    @_conn.trigger event_name, data, @connection_id
+  trigger: (event_name, data, success_callback, failure_callback) =>
+    event = new WebSocketRails.Event( [event_name, data, @connection_id], success_callback, failure_callback )
+    @queue[event.id] = event
+    @_conn.trigger event
 
-  dispatch: (event_name, data) =>
-    return unless @callbacks[event_name]?
-    for callback in @callbacks[event_name]
-      callback data
+  trigger_event: (event) =>
+    @queue[event.id] ?= event # Prevent replacing an event that has callbacks stored
+    @_conn.trigger event
+
+  dispatch: (event) =>
+    return unless @callbacks[event.name]?
+    for callback in @callbacks[event.name]
+      callback event.data
 
   subscribe: (channel_name) =>
     unless @channels[channel_name]?
@@ -69,13 +79,21 @@ class window.WebSocketRails
     else
       @channels[channel_name]
 
-  trigger_channel: (channel, event_name, data) =>
-    @_conn.trigger_channel channel, event_name, @connection_id
+  subscribe_private: (channel_name) =>
+    unless @channels[channel_name]?
+      channel = new WebSocketRails.Channel channel_name, @, true
+      @channels[channel_name] = channel
+      channel
+    else
+      @channels[channel_name]
 
-  dispatch_channel: (channel, event_name, message) =>
-    return unless @channels[channel]?
-    @channels[channel].dispatch event_name, message
+  dispatch_channel: (event) =>
+    return unless @channels[event.channel]?
+    @channels[event.channel].dispatch event.name, event.data
 
   supports_websockets: =>
     (typeof(WebSocket) == "function" or typeof(WebSocket) == "object")
 
+  pong: =>
+    pong = new WebSocketRails.Event( ['websocket_rails.pong',{},@connection_id] )
+    @_conn.trigger pong

data/lib/websocket-rails.rb

@@ -17,7 +17,10 @@ module WebsocketRails
   end
 end
 
-require "websocket_rails/engine"
+LOG_LEVEL = :warn
+
+require 'websocket_rails/engine'
+require 'websocket_rails/logging'
 require 'websocket_rails/connection_manager'
 require 'websocket_rails/dispatcher'
 require 'websocket_rails/event'
@@ -32,9 +35,6 @@ require 'websocket_rails/connection_adapters'
 require 'websocket_rails/connection_adapters/http'
 require 'websocket_rails/connection_adapters/web_socket'
 
-::Thin::Server.send( :remove_const, 'DEFAULT_TIMEOUT' )
-::Thin::Server.const_set( 'DEFAULT_TIMEOUT', 0 )
-
 # Exceptions
 class InvalidConnectionError < StandardError
   def rack_response

data/lib/websocket_rails/base_controller.rb

@@ -2,10 +2,7 @@ require 'websocket_rails/data_store'
 
 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 {Events} class.
-  # This class should be sub classed in a user's application, similar to the ApplicationController
-  # in a Rails application. You can create your WebsocketRails controllers in your standard Rails
-  # controllers directory.
+  # defined on a WebsocketRails controller can be mapped to events using the {EventMap} class.
   #
   # == Example WebsocketRails controller
   #   class ChatController < WebsocketRails::BaseController
@@ -17,8 +14,14 @@ module WebsocketRails
   #
   # 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
-    
+
+    def self.inherited(controller)
+      unloadable controller
+    end
+
     # Add observers to specific events or the controller in general. This functionality is similar
     # to the Rails before_filter methods. Observers are stored as Proc objects and have access
     # to the current controller environment.
@@ -42,80 +45,109 @@ module WebsocketRails
         @@observers[:general] << block
       end
     end
-    
+
     # Stores the observer Procs for the current controller. See {observe} for details.
     @@observers = Hash.new {|h,k| h[k] = Array.new}
-    
+
     def initialize
       @data_store = DataStore.new(self)
     end
-    
-    # Provides direct access to the Faye::WebSocket connection object for the client that
+
+    # 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. 
+    # 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
+
     # 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.
-    # 
-    #   # Will arrive on the client as JSON string like the following:
-    #   # ['new_message',{'message': 'new message for the client'}]
-    #   message_hash = {:message => 'new message for the client'}
-    #   send_message :new_message, message_hash
     #
     # To send an event under a namespace, add the `:namespace => :target_namespace` option.
     #
-    #   # Will arrive as: ['product.new_message',{'message': 'new message'}]
     #   send_message :new_message, message_hash, :namespace => :product
     #
     # Nested namespaces can be passed as an array like the following:
     #
-    #   # Will arrive as: ['products.glasses.new',{'message': 'new message'}]
     #   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
-      event = Event.new( 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
-      event = Event.new( 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
       @_request
     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 data_store
       @data_store
     end
-    
+
     private
-    
+
     # Executes the observers that have been defined for this controller. General observers are executed
     # first and event specific observers are executed last. Each will be executed in the order that
     # they have been defined. This method is executed by the {Dispatcher}.
@@ -139,6 +171,6 @@ module WebsocketRails
         super
       end
     end
-    
+
   end
 end

data/lib/websocket_rails/channel.rb

@@ -5,23 +5,32 @@ module WebsocketRails
 
     def initialize(channel_name)
       @subscribers = []
-      @name = channel_name
+      @name        = channel_name
+      @private     = false
     end
 
     def subscribe(connection)
       @subscribers << connection
     end
 
-    def trigger(event_name,data,options={})
-      options.merge! :channel => name
-      event = Event.new event_name, data, options
+    def trigger(event_name,data={})
+      data.merge! :channel => name
+      event = Event.new event_name, data
       send_data event
     end
 
     def trigger_event(event)
       send_data event
     end
-
+    
+    def make_private
+      @private = true
+    end
+    
+    def is_private?
+      @private
+    end
+    
     private
 
     def send_data(event)

data/lib/websocket_rails/channel_manager.rb

@@ -1,3 +1,5 @@
+require 'active_support/hash_with_indifferent_access'
+
 module WebsocketRails
 
   class << self
@@ -17,7 +19,7 @@ module WebsocketRails
     attr_reader :channels
     
     def initialize
-      @channels = Hash.new.with_indifferent_access
+      @channels = HashWithIndifferentAccess.new
     end
 
     def [](channel)

data/lib/websocket_rails/connection_adapters.rb

@@ -16,6 +16,8 @@ module WebsocketRails
     
     class Base
 
+      include Logging
+
       def self.accepts?(env)
         false
       end
@@ -31,9 +33,11 @@ module WebsocketRails
         @request    = request
         @queue      = EventQueue.new
         @dispatcher = dispatcher
+        @connected  = true
         @delegate   = DelegationController.new
         @delegate.instance_variable_set(:@_env,request.env)
         @delegate.instance_variable_set(:@_request,request)
+        start_ping_timer
       end
 
       def on_open(data=nil)
@@ -43,7 +47,8 @@ module WebsocketRails
       end
 
       def on_message(encoded_data)
-        dispatch Event.new_from_json( encoded_data, self )
+        event = Event.new_from_json( encoded_data, self )
+        dispatch event
       end
 
       def on_close(data=nil)
@@ -61,19 +66,25 @@ module WebsocketRails
         @queue << event
       end
 
+      attr_accessor :flush_scheduled
+
       def trigger(event)
-        enqueue event
-        unless flush_scheduled
-          EM.next_tick { flush; flush_scheduled = false }
-          flush_scheduled = true
-        end
+        # 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 = "["
         @queue.flush do |event|
           message << event.serialize
-          message << "," unless event == @queue.last
+          message << "," unless count == @queue.size
+          count += 1
         end
         message << "]"
         send message
@@ -105,13 +116,24 @@ module WebsocketRails
         dispatcher.connection_manager.close_connection self
       end
 
-      def flush_scheduled
-        @flush_scheduled
+      attr_accessor :pong
+      public :pong, :pong=
+
+      def start_ping_timer
+        @pong = true
+        @ping_timer = EM::PeriodicTimer.new(10) do
+          log "ping"
+          if pong == true
+            self.pong = false
+            ping = Event.new_on_ping self
+            trigger ping
+          else
+            @ping_timer.cancel
+            on_error
+          end
+        end
       end
 
-      def flush_scheduled=(value)
-        @flush_scheduled = value
-      end
     end
     
   end

data/lib/websocket_rails/connection_manager.rb

@@ -7,6 +7,8 @@ module WebsocketRails
   # incoming WebSocket connections.
   class ConnectionManager
 
+    include Logging
+
     SuccessfulResponse = [200,{'Content-Type' => 'text/plain'},['success']].freeze
     BadRequestResponse = [400,{'Content-Type' => 'text/plain'},['invalid']].freeze
     ExceptionResponse  = [500,{'Content-Type' => 'text/plain'},['exception']].freeze
@@ -56,11 +58,13 @@ module WebsocketRails
     def open_connection(request)
       connection = ConnectionAdapters.establish_connection( request, dispatcher )
       connections << connection
+      log "Connection opened: #{connection}"
       connection.rack_response
     end
 
     def close_connection(connection)
       connections.delete connection
+      log "Connection closed: #{connection}"
       connection = nil
     end
     public :close_connection

data/lib/websocket_rails/dispatcher.rb

@@ -2,6 +2,8 @@
 
 module WebsocketRails
   class Dispatcher
+
+    include Logging
     
     attr_reader :event_map, :connection_manager
     
@@ -21,6 +23,7 @@ module WebsocketRails
     end
     
     def dispatch(event)
+      log "Event received: #{event.name}"
       if event.is_channel?
         WebsocketRails[event.channel].trigger_event event
       else
@@ -38,6 +41,10 @@ module WebsocketRails
       end
     end
 
+    def reload_controllers!
+      @event_map.reload_controllers!
+    end
+
     private
 
     def route(event)
@@ -47,9 +54,13 @@ module WebsocketRails
           begin
             controller.instance_variable_set(:@_event,event)
             controller.send :execute_observers, event.name if controller.respond_to?(:execute_observers)
-            controller.send method if controller.respond_to?(method)
-          rescue Exception => e
-            puts "Application Exception: #{e.inspect}"
+            result = controller.send method if controller.respond_to?(method)
+          rescue Exception => ex
+            puts ex.backtrace
+            puts "Application Exception: #{ex}"
+            event.success = false
+            event.data = extract_exception_data ex
+            event.trigger
           end
         end
       end
@@ -62,5 +73,18 @@ module WebsocketRails
       end
     end
 
+    def extract_exception_data(ex)
+      case ex
+      when 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
+
   end
 end

data/lib/websocket_rails/engine.rb

@@ -2,14 +2,11 @@ module WebsocketRails
   
   class Engine < Rails::Engine
     initializer "websocket_rails.load_app_instance_data" do |app|
+      paths['app/controllers'] = 'app/controllers'
       WebsocketRails.setup do |config|
         config.app_root = app.root
       end
       app.config.autoload_paths += [File.expand_path("../../lib", __FILE__)]
     end
-    
-    initializer "websocket_rails.load_static_assets" do |app|
-      app.middleware.use ::ActionDispatch::Static, "#{root}/public"
-    end    
   end
-end
+end