wwl-websocket-rails 0.7.1

data/bin/thin-socketrails

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+# * Borrowed from the <tt>websocket-rack</tt>
+#   Gem as a temporary workaround for the
+#   timeout problem.
+#
+# Modified Thin command line interface script.
+# This is fallback for WebSocket-Rack.
+# Use it when you have EventMachine version < 1.0.0
+# Rationale:
+#   Older versions of EM have bug that prevent to
+#   clearing connection inactivity once it's set.
+#   This one will set connection timeout to 0 at
+#   default, so there will be no need to overwrite it.
+#   Be aware that this will also change inactivity
+#   timeout for "normal" connection, so it will be
+#   easy to make DoS attack.
+
+require 'rubygems'
+require 'thin'
+
+puts <<END
+*** Deprecation Notice***
+
+The thin-socketrails executable is now deprecated and
+will be removed in the next release. 
+
+You may use the regular thin executable to launch the 
+server now. 
+
+Other EventMachine based web servers should now be
+supported but have not yet been tested.
+
+*************************
+END
+
+if EM::VERSION < "1.0.0"
+  begin
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    ::Thin::Server.const_set 'DEFAULT_TIMEOUT', 0
+  ensure
+    $VERBOSE = old_verbose
+  end
+end
+
+Thin::Runner.new(ARGV).run!

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

@@ -0,0 +1,45 @@
+###
+ Abstract Interface for the WebSocketRails client.
+###
+class WebSocketRails.AbstractConnection
+
+  constructor: (url, @dispatcher) ->
+    @message_queue   = []
+
+  close: ->
+
+  trigger: (event) ->
+    if @dispatcher.state != 'connected'
+      @message_queue.push event
+    else
+      @send_event event
+
+  send_event: (event) ->
+    # Events queued before connecting do not have the correct
+    # connection_id set yet. We need to update it before dispatching.
+    event.connection_id = @connection_id if @connection_id?
+
+    # ...
+    
+  on_close: (event) ->
+    if @dispatcher && @dispatcher._conn == @
+      close_event = new WebSocketRails.Event(['connection_closed', event])
+      @dispatcher.state = 'disconnected'
+      @dispatcher.dispatch close_event
+
+  on_error: (event) ->
+    if @dispatcher && @dispatcher._conn == @
+      error_event = new WebSocketRails.Event(['connection_error', event])
+      @dispatcher.state = 'disconnected'
+      @dispatcher.dispatch error_event
+
+  on_message: (event_data) ->
+    if @dispatcher && @dispatcher._conn == @
+      @dispatcher.new_message event_data
+
+  setConnectionId: (@connection_id) ->
+
+  flush_queue: ->
+    for event in @message_queue
+      @trigger event
+    @message_queue = []

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

@@ -0,0 +1,70 @@
+###
+The channel object is returned when you subscribe to a channel.
+
+For instance:
+  var dispatcher = new WebSocketRails('localhost:3000/websocket');
+  var awesome_channel = dispatcher.subscribe('awesome_channel');
+  awesome_channel.bind('event', function(data) { console.log('channel event!'); });
+  awesome_channel.trigger('awesome_event', awesome_object);
+
+If you want to unbind an event, you can use the unbind function :
+  awesome_channel.unbind('event')
+###
+class WebSocketRails.Channel
+
+  constructor: (@name, @_dispatcher, @is_private = false, @on_success, @on_failure) ->
+    @_callbacks = {}
+    @_token = undefined
+    @_queue = []
+    if @is_private
+      event_name = 'websocket_rails.subscribe_private'
+    else
+      event_name = 'websocket_rails.subscribe'
+
+    @connection_id = @_dispatcher._conn?.connection_id
+    event = new WebSocketRails.Event( [event_name, {data: {channel: @name}}, @connection_id], @_success_launcher, @_failure_launcher)
+    @_dispatcher.trigger_event event
+
+  destroy: ->
+    if @connection_id == @_dispatcher._conn?.connection_id
+      event_name = 'websocket_rails.unsubscribe'
+      event =  new WebSocketRails.Event( [event_name, {data: {channel: @name}}, @connection_id] )
+      @_dispatcher.trigger_event event
+    @_callbacks = {}
+
+  bind: (event_name, callback) ->
+    @_callbacks[event_name] ?= []
+    @_callbacks[event_name].push callback
+
+  unbind: (event_name) ->
+    delete @_callbacks[event_name]
+
+  trigger: (event_name, message) ->
+    event = new WebSocketRails.Event( [event_name, {channel: @name, data: message, token: @_token}, @connection_id] )
+    if !@_token
+      @_queue.push event
+    else
+      @_dispatcher.trigger_event event
+
+  dispatch: (event_name, message) ->
+    if event_name == 'websocket_rails.channel_token'
+      @connection_id = @_dispatcher._conn?.connection_id
+      @_token = message['token']
+      @flush_queue()
+    else
+      return unless @_callbacks[event_name]?
+      for callback in @_callbacks[event_name]
+        callback message
+
+  # using this method because @on_success will not be defined when the constructor is executed
+  _success_launcher: (data) =>
+    @on_success(data) if @on_success?
+
+  # using this method because @on_failure will not be defined when the constructor is executed
+  _failure_launcher: (data) =>
+    @on_failure(data) if @on_failure?
+
+  flush_queue: ->
+    for event in @_queue
+      @_dispatcher.trigger_event event
+    @_queue = []

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

@@ -0,0 +1,46 @@
+###
+The Event object stores all the relevant event information.
+###
+
+class WebSocketRails.Event
+
+  SUCCEEDED: 0
+  FAILED: 1
+  FINISHED_WITHOUT_FAILURE: 2
+
+  constructor: (data, @success_callback, @failure_callback) ->
+    @name    = data[0]
+    attr     = data[1]
+    if attr?
+      @id      = if attr['id']? then attr['id'] else (((1+Math.random())*0x10000)|0)
+      @channel = if attr.channel? then attr.channel
+      @data    = if attr.data? then attr.data else attr
+      @token   = if attr.token? then attr.token
+      @connection_id = data[2]
+      if attr.success?
+        @result  = true
+        @success = attr.success
+
+  is_channel: ->
+    @channel?
+
+  is_result: ->
+    typeof @result != 'undefined'
+
+  is_ping: ->
+    @name == 'websocket_rails.ping'
+
+  serialize: ->
+      JSON.stringify [@name, @attributes()]
+
+  attributes: ->
+    id: @id,
+    channel: @channel,
+    data: @data
+    token: @token
+
+  run_callbacks: (@success, @result) ->
+    if @success == @SUCCEEDED
+      @success_callback?(@result)
+    else if @success == @FAILED
+      @failure_callback?(@result)

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

@@ -0,0 +1,66 @@
+###
+ HTTP Interface for the WebSocketRails client.
+###
+class WebSocketRails.HttpConnection extends WebSocketRails.AbstractConnection
+  connection_type: 'http'
+
+  _httpFactories: -> [
+    -> new XDomainRequest(),
+    -> new XMLHttpRequest(),
+    -> new ActiveXObject("Msxml2.XMLHTTP"),
+    -> new ActiveXObject("Msxml3.XMLHTTP"),
+    -> new ActiveXObject("Microsoft.XMLHTTP")
+  ]
+
+  constructor: (url, @dispatcher) ->
+    super
+    @_url          = "http://#{url}"
+    @_conn         = @_createXMLHttpObject()
+    @last_pos      = 0
+    try
+      @_conn.onreadystatechange = => @_parse_stream()
+      @_conn.addEventListener("load", @on_close, false)
+    catch e
+      @_conn.onprogress = => @_parse_stream()
+      @_conn.onload = @on_close
+      # set this as 3 always for parse_stream as the object does not have this property at all
+      @_conn.readyState = 3
+    @_conn.open "GET", @_url, true
+    @_conn.send()
+
+  close: ->
+    @_conn.abort()
+
+  send_event: (event) ->
+    super
+    @_post_data event.serialize()
+
+  _post_data: (payload) ->
+    $.ajax @_url,
+      type: 'POST'
+      data:
+        client_id: @connection_id
+        data: payload
+      success: ->
+
+  _createXMLHttpObject: ->
+    xmlhttp   = false
+    factories = @_httpFactories()
+    for factory in factories
+      try
+        xmlhttp = factory()
+      catch e
+        continue
+      break
+    xmlhttp
+
+  _parse_stream: ->
+    if @_conn.readyState == 3
+      data         = @_conn.responseText.substring @last_pos
+      @last_pos    = @_conn.responseText.length
+      data = data.replace( /\]\]\[\[/g, "],[" )
+      try
+        event_data = JSON.parse data
+        @on_message(event_data)
+      catch e
+        # just ignore if it cannot be parsed, probably whitespace

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

@@ -0,0 +1,6 @@
+//= require ./websocket_rails
+//= require ./event
+//= require ./abstract_connection
+//= require ./http_connection
+//= require ./websocket_connection
+//= require ./channel

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

@@ -0,0 +1,29 @@
+###
+WebSocket Interface for the WebSocketRails client.
+###
+class WebSocketRails.WebSocketConnection extends WebSocketRails.AbstractConnection
+  connection_type: 'websocket'
+  
+  constructor: (@url, @dispatcher) ->
+    super
+    if @url.match(/^wss?:\/\//)
+        console.log "WARNING: Using connection urls with protocol specified is depricated"
+    else if window.location.protocol == 'https:'
+        @url             = "wss://#{@url}"
+    else
+        @url             = "ws://#{@url}"
+    @_conn           = new WebSocket(@url)
+    @_conn.onmessage = (event) => 
+      event_data = JSON.parse event.data
+      @on_message(event_data)
+    @_conn.onclose   = (event) => 
+      @on_close(event)
+    @_conn.onerror   = (event) => 
+      @on_error(event)
+
+  close: ->
+    @_conn.close()
+
+  send_event: (event) ->
+    super
+    @_conn.send event.serialize()

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

@@ -0,0 +1,158 @@
+###
+WebsocketRails JavaScript Client
+
+Setting up the dispatcher:
+  var dispatcher = new WebSocketRails('localhost:3000/websocket');
+  dispatcher.on_open = function() {
+    // trigger a server event immediately after opening connection
+    dispatcher.trigger('new_user',{user_name: 'guest'});
+  })
+
+Triggering a new event on the server
+  dispatcherer.trigger('event_name',object_to_be_serialized_to_json);
+
+Listening for new events from the server
+  dispatcher.bind('event_name', function(data) {
+    console.log(data.user_name);
+  });
+
+Stop listening for new events from the server
+  dispatcher.unbind('event')
+###
+class @WebSocketRails
+  constructor: (@url, @use_websockets = true) ->
+    @callbacks = {}
+    @channels  = {}
+    @queue     = {}
+
+    @connect()
+
+  connect: ->
+    @state = 'connecting'
+
+    unless @supports_websockets() and @use_websockets
+      @_conn = new WebSocketRails.HttpConnection @url, @
+    else
+      @_conn = new WebSocketRails.WebSocketConnection @url, @
+
+    @_conn.new_message = @new_message
+
+  disconnect: ->
+    if @_conn
+      @_conn.close()
+      delete @_conn._conn
+      delete @_conn
+
+    @state     = 'disconnected'
+
+  # Reconnects the whole connection, 
+  # keeping the messages queue and its' connected channels.
+  # 
+  # After successfull connection, this will:
+  # - reconnect to all channels, that were active while disconnecting
+  # - resend all events from which we haven't received any response yet
+  reconnect: =>
+    old_connection_id = @_conn?.connection_id
+
+    @disconnect()
+    @connect()
+
+    # Resend all unfinished events from the previous connection.
+    for id, event of @queue
+      if event.connection_id == old_connection_id && !event.is_result()
+        @trigger_event event
+
+    @reconnect_channels()
+
+  new_message: (data) =>
+    for socket_message in data
+      event = new WebSocketRails.Event( socket_message )
+      if event.is_result()
+        @queue[event.id]?.run_callbacks(event.success, event.data)
+        delete @queue[event.id]
+      else if event.is_channel()
+        @dispatch_channel event
+      else if event.is_ping()
+        @pong()
+      else
+        @dispatch event
+
+      if @state == 'connecting' and event.name == 'client_connected'
+        @connection_established event.data
+
+  connection_established: (data) =>
+    @state         = 'connected'
+    @_conn.setConnectionId(data.connection_id)
+    @_conn.flush_queue()
+    if @on_open?
+      @on_open(data)
+
+  bind: (event_name, callback) =>
+    @callbacks[event_name] ?= []
+    @callbacks[event_name].push callback
+
+  unbind: (event_name) =>
+    delete @callbacks[event_name]
+
+  trigger: (event_name, data, success_callback, failure_callback) =>
+    event = new WebSocketRails.Event( [event_name, data, @_conn?.connection_id], success_callback, failure_callback )
+    @trigger_event event
+
+  trigger_event: (event) =>
+    @queue[event.id] ?= event # Prevent replacing an event that has callbacks stored
+    @_conn.trigger event if @_conn
+    event
+
+  dispatch: (event) =>
+    return unless @callbacks[event.name]?
+    for callback in @callbacks[event.name]
+      callback event.data
+
+  subscribe: (channel_name, success_callback, failure_callback) =>
+    unless @channels[channel_name]?
+      channel = new WebSocketRails.Channel channel_name, @, false, success_callback, failure_callback
+      @channels[channel_name] = channel
+      channel
+    else
+      @channels[channel_name]
+
+  subscribe_private: (channel_name, success_callback, failure_callback) =>
+    unless @channels[channel_name]?
+      channel = new WebSocketRails.Channel channel_name, @, true, success_callback, failure_callback
+      @channels[channel_name] = channel
+      channel
+    else
+      @channels[channel_name]
+
+  unsubscribe: (channel_name) =>
+    return unless @channels[channel_name]?
+    @channels[channel_name].destroy()
+    delete @channels[channel_name]
+
+  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', {}, @_conn?.connection_id] )
+    @_conn.trigger pong
+
+  connection_stale: =>
+    @state != 'connected'
+
+  # Destroy and resubscribe to all existing @channels.
+  reconnect_channels: ->
+    for name, channel of @channels
+      callbacks = channel._callbacks
+      channel.destroy()
+      delete @channels[name]
+
+      channel = if channel.is_private
+        @subscribe_private name
+      else
+        @subscribe name
+      channel._callbacks = callbacks
+      channel

data/lib/config.ru

@@ -0,0 +1,3 @@
+require "websocket-rails"
+
+run WebsocketRails::ConnectionManager.new

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

@@ -0,0 +1,33 @@
+require 'rails'
+
+module WebsocketRails
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("../templates", __FILE__)
+
+      desc "Create the events.rb initializer and require the JS client in the application.js manifest."
+
+      class_option :manifest, :type => :string, :aliases => "-m", :default => 'application.js',
+                   :desc => "Javascript manifest file to modify (or create)"
+
+      def create_events_initializer_file
+        template 'events.rb', File.join('config', 'events.rb')
+        template 'websocket_rails.rb', File.join('config', 'initializers', 'websocket_rails.rb')
+      end
+
+      def inject_websocket_rails_client
+        manifest = options[:manifest]
+        js_path  = "app/assets/javascripts"
+
+        create_file("#{js_path}/#{manifest}") unless File.exists?("#{js_path}/#{manifest}")
+
+        append_to_file "#{js_path}/#{manifest}" do
+          out = ""
+          out << "//= require websocket_rails/main"
+          out << "\n"
+          out << "\n"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+WebsocketRails::EventMap.describe do
+  # You can use this file to map incoming events to controller actions.
+  # One event can be mapped to any number of controller actions. The
+  # actions will be executed in the order they were subscribed.
+  #
+  # Uncomment and edit the next line to handle the client connected event:
+  #   subscribe :client_connected, :to => Controller, :with_method => :method_name
+  #
+  # Here is an example of mapping namespaced events:
+  #   namespace :product do
+  #     subscribe :new, :to => ProductController, :with_method => :new_product
+  #   end
+  # The above will handle an event triggered on the client like `product.new`.
+end

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

@@ -0,0 +1,68 @@
+WebsocketRails.setup do |config|
+
+  # Uncomment to override the default log level. The log level can be
+  # any of the standard Logger log levels. By default it will mirror the
+  # current Rails environment log level.
+  # config.log_level = :debug
+
+  # Uncomment to change the default log file path.
+  # config.log_path = "#{Rails.root}/log/websocket_rails.log"
+
+  # Set to true if you wish to log the internal websocket_rails events
+  # such as the keepalive `websocket_rails.ping` event.
+  # config.log_internal_events = false
+
+  # Change to true to enable standalone server mode
+  # Start the standalone server with rake websocket_rails:start_server
+  # * Requires Redis
+  config.standalone = false
+
+  # Change to true to enable channel synchronization between
+  # multiple server instances.
+  # * Requires Redis.
+  config.synchronize = false
+
+  # Prevent Thin from daemonizing (default is true)
+  # config.daemonize = false
+
+  # Uncomment and edit to point to a different redis instance.
+  # Will not be used unless standalone or synchronization mode
+  # is enabled.
+  # config.redis_options = {:host => 'localhost', :port => '6379'}
+
+  # By default, all subscribers in to a channel will be removed
+  # when that channel is made private. If you don't wish active
+  # subscribers to be removed from a previously public channel
+  # when making it private, set the following to true.
+  # config.keep_subscribers_when_private = false
+
+  # Set to true if you wish to broadcast channel subscriber_join and
+  # subscriber_part events. All subscribers of a channel will be 
+  # notified when other clients join and part the channel. If you are
+  # using the UserManager, the current_user object will be sent along
+  # with the event.
+  # config.broadcast_subscriber_events = true
+
+  # Used as the key for the WebsocketRails.users Hash. This method
+  # will be called on the `current_user` object in your controller
+  # 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
+
+  # Supporting HTTP streaming on Internet Explorer versions 8 & 9
+  # requires CORS to be enabled for GET "/websocket" request.
+  # List here the origin domains allowed to perform the request.
+  # config.allowed_origins = ['http://localhost:3000']
+
+  # Uncomment this option to change the default behavior when 
+  # trigger_success or trigger_failure are not called in the action
+  # of the WebsocketController. (default is true)
+  # confid.trigger_success_by_default = false
+
+end

data/lib/rails/app/controllers/websocket_rails/delegation_controller.rb

@@ -0,0 +1,13 @@
+module WebsocketRails
+  # This class provides a means for accessing the Rails
+  # controller helper methods defined in a user's application
+  # or in gems that the user has added to the project.
+  #
+  # Each active connection creates and stores it's own
+  # instance with the correct @_request and @_env objects
+  # set. WebsocketRails::BaseController sends missing
+  # methods to the active connection's delegation controller
+  # instance.
+  class DelegationController < ApplicationController
+  end
+end

data/lib/rails/config/routes.rb

@@ -0,0 +1,7 @@
+Rails.application.routes.draw do
+  if Rails.version >= '4.0.0'
+    match "/websocket", :to => WebsocketRails::ConnectionManager.new, via: [:get, :post]
+  else
+    match "/websocket", :to => WebsocketRails::ConnectionManager.new
+  end
+end

data/lib/rails/tasks/websocket_rails.tasks

@@ -0,0 +1,42 @@
+namespace :websocket_rails do
+  desc 'Start the WebsocketRails standalone server.'
+  task :start_server do
+    require "thin"
+    load "#{Rails.root}/config/initializers/websocket_rails.rb"
+    load "#{Rails.root}/config/events.rb"
+
+    options = WebsocketRails.config.thin_options
+
+    warn_if_standalone_not_enabled!
+
+    if options[:daemonize]
+      fork do
+        Thin::Controllers::Controller.new(options).start
+      end
+    else
+        Thin::Controllers::Controller.new(options).start
+    end
+
+    puts "Websocket Rails Standalone Server listening on port #{options[:port]}"
+  end
+
+  desc 'Stop the WebsocketRails standalone server.'
+  task :stop_server do
+    require "thin"
+    load "#{Rails.root}/config/initializers/websocket_rails.rb"
+    load "#{Rails.root}/config/events.rb"
+
+    options = WebsocketRails.config.thin_options
+
+    warn_if_standalone_not_enabled!
+
+    Thin::Controllers::Controller.new(options).stop
+  end
+end
+
+def warn_if_standalone_not_enabled!
+  return if WebsocketRails.standalone?
+  puts "Fail!"
+  puts "You must enable standalone mode in your websocket_rails.rb initializer to use the standalone server."
+  exit 1
+end