actioncable 5.0.0.beta1.1 → 5.0.0.beta2

data/lib/action_cable/server/broadcasting.rb

@@ -1,5 +1,3 @@
-require 'redis'
-
 module ActionCable
   module Server
     # Broadcasting is how other parts of your application can send messages to the channel subscribers. As explained in Channel, most of the time, these
@@ -31,11 +29,6 @@ module ActionCable
         Broadcaster.new(self, broadcasting)
       end
 
-      # The redis instance used for broadcasting. Not intended for direct user use.
-      def broadcasting_redis
-        @broadcasting_redis ||= Redis.new(config.redis)
-      end
-
       private
         class Broadcaster
           attr_reader :server, :broadcasting
@@ -46,7 +39,7 @@ module ActionCable
 
           def broadcast(message)
             server.logger.info "[ActionCable] Broadcasting to #{broadcasting}: #{message}"
-            server.broadcasting_redis.publish broadcasting, ActiveSupport::JSON.encode(message)
+            server.pubsub.broadcast broadcasting, ActiveSupport::JSON.encode(message)
           end
         end
     end

data/lib/action_cable/server/configuration.rb

@@ -5,9 +5,9 @@ module ActionCable
     class Configuration
       attr_accessor :logger, :log_tags
       attr_accessor :connection_class, :worker_pool_size
-      attr_accessor :redis, :channels_path
+      attr_accessor :channel_load_paths
       attr_accessor :disable_request_forgery_protection, :allowed_request_origins
-      attr_accessor :url
+      attr_accessor :cable, :url
 
       def initialize
         @log_tags = []
@@ -15,13 +15,15 @@ module ActionCable
         @connection_class  = ApplicationCable::Connection
         @worker_pool_size  = 100
 
-        @channels_path = Rails.root.join('app/channels')
+        @channel_load_paths = [Rails.root.join('app/channels')]
 
         @disable_request_forgery_protection = false
       end
 
       def channel_paths
-        @channels ||= Dir["#{channels_path}/**/*_channel.rb"]
+        @channel_paths ||= channel_load_paths.flat_map do |path|
+          Dir["#{path}/**/*_channel.rb"]
+        end
       end
 
       def channel_class_names
@@ -29,7 +31,25 @@ module ActionCable
           Pathname.new(channel_path).basename.to_s.split('.').first.camelize
         end
       end
+
+      # Returns constant of subscription adapter specified in config/cable.yml.
+      # If the adapter cannot be found, this will default to the Redis adapter.
+      # Also makes sure proper dependencies are required.
+      def pubsub_adapter
+        adapter = (cable.fetch('adapter') { 'redis' })
+        path_to_adapter = "action_cable/subscription_adapter/#{adapter}"
+        begin
+          require path_to_adapter
+        rescue Gem::LoadError => e
+          raise Gem::LoadError, "Specified '#{adapter}' for Action Cable pubsub adapter, but the gem is not loaded. Add `gem '#{e.name}'` to your Gemfile (and ensure its version is at the minimum required by Action Cable)."
+        rescue LoadError => e
+          raise LoadError, "Could not load '#{path_to_adapter}'. Make sure that the adapter in config/cable.yml is valid. If you use an adapter other than 'postgresql' or 'redis' add the necessary adapter gem to the Gemfile.", e.backtrace
+        end
+
+        adapter = adapter.camelize
+        adapter = 'PostgreSQL' if adapter == 'Postgresql'
+        "ActionCable::SubscriptionAdapter::#{adapter}".constantize
+      end
     end
   end
 end
-

data/lib/action_cable/server/connections.rb

@@ -22,11 +22,9 @@ module ActionCable
       # then can't rely on being able to receive and send to it. So there's a 3 second heartbeat running on all connections. If the beat fails, we automatically
       # disconnect.
       def setup_heartbeat_timer
-        EM.next_tick do
-          @heartbeat_timer ||= EventMachine.add_periodic_timer(BEAT_INTERVAL) do
-            EM.next_tick { connections.map(&:beat) }
-          end
-        end
+        @heartbeat_timer ||= Concurrent::TimerTask.new(execution_interval: BEAT_INTERVAL) do
+          Concurrent.global_io_executor.post { connections.map(&:beat) }
+        end.tap(&:execute)
       end
 
       def open_connections_statistics

data/lib/action_cable/server/worker.rb

@@ -1,39 +1,68 @@
-require 'celluloid'
 require 'active_support/callbacks'
+require 'active_support/core_ext/module/attribute_accessors_per_thread'
+require 'concurrent'
 
 module ActionCable
   module Server
     # Worker used by Server.send_async to do connection work in threads. Only for internal use.
     class Worker
       include ActiveSupport::Callbacks
-      include Celluloid
 
-      attr_reader :connection
+      thread_mattr_accessor :connection
       define_callbacks :work
       include ActiveRecordConnectionManagement
 
+      def initialize(max_size: 5)
+        @pool = Concurrent::ThreadPoolExecutor.new(
+          min_threads: 1,
+          max_threads: max_size,
+          max_queue: 0,
+        )
+      end
+
+      def async_invoke(receiver, method, *args)
+        @pool.post do
+          invoke(receiver, method, *args)
+        end
+      end
+
       def invoke(receiver, method, *args)
-        @connection = receiver
+        begin
+          self.connection = receiver
 
-        run_callbacks :work do
-          receiver.send method, *args
+          run_callbacks :work do
+            receiver.send method, *args
+          end
+        rescue Exception => e
+          logger.error "There was an exception - #{e.class}(#{e.message})"
+          logger.error e.backtrace.join("\n")
+
+          receiver.handle_exception if receiver.respond_to?(:handle_exception)
+        ensure
+          self.connection = nil
         end
-      rescue Exception => e
-        logger.error "There was an exception - #{e.class}(#{e.message})"
-        logger.error e.backtrace.join("\n")
+      end
 
-        receiver.handle_exception if receiver.respond_to?(:handle_exception)
+      def async_run_periodic_timer(channel, callback)
+        @pool.post do
+          run_periodic_timer(channel, callback)
+        end
       end
 
       def run_periodic_timer(channel, callback)
-        @connection = channel.connection
+        begin
+          self.connection = channel.connection
 
-        run_callbacks :work do
-          callback.respond_to?(:call) ? channel.instance_exec(&callback) : channel.send(callback)
+          run_callbacks :work do
+            callback.respond_to?(:call) ? channel.instance_exec(&callback) : channel.send(callback)
+          end
+        ensure
+          self.connection = nil
         end
       end
 
       private
+
         def logger
           ActionCable.server.logger
         end

data/lib/action_cable/subscription_adapter.rb

@@ -0,0 +1,8 @@
+module ActionCable
+  module SubscriptionAdapter
+    extend ActiveSupport::Autoload
+
+    autoload :Base
+    autoload :SubscriberMap
+  end
+end

data/lib/action_cable/subscription_adapter/async.rb

@@ -0,0 +1,22 @@
+require 'action_cable/subscription_adapter/inline'
+
+module ActionCable
+  module SubscriptionAdapter
+    class Async < Inline # :nodoc:
+      private
+        def new_subscriber_map
+          AsyncSubscriberMap.new
+        end
+
+        class AsyncSubscriberMap < SubscriberMap
+          def add_subscriber(*)
+            Concurrent.global_io_executor.post { super }
+          end
+
+          def invoke_callback(*)
+            Concurrent.global_io_executor.post { super }
+          end
+        end
+    end
+  end
+end

data/lib/action_cable/subscription_adapter/base.rb

@@ -0,0 +1,28 @@
+module ActionCable
+  module SubscriptionAdapter
+    class Base
+      attr_reader :logger, :server
+
+      def initialize(server)
+        @server = server
+        @logger = @server.logger
+      end
+
+      def broadcast(channel, payload)
+        raise NotImplementedError
+      end
+
+      def subscribe(channel, message_callback, success_callback = nil)
+        raise NotImplementedError
+      end
+
+      def unsubscribe(channel, message_callback)
+        raise NotImplementedError
+      end
+
+      def shutdown
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/action_cable/subscription_adapter/evented_redis.rb

@@ -0,0 +1,67 @@
+require 'thread'
+
+gem 'em-hiredis', '~> 0.3.0'
+gem 'redis', '~> 3.0'
+require 'em-hiredis'
+require 'redis'
+
+EventMachine.epoll  if EventMachine.epoll?
+EventMachine.kqueue if EventMachine.kqueue?
+
+module ActionCable
+  module SubscriptionAdapter
+    class EventedRedis < Base # :nodoc:
+      @@mutex = Mutex.new
+
+      def initialize(*)
+        super
+        @redis_connection_for_broadcasts = @redis_connection_for_subscriptions = nil
+      end
+
+      def broadcast(channel, payload)
+        redis_connection_for_broadcasts.publish(channel, payload)
+      end
+
+      def subscribe(channel, message_callback, success_callback = nil)
+        redis_connection_for_subscriptions.pubsub.subscribe(channel, &message_callback).tap do |result|
+          result.callback { |reply| success_callback.call } if success_callback
+        end
+      end
+
+      def unsubscribe(channel, message_callback)
+        redis_connection_for_subscriptions.pubsub.unsubscribe_proc(channel, message_callback)
+      end
+
+      def shutdown
+        redis_connection_for_subscriptions.pubsub.close_connection
+        @redis_connection_for_subscriptions = nil
+      end
+
+      private
+        def redis_connection_for_subscriptions
+          ensure_reactor_running
+          @redis_connection_for_subscriptions || @server.mutex.synchronize do
+            @redis_connection_for_subscriptions ||= EM::Hiredis.connect(@server.config.cable[:url]).tap do |redis|
+              redis.on(:reconnect_failed) do
+                @logger.info "[ActionCable] Redis reconnect failed."
+              end
+            end
+          end
+        end
+
+        def redis_connection_for_broadcasts
+          @redis_connection_for_broadcasts || @server.mutex.synchronize do
+            @redis_connection_for_broadcasts ||= ::Redis.new(@server.config.cable)
+          end
+        end
+
+        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
+    end
+  end
+end

data/lib/action_cable/subscription_adapter/inline.rb

@@ -0,0 +1,35 @@
+module ActionCable
+  module SubscriptionAdapter
+    class Inline < Base # :nodoc:
+      def initialize(*)
+        super
+        @subscriber_map = nil
+      end
+
+      def broadcast(channel, payload)
+        subscriber_map.broadcast(channel, payload)
+      end
+
+      def subscribe(channel, callback, success_callback = nil)
+        subscriber_map.add_subscriber(channel, callback, success_callback)
+      end
+
+      def unsubscribe(channel, callback)
+        subscriber_map.remove_subscriber(channel, callback)
+      end
+
+      def shutdown
+        # nothing to do
+      end
+
+      private
+        def subscriber_map
+          @subscriber_map || @server.mutex.synchronize { @subscriber_map ||= new_subscriber_map }
+        end
+
+        def new_subscriber_map
+          SubscriberMap.new
+        end
+    end
+  end
+end

data/lib/action_cable/subscription_adapter/postgresql.rb

@@ -0,0 +1,106 @@
+gem 'pg', '~> 0.18'
+require 'pg'
+require 'thread'
+
+module ActionCable
+  module SubscriptionAdapter
+    class PostgreSQL < Base # :nodoc:
+      def initialize(*)
+        super
+        @listener = nil
+      end
+
+      def broadcast(channel, payload)
+        with_connection do |pg_conn|
+          pg_conn.exec("NOTIFY #{pg_conn.escape_identifier(channel)}, '#{pg_conn.escape_string(payload)}'")
+        end
+      end
+
+      def subscribe(channel, callback, success_callback = nil)
+        listener.add_subscriber(channel, callback, success_callback)
+      end
+
+      def unsubscribe(channel, callback)
+        listener.remove_subscriber(channel, callback)
+      end
+
+      def shutdown
+        listener.shutdown
+      end
+
+      def with_connection(&block) # :nodoc:
+        ActiveRecord::Base.connection_pool.with_connection do |ar_conn|
+          pg_conn = ar_conn.raw_connection
+
+          unless pg_conn.is_a?(PG::Connection)
+            raise 'ActiveRecord database must be Postgres in order to use the Postgres ActionCable storage adapter'
+          end
+
+          yield pg_conn
+        end
+      end
+
+      private
+        def listener
+          @listener || @server.mutex.synchronize { @listener ||= Listener.new(self) }
+        end
+
+        class Listener < SubscriberMap
+          def initialize(adapter)
+            super()
+
+            @adapter = adapter
+            @queue = Queue.new
+
+            @thread = Thread.new do
+              Thread.current.abort_on_exception = true
+              listen
+            end
+          end
+
+          def listen
+            @adapter.with_connection do |pg_conn|
+              catch :shutdown do
+                loop do
+                  until @queue.empty?
+                    action, channel, callback = @queue.pop(true)
+
+                    case action
+                    when :listen
+                      pg_conn.exec("LISTEN #{pg_conn.escape_identifier channel}")
+                      Concurrent.global_io_executor << callback if callback
+                    when :unlisten
+                      pg_conn.exec("UNLISTEN #{pg_conn.escape_identifier channel}")
+                    when :shutdown
+                      throw :shutdown
+                    end
+                  end
+
+                  pg_conn.wait_for_notify(1) do |chan, pid, message|
+                    broadcast(chan, message)
+                  end
+                end
+              end
+            end
+          end
+
+          def shutdown
+            @queue.push([:shutdown])
+            Thread.pass while @thread.alive?
+          end
+
+          def add_channel(channel, on_success)
+            @queue.push([:listen, channel, on_success])
+          end
+
+          def remove_channel(channel)
+            @queue.push([:unlisten, channel])
+          end
+
+          def invoke_callback(*)
+            Concurrent.global_io_executor.post { super }
+          end
+        end
+    end
+  end
+end