wwl-websocket-rails 0.7.1

data/lib/websocket_rails/configuration.rb

@@ -0,0 +1,177 @@
+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
+
+    def trigger_success_by_default
+      @trigger_success_by_default ||= true
+    end
+
+    def trigger_success_by_default= value
+      @trigger_success_by_default = value
+    end
+
+  end
+end

data/lib/websocket_rails/connection_adapters/http.rb

@@ -0,0 +1,120 @@
+module WebsocketRails
+  module ConnectionAdapters
+    class Http < Base
+      TERM = "\r\n".freeze
+      TAIL = "0#{TERM}#{TERM}".freeze
+      HttpHeaders = {
+        'Content-Type'      => 'text/json',
+        'Transfer-Encoding' => 'chunked'
+      }
+
+      def self.accepts?(env)
+        true
+      end
+
+      attr_accessor :headers
+
+      def initialize(env,dispatcher)
+        super
+        @body = DeferrableBody.new
+        @headers = HttpHeaders
+
+        define_deferrable_callbacks
+
+        origin = "#{request.protocol}#{request.raw_host_with_port}"
+        @headers.merge!({'Access-Control-Allow-Origin' => origin}) if WebsocketRails.config.allowed_origins.include?(origin)
+        # IE < 10.0 hack
+        # XDomainRequest will not bubble up notifications of download progress in the first 2kb of the response
+        # http://blogs.msdn.com/b/ieinternals/archive/2010/04/06/comet-streaming-in-internet-explorer-with-xmlhttprequest-and-xdomainrequest.aspx
+        @body.chunk(encode_chunk(" " * 2048))
+
+        EM.next_tick do
+          @env['async.callback'].call [200, @headers, @body]
+          on_open
+        end
+      end
+
+      def send(message)
+        @body.chunk encode_chunk( message )
+      end
+
+      def close!
+        @body.close!
+      end
+
+      private
+
+      def define_deferrable_callbacks
+        @body.callback do |event|
+          on_close(event)
+        end
+        @body.errback do |event|
+          on_close(event)
+        end
+      end
+
+      # From [Rack::Stream](https://github.com/intridea/rack-stream)
+      def encode_chunk(c)
+        return nil if c.nil?
+        # hack to work with Rack::File for now, should not TE chunked
+        # things that aren't strings or respond to bytesize
+        c = ::File.read(c.path) if c.kind_of?(Rack::File)
+        size = Rack::Utils.bytesize(c)
+        return nil if size == 0
+        c.dup.force_encoding(Encoding::BINARY) if c.respond_to?(:force_encoding)
+        [size.to_s(16), TERM, c, TERM].join
+      end
+
+      # From [thin_async](https://github.com/macournoyer/thin_async)
+      class DeferrableBody
+        include EM::Deferrable
+
+        # @param chunks - object that responds to each. holds initial chunks of content
+        def initialize(chunks = [])
+          @queue = []
+          chunks.each {|c| chunk(c)}
+        end
+
+        # Enqueue a chunk of content to be flushed to stream at a later time
+        def chunk(*chunks)
+          @queue += chunks
+          schedule_dequeue
+        end
+
+        # When rack attempts to iterate over `body`, save the block,
+        # and execute at a later time when `@queue` has elements
+        def each(&blk)
+          @body_callback = blk
+          schedule_dequeue
+        end
+
+        def empty?
+          @queue.empty?
+        end
+
+        def close!(flush = true)
+          EM.next_tick {
+            if !flush || empty?
+              succeed
+            else
+              schedule_dequeue
+              close!(flush)
+            end
+          }
+        end
+
+        private
+
+        def schedule_dequeue
+          return unless @body_callback
+          EM.next_tick do
+            next unless c = @queue.shift
+            @body_callback.call(c)
+            schedule_dequeue unless empty?
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/websocket_rails/connection_adapters/web_socket.rb

@@ -0,0 +1,35 @@
+module WebsocketRails
+  module ConnectionAdapters
+    class WebSocket < Base
+
+      def self.accepts?(env)
+        Faye::WebSocket.websocket?( env )
+      end
+
+      def initialize(request, dispatcher)
+        super
+        @connection = Faye::WebSocket.new(request.env)
+        @connection.onmessage = method(:on_message)
+        @connection.onerror   = method(:on_error)
+        @connection.onclose   = method(:on_close)
+        EM.next_tick do
+          on_open
+        end
+      end
+
+      def send(message)
+        @connection.send message
+      end
+
+      def on_message(event)
+        data = event.respond_to?(:data) ? event.data : event
+        super data
+      end
+
+      def close!
+        @connection.close
+      end
+
+    end
+  end
+end

data/lib/websocket_rails/connection_adapters.rb

@@ -0,0 +1,195 @@
+module WebsocketRails
+  module ConnectionAdapters
+
+    attr_reader :adapters
+    module_function :adapters
+
+    def self.register(adapter)
+      @adapters ||= []
+      @adapters.unshift adapter
+    end
+
+    def self.establish_connection(request, dispatcher)
+      adapter = adapters.detect { |a| a.accepts?(request.env) } || raise(InvalidConnectionError)
+      adapter.new request, dispatcher
+    end
+
+    class Base
+
+      include Logging
+
+      def self.accepts?(env)
+        false
+      end
+
+      def self.inherited(adapter)
+        ConnectionAdapters.register adapter
+      end
+
+      attr_reader :dispatcher, :queue, :env, :request, :data_store
+
+      # The ConnectionManager will set the connection ID when the
+      # connection is opened.
+      attr_accessor :id
+
+      def initialize(request, dispatcher)
+        @env        = request.env.dup
+        @request    = request
+        @dispatcher = dispatcher
+        @connected  = true
+        @queue      = EventQueue.new
+        @data_store = DataStore::Connection.new(self)
+        @delegate   = WebsocketRails::DelegationController.new
+        @delegate.instance_variable_set(:@_env, request.env)
+        @delegate.instance_variable_set(:@_request, request)
+
+        start_ping_timer
+      end
+
+      def on_open(data=nil)
+        event = Event.new_on_open( self, data )
+        dispatch event
+        trigger event
+      end
+
+      def on_message(encoded_data)
+        event = Event.new_from_json( encoded_data, self )
+        dispatch event
+      end
+
+      def on_close(data=nil)
+        @ping_timer.try(:cancel)
+        dispatch Event.new_on_close( self, data )
+        close_connection
+      end
+
+      def on_error(data=nil)
+        event = Event.new_on_error( self, data )
+        dispatch event
+        on_close event.data
+      end
+
+      def enqueue(event)
+        @queue << event
+      end
+
+      def trigger(event)
+        send "[#{event.serialize}]"
+      end
+
+      def flush
+        message = []
+        @queue.flush do |event|
+          message << event.as_json
+        end
+        send message.to_json
+      end
+
+      def send_message(event_name, data = {}, options = {})
+        options.merge! :user_id => user_identifier, :connection => self
+        options[:data] = data
+
+        event = Event.new(event_name, options)
+        event.trigger
+      end
+
+      def send(message)
+        raise NotImplementedError, "Override this method in the connection specific adapter class"
+      end
+
+      def rack_response
+        [ -1, {}, [] ]
+      end
+
+      def controller_delegate
+        @delegate
+      end
+
+      def connected?
+        true & @connected
+      end
+
+      def inspect
+        "#<Connection::#{id}>"
+      end
+
+      def to_s
+        inspect
+      end
+
+      def user_connection?
+        not user_identifier.nil?
+      end
+
+      def user
+        return unless user_connection?
+        controller_delegate.current_user
+      end
+
+      def user_identifier
+        @user_identifier ||= begin
+          identifier = WebsocketRails.config.user_identifier
+
+          return unless current_user_responds_to?(identifier)
+
+          controller_delegate.current_user.send(identifier)
+         end
+      end
+
+      def ping_interval
+        @ping_interval ||= WebsocketRails.config.default_ping_interval
+      end
+
+      def ping_interval=(interval)
+        @ping_interval = interval.to_i
+        @ping_timer.try(:cancel)
+        start_ping_timer
+      end
+
+      private
+
+      def dispatch(event)
+        dispatcher.dispatch event
+      end
+
+      def connection_manager
+        dispatcher.connection_manager
+      end
+
+      def close_connection
+        @data_store.destroy!
+        @ping_timer.try(:cancel)
+        dispatcher.connection_manager.close_connection self
+      end
+
+      def current_user_responds_to?(identifier)
+        controller_delegate                            &&
+        controller_delegate.respond_to?(:current_user) &&
+        controller_delegate.current_user               &&
+        controller_delegate.current_user.respond_to?(identifier)
+      end
+
+      attr_accessor :pong
+      public :pong, :pong=
+
+      def start_ping_timer
+        @pong = true
+
+        # Set negative interval to nil to deactivate periodic pings
+        if ping_interval > 0
+          @ping_timer = EM::PeriodicTimer.new(ping_interval) do
+            if pong == true
+              self.pong = false
+              ping = Event.new_on_ping self
+              trigger ping
+            else
+              @ping_timer.cancel
+              on_error
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/websocket_rails/connection_manager.rb

@@ -0,0 +1,119 @@
+require 'faye/websocket'
+require 'rack'
+require 'thin'
+
+Faye::WebSocket.load_adapter('thin')
+
+module WebsocketRails
+  # The +ConnectionManager+ class implements the core Rack application that handles
+  # 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
+
+    # Contains a Hash of currently open connections.
+    # @return [Hash]
+    attr_reader :connections
+
+    # Contains the {Dispatcher} instance for the active server.
+    # @return [Dispatcher]
+    attr_reader :dispatcher
+
+    # Contains the {Synchronization} instance for the active server.
+    # @return [Synchronization]
+    attr_reader :synchronization
+
+    def initialize
+      @connections = {}
+      @dispatcher  = Dispatcher.new(self)
+
+      if WebsocketRails.synchronize?
+        EM.next_tick do
+          Fiber.new {
+            Synchronization.synchronize!
+            EM.add_shutdown_hook { Synchronization.shutdown! }
+          }.resume
+        end
+      end
+    end
+
+    def inspect
+      "websocket_rails"
+    end
+
+    # Primary entry point for the Rack application
+    def call(env)
+      request = ActionDispatch::Request.new(env)
+
+      if request.post?
+        response = parse_incoming_event(request.params)
+      else
+        response = open_connection(request)
+      end
+
+      response
+    rescue InvalidConnectionError
+      BadRequestResponse
+    end
+
+    private
+
+    def parse_incoming_event(params)
+      connection = find_connection_by_id(params["client_id"])
+      connection.on_message params["data"]
+      SuccessfulResponse
+    end
+
+    def find_connection_by_id(id)
+      connections[id] || raise(InvalidConnectionError)
+    end
+
+    # Opens a persistent connection using the appropriate {ConnectionAdapter}. Stores
+    # active connections in the {connections} Hash.
+    def open_connection(request)
+      connection = ConnectionAdapters.establish_connection(request, dispatcher)
+
+      assign_connection_id connection
+      register_user_connection connection
+
+      connections[connection.id] = connection
+
+      info "Connection opened: #{connection}"
+      connection.rack_response
+    end
+
+    def close_connection(connection)
+      WebsocketRails.channel_manager.unsubscribe connection
+      destroy_user_connection connection
+
+      connections.delete connection.id
+
+      info "Connection closed: #{connection}"
+      connection = nil
+    end
+    public :close_connection
+
+    def assign_connection_id(connection)
+      begin
+        id = SecureRandom.hex(10)
+      end while connections.has_key?(id)
+
+      connection.id = id
+    end
+
+    def register_user_connection(connection)
+      return unless connection.user_connection?
+      WebsocketRails.users[connection.user_identifier] = connection
+    end
+
+    def destroy_user_connection(connection)
+      return unless connection.user_connection?
+      WebsocketRails.users.delete(connection)
+    end
+
+  end
+end