actioncable 5.0.0.beta3 → 5.0.0.beta4

data/lib/action_cable/connection/client_socket.rb

@@ -29,10 +29,10 @@ module ActionCable
 
       attr_reader :env, :url
 
-      def initialize(env, event_target, stream_event_loop)
-        @env               = env
-        @event_target      = event_target
-        @stream_event_loop = stream_event_loop
+      def initialize(env, event_target, event_loop, protocols)
+        @env          = env
+        @event_target = event_target
+        @event_loop   = event_loop
 
         @url = ClientSocket.determine_url(@env)
 
@@ -42,22 +42,24 @@ module ActionCable
         @ready_state = CONNECTING
 
         # The driver calls +env+, +url+, and +write+
-        @driver = ::WebSocket::Driver.rack(self)
+        @driver = ::WebSocket::Driver.rack(self, protocols: protocols)
 
         @driver.on(:open)    { |e| open }
         @driver.on(:message) { |e| receive_message(e.data) }
         @driver.on(:close)   { |e| begin_close(e.reason, e.code) }
         @driver.on(:error)   { |e| emit_error(e.message) }
 
-        @stream = ActionCable::Connection::Stream.new(@stream_event_loop, self)
+        @stream = ActionCable::Connection::Stream.new(@event_loop, self)
+      end
+
+      def start_driver
+        return if @driver.nil? || @driver_started
+        @stream.hijack_rack_socket
 
         if callback = @env['async.callback']
           callback.call([101, {}, @stream])
         end
-      end
 
-      def start_driver
-        return if @driver.nil? || @driver_started
         @driver_started = true
         @driver.start
       end
@@ -69,6 +71,8 @@ module ActionCable
 
       def write(data)
         @stream.write(data)
+      rescue => e
+        emit_error e.message
       end
 
       def transmit(message)
@@ -107,6 +111,10 @@ module ActionCable
         @ready_state == OPEN
       end
 
+      def protocol
+        @driver.protocol
+      end
+
       private
         def open
           return unless @ready_state == CONNECTING

data/lib/action_cable/connection/faye_client_socket.rb

@@ -0,0 +1,48 @@
+require 'faye/websocket'
+
+module ActionCable
+  module Connection
+    class FayeClientSocket
+      def initialize(env, event_target, stream_event_loop, protocols)
+        @env = env
+        @event_target = event_target
+        @protocols = protocols
+
+        @faye = nil
+      end
+
+      def alive?
+        @faye && @faye.ready_state == Faye::WebSocket::API::OPEN
+      end
+
+      def transmit(data)
+        connect
+        @faye.send data
+      end
+
+      def close
+        @faye && @faye.close
+      end
+
+      def protocol
+        @faye && @faye.protocol
+      end
+
+      def rack_response
+        connect
+        @faye.rack_response
+      end
+
+      private
+        def connect
+          return if @faye
+          @faye = Faye::WebSocket.new(@env, @protocols)
+
+          @faye.on(:open)    { |event| @event_target.on_open }
+          @faye.on(:message) { |event| @event_target.on_message(event.data) }
+          @faye.on(:close)   { |event| @event_target.on_close(event.reason, event.code) }
+          @faye.on(:error)   { |event| @event_target.on_error(event.message) }
+        end
+    end
+  end
+end

data/lib/action_cable/connection/faye_event_loop.rb

@@ -0,0 +1,44 @@
+require 'thread'
+
+require 'eventmachine'
+EventMachine.epoll  if EventMachine.epoll?
+EventMachine.kqueue if EventMachine.kqueue?
+
+module ActionCable
+  module Connection
+    class FayeEventLoop
+      @@mutex = Mutex.new
+
+      def timer(interval, &block)
+        ensure_reactor_running
+        EMTimer.new(::EM::PeriodicTimer.new(interval, &block))
+      end
+
+      def post(task = nil, &block)
+        task ||= block
+
+        ensure_reactor_running
+        ::EM.next_tick(&task)
+      end
+
+      private
+        def ensure_reactor_running
+          return if EventMachine.reactor_running?
+          @@mutex.synchronize do
+            Thread.new { EventMachine.run } unless EventMachine.reactor_running?
+            Thread.pass until EventMachine.reactor_running?
+          end
+        end
+
+        class EMTimer
+          def initialize(inner)
+            @inner = inner
+          end
+
+          def shutdown
+            @inner.cancel
+          end
+        end
+    end
+  end
+end

data/lib/action_cable/connection/internal_channel.rb

@@ -11,24 +11,22 @@ module ActionCable
 
         def subscribe_to_internal_channel
           if connection_identifier.present?
-            callback = -> (message) { process_internal_message(message) }
+            callback = -> (message) { process_internal_message decode(message) }
             @_internal_subscriptions ||= []
             @_internal_subscriptions << [ internal_channel, callback ]
 
-            Concurrent.global_io_executor.post { pubsub.subscribe(internal_channel, callback) }
+            server.event_loop.post { pubsub.subscribe(internal_channel, callback) }
             logger.info "Registered connection (#{connection_identifier})"
           end
         end
 
         def unsubscribe_from_internal_channel
           if @_internal_subscriptions.present?
-            @_internal_subscriptions.each { |channel, callback| Concurrent.global_io_executor.post { pubsub.unsubscribe(channel, callback) } }
+            @_internal_subscriptions.each { |channel, callback| server.event_loop.post { pubsub.unsubscribe(channel, callback) } }
           end
         end
 
         def process_internal_message(message)
-          message = ActiveSupport::JSON.decode(message)
-
           case message['type']
           when 'disconnect'
             logger.info "Removing connection (#{connection_identifier})"

data/lib/action_cable/connection/message_buffer.rb

@@ -30,7 +30,7 @@ module ActionCable
 
       protected
         attr_reader :connection
-        attr_accessor :buffered_messages
+        attr_reader :buffered_messages
 
       private
         def valid?(message)
@@ -38,7 +38,7 @@ module ActionCable
         end
 
         def receive(message)
-          connection.send_async :receive, message
+          connection.receive message
         end
 
         def buffer(message)

data/lib/action_cable/connection/stream.rb

@@ -4,15 +4,13 @@ module ActionCable
     # This class is heavily based on faye-websocket-ruby
     #
     # Copyright (c) 2010-2015 James Coglan
-    class Stream
+    class Stream # :nodoc:
       def initialize(event_loop, socket)
         @event_loop    = event_loop
         @socket_object = socket
         @stream_send   = socket.env['stream.send']
 
         @rack_hijack_io = nil
-
-        hijack_rack_socket
       end
 
       def each(&callback)
@@ -31,7 +29,7 @@ module ActionCable
       def write(data)
         return @rack_hijack_io.write(data) if @rack_hijack_io
         return @stream_send.call(data) if @stream_send
-      rescue EOFError
+      rescue EOFError, Errno::ECONNRESET
         @socket_object.client_gone
       end
 
@@ -39,16 +37,16 @@ module ActionCable
         @socket_object.parse(data)
       end
 
-      private
-        def hijack_rack_socket
-          return unless @socket_object.env['rack.hijack']
+      def hijack_rack_socket
+        return unless @socket_object.env['rack.hijack']
 
-          @socket_object.env['rack.hijack'].call
-          @rack_hijack_io = @socket_object.env['rack.hijack_io']
+        @socket_object.env['rack.hijack'].call
+        @rack_hijack_io = @socket_object.env['rack.hijack_io']
 
-          @event_loop.attach(@rack_hijack_io, self)
-        end
+        @event_loop.attach(@rack_hijack_io, self)
+      end
 
+      private
         def clean_rack_hijack
           return unless @rack_hijack_io
           @event_loop.detach(@rack_hijack_io, self)

data/lib/action_cable/connection/stream_event_loop.rb

@@ -11,7 +11,16 @@ module ActionCable
         @todo = Queue.new
 
         @spawn_mutex = Mutex.new
-        spawn
+      end
+
+      def timer(interval, &block)
+        Concurrent::TimerTask.new(execution_interval: interval, &block).tap(&:execute)
+      end
+
+      def post(task = nil, &block)
+        task ||= block
+
+        Concurrent.global_io_executor << task
       end
 
       def attach(io, stream)

data/lib/action_cable/connection/web_socket.rb

@@ -4,8 +4,8 @@ module ActionCable
   module Connection
     # Wrap the real socket to minimize the externally-presented API
     class WebSocket
-      def initialize(env, event_target, stream_event_loop)
-        @websocket = ::WebSocket::Driver.websocket?(env) ? ClientSocket.new(env, event_target, stream_event_loop) : nil
+      def initialize(env, event_target, event_loop, client_socket_class, protocols: ActionCable::INTERNAL[:protocols])
+        @websocket = ::WebSocket::Driver.websocket?(env) ? client_socket_class.new(env, event_target, event_loop, protocols) : nil
       end
 
       def possible?
@@ -24,6 +24,10 @@ module ActionCable
         websocket.close
       end
 
+      def protocol
+        websocket.protocol
+      end
+
       def rack_response
         websocket.rack_response
       end

data/lib/action_cable/engine.rb

@@ -6,7 +6,7 @@ require "active_support/core_ext/hash/indifferent_access"
 module ActionCable
   class Railtie < Rails::Engine # :nodoc:
     config.action_cable = ActiveSupport::OrderedOptions.new
-    config.action_cable.url = '/cable'
+    config.action_cable.mount_path = ActionCable::INTERNAL[:default_mount_path]
 
     config.eager_load_namespaces << ActionCable
 
@@ -40,5 +40,41 @@ module ActionCable
         options.each { |k,v| send("#{k}=", v) }
       end
     end
+
+    initializer "action_cable.routes" do
+      config.after_initialize do |app|
+        config = app.config
+        unless config.action_cable.mount_path.nil?
+          app.routes.prepend do
+            mount ActionCable.server => config.action_cable.mount_path, internal: true
+          end
+        end
+      end
+    end
+
+    initializer "action_cable.set_work_hooks" do |app|
+      ActiveSupport.on_load(:action_cable) do
+        ActionCable::Server::Worker.set_callback :work, :around, prepend: true do |_, inner|
+          app.executor.wrap do
+            # If we took a while to get the lock, we may have been halted
+            # in the meantime. As we haven't started doing any real work
+            # yet, we should pretend that we never made it off the queue.
+            unless stopping?
+              inner.call
+            end
+          end
+        end
+
+        wrap = lambda do |_, inner|
+          app.executor.wrap(&inner)
+        end
+        ActionCable::Channel::Base.set_callback :subscribe, :around, prepend: true, &wrap
+        ActionCable::Channel::Base.set_callback :unsubscribe, :around, prepend: true, &wrap
+
+        app.reloader.before_class_unload do
+          ActionCable.server.restart
+        end
+      end
+    end
   end
 end

data/lib/action_cable/gem_version.rb

@@ -8,7 +8,7 @@ module ActionCable
     MAJOR = 5
     MINOR = 0
     TINY  = 0
-    PRE   = "beta3"
+    PRE   = "beta4"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/action_cable/helpers/action_cable_helper.rb

@@ -1,28 +1,39 @@
 module ActionCable
   module Helpers
     module ActionCableHelper
-      # Returns an "action-cable-url" meta tag with the value of the url specified in your
-      # configuration. Ensure this is above your javascript tag:
+      # Returns an "action-cable-url" meta tag with the value of the URL specified in your
+      # configuration. Ensure this is above your JavaScript tag:
       #
       #   <head>
       #     <%= action_cable_meta_tag %>
       #     <%= javascript_include_tag 'application', 'data-turbolinks-track' => true %>
       #   </head>
       #
-      # This is then used by Action Cable to determine the url of your WebSocket server.
+      # This is then used by Action Cable to determine the URL of your WebSocket server.
       # Your CoffeeScript can then connect to the server without needing to specify the
-      # url directly:
+      # URL directly:
       #
       #   #= require cable
       #   @App = {}
       #   App.cable = Cable.createConsumer()
       #
-      # Make sure to specify the correct server location in each of your environments
-      # config file:
+      # Make sure to specify the correct server location in each of your environment
+      # config files:
+      #
+      #   config.action_cable.mount_path = "/cable123"
+      #   <%= action_cable_meta_tag %> would render:
+      #   => <meta name="action-cable-url" content="/cable123" />
+      #
+      #   config.action_cable.url = "ws://actioncable.com"
+      #   <%= action_cable_meta_tag %> would render:
+      #   => <meta name="action-cable-url" content="ws://actioncable.com" />
       #
-      #   config.action_cable.url = "ws://example.com:28080"
       def action_cable_meta_tag
-        tag "meta", name: "action-cable-url", content: Rails.application.config.action_cable.url
+        tag "meta", name: "action-cable-url", content: (
+          ActionCable.server.config.url ||
+          ActionCable.server.config.mount_path ||
+          raise("No Action Cable URL configured -- please configure this at config.action_cable.url")
+        )
       end
     end
   end

data/lib/action_cable/remote_connections.rb

@@ -28,7 +28,7 @@ module ActionCable
 
     private
       # Represents a single remote connection found via <tt>ActionCable.server.remote_connections.where(*)</tt>.
-      # Exists for the solely for the purpose of calling #disconnect on that connection.
+      # Exists solely for the purpose of calling #disconnect on that connection.
       class RemoteConnection
         class InvalidIdentifiersError < StandardError; end
 

data/lib/action_cable/server/base.rb

@@ -1,4 +1,4 @@
-require 'thread'
+require 'monitor'
 
 module ActionCable
   module Server
@@ -18,8 +18,8 @@ module ActionCable
       attr_reader :mutex
 
       def initialize
-        @mutex = Mutex.new
-        @remote_connections = @stream_event_loop = @worker_pool = @channel_classes = @pubsub = nil
+        @mutex = Monitor.new
+        @remote_connections = @event_loop = @worker_pool = @channel_classes = @pubsub = nil
       end
 
       # Called by Rack to setup the server.
@@ -33,16 +33,36 @@ module ActionCable
         remote_connections.where(identifiers).disconnect
       end
 
+      def restart
+        connections.each(&:close)
+
+        @mutex.synchronize do
+          worker_pool.halt if @worker_pool
+
+          @worker_pool = nil
+        end
+      end
+
       # Gateway to RemoteConnections. See that class for details.
       def remote_connections
         @remote_connections || @mutex.synchronize { @remote_connections ||= RemoteConnections.new(self) }
       end
 
-      def stream_event_loop
-        @stream_event_loop || @mutex.synchronize { @stream_event_loop ||= ActionCable::Connection::StreamEventLoop.new }
+      def event_loop
+        @event_loop || @mutex.synchronize { @event_loop ||= config.event_loop_class.new }
       end
 
-      # The thread worker pool for handling all the connection work on this server. Default size is set by config.worker_pool_size.
+      # The worker pool is where we run connection callbacks and channel actions. We do as little as possible on the server's main thread.
+      # The worker pool is an executor service that's backed by a pool of threads working from a task queue. The thread pool size maxes out
+      # at 4 worker threads by default. Tune the size yourself with config.action_cable.worker_pool_size.
+      #
+      # Using Active Record, Redis, etc within your channel actions means you'll get a separate connection from each thread in the worker pool.
+      # Plan your deployment accordingly: 5 servers each running 5 Puma workers each running an 8-thread worker pool means at least 200 database
+      # connections.
+      #
+      # Also, ensure that your database connection pool size is as least as large as your worker pool size. Otherwise, workers may oversubscribe
+      # the db connection pool and block while they wait for other workers to release their connections. Use a smaller worker pool or a larger
+      # db connection pool instead.
       def worker_pool
         @worker_pool || @mutex.synchronize { @worker_pool ||= ActionCable::Server::Worker.new(max_size: config.worker_pool_size) }
       end