actioncable 6.0.0

data/lib/action_cable/subscription_adapter/async.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "action_cable/subscription_adapter/inline"
+
+module ActionCable
+  module SubscriptionAdapter
+    class Async < Inline # :nodoc:
+      private
+        def new_subscriber_map
+          AsyncSubscriberMap.new(server.event_loop)
+        end
+
+        class AsyncSubscriberMap < SubscriberMap
+          def initialize(event_loop)
+            @event_loop = event_loop
+            super()
+          end
+
+          def add_subscriber(*)
+            @event_loop.post { super }
+          end
+
+          def invoke_callback(*)
+            @event_loop.post { super }
+          end
+        end
+    end
+  end
+end

data/lib/action_cable/subscription_adapter/base.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+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/channel_prefix.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActionCable
+  module SubscriptionAdapter
+    module ChannelPrefix # :nodoc:
+      def broadcast(channel, payload)
+        channel = channel_with_prefix(channel)
+        super
+      end
+
+      def subscribe(channel, callback, success_callback = nil)
+        channel = channel_with_prefix(channel)
+        super
+      end
+
+      def unsubscribe(channel, callback)
+        channel = channel_with_prefix(channel)
+        super
+      end
+
+      private
+        # Returns the channel name, including channel_prefix specified in cable.yml
+        def channel_with_prefix(channel)
+          [@server.config.cable[:channel_prefix], channel].compact.join(":")
+        end
+    end
+  end
+end

data/lib/action_cable/subscription_adapter/inline.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+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,132 @@
+# frozen_string_literal: true
+
+gem "pg", ">= 0.18", "< 2.0"
+require "pg"
+require "thread"
+require "digest/sha1"
+
+module ActionCable
+  module SubscriptionAdapter
+    class PostgreSQL < Base # :nodoc:
+      prepend ChannelPrefix
+
+      def initialize(*)
+        super
+        @listener = nil
+      end
+
+      def broadcast(channel, payload)
+        with_broadcast_connection do |pg_conn|
+          pg_conn.exec("NOTIFY #{pg_conn.escape_identifier(channel_identifier(channel))}, '#{pg_conn.escape_string(payload)}'")
+        end
+      end
+
+      def subscribe(channel, callback, success_callback = nil)
+        listener.add_subscriber(channel_identifier(channel), callback, success_callback)
+      end
+
+      def unsubscribe(channel, callback)
+        listener.remove_subscriber(channel_identifier(channel), callback)
+      end
+
+      def shutdown
+        listener.shutdown
+      end
+
+      def with_subscriptions_connection(&block) # :nodoc:
+        ar_conn = ActiveRecord::Base.connection_pool.checkout.tap do |conn|
+          # Action Cable is taking ownership over this database connection, and
+          # will perform the necessary cleanup tasks
+          ActiveRecord::Base.connection_pool.remove(conn)
+        end
+        pg_conn = ar_conn.raw_connection
+
+        verify!(pg_conn)
+        yield pg_conn
+      ensure
+        ar_conn.disconnect!
+      end
+
+      def with_broadcast_connection(&block) # :nodoc:
+        ActiveRecord::Base.connection_pool.with_connection do |ar_conn|
+          pg_conn = ar_conn.raw_connection
+          verify!(pg_conn)
+          yield pg_conn
+        end
+      end
+
+      private
+        def channel_identifier(channel)
+          channel.size > 63 ? Digest::SHA1.hexdigest(channel) : channel
+        end
+
+        def listener
+          @listener || @server.mutex.synchronize { @listener ||= Listener.new(self, @server.event_loop) }
+        end
+
+        def verify!(pg_conn)
+          unless pg_conn.is_a?(PG::Connection)
+            raise "The Active Record database must be PostgreSQL in order to use the PostgreSQL Action Cable storage adapter"
+          end
+        end
+
+        class Listener < SubscriberMap
+          def initialize(adapter, event_loop)
+            super()
+
+            @adapter = adapter
+            @event_loop = event_loop
+            @queue = Queue.new
+
+            @thread = Thread.new do
+              Thread.current.abort_on_exception = true
+              listen
+            end
+          end
+
+          def listen
+            @adapter.with_subscriptions_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}")
+                      @event_loop.post(&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(*)
+            @event_loop.post { super }
+          end
+        end
+    end
+  end
+end

data/lib/action_cable/subscription_adapter/redis.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "thread"
+
+gem "redis", ">= 3", "< 5"
+require "redis"
+
+require "active_support/core_ext/hash/except"
+
+module ActionCable
+  module SubscriptionAdapter
+    class Redis < Base # :nodoc:
+      prepend ChannelPrefix
+
+      # Overwrite this factory method for Redis connections if you want to use a different Redis library than the redis gem.
+      # This is needed, for example, when using Makara proxies for distributed Redis.
+      cattr_accessor :redis_connector, default: ->(config) do
+        config[:id] ||= "ActionCable-PID-#{$$}"
+        ::Redis.new(config.except(:adapter, :channel_prefix))
+      end
+
+      def initialize(*)
+        super
+        @listener = nil
+        @redis_connection_for_broadcasts = nil
+      end
+
+      def broadcast(channel, payload)
+        redis_connection_for_broadcasts.publish(channel, payload)
+      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 if @listener
+      end
+
+      def redis_connection_for_subscriptions
+        redis_connection
+      end
+
+      private
+        def listener
+          @listener || @server.mutex.synchronize { @listener ||= Listener.new(self, @server.event_loop) }
+        end
+
+        def redis_connection_for_broadcasts
+          @redis_connection_for_broadcasts || @server.mutex.synchronize do
+            @redis_connection_for_broadcasts ||= redis_connection
+          end
+        end
+
+        def redis_connection
+          self.class.redis_connector.call(@server.config.cable)
+        end
+
+        class Listener < SubscriberMap
+          def initialize(adapter, event_loop)
+            super()
+
+            @adapter = adapter
+            @event_loop = event_loop
+
+            @subscribe_callbacks = Hash.new { |h, k| h[k] = [] }
+            @subscription_lock = Mutex.new
+
+            @raw_client = nil
+
+            @when_connected = []
+
+            @thread = nil
+          end
+
+          def listen(conn)
+            conn.without_reconnect do
+              original_client = conn.respond_to?(:_client) ? conn._client : conn.client
+
+              conn.subscribe("_action_cable_internal") do |on|
+                on.subscribe do |chan, count|
+                  @subscription_lock.synchronize do
+                    if count == 1
+                      @raw_client = original_client
+
+                      until @when_connected.empty?
+                        @when_connected.shift.call
+                      end
+                    end
+
+                    if callbacks = @subscribe_callbacks[chan]
+                      next_callback = callbacks.shift
+                      @event_loop.post(&next_callback) if next_callback
+                      @subscribe_callbacks.delete(chan) if callbacks.empty?
+                    end
+                  end
+                end
+
+                on.message do |chan, message|
+                  broadcast(chan, message)
+                end
+
+                on.unsubscribe do |chan, count|
+                  if count == 0
+                    @subscription_lock.synchronize do
+                      @raw_client = nil
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          def shutdown
+            @subscription_lock.synchronize do
+              return if @thread.nil?
+
+              when_connected do
+                send_command("unsubscribe")
+                @raw_client = nil
+              end
+            end
+
+            Thread.pass while @thread.alive?
+          end
+
+          def add_channel(channel, on_success)
+            @subscription_lock.synchronize do
+              ensure_listener_running
+              @subscribe_callbacks[channel] << on_success
+              when_connected { send_command("subscribe", channel) }
+            end
+          end
+
+          def remove_channel(channel)
+            @subscription_lock.synchronize do
+              when_connected { send_command("unsubscribe", channel) }
+            end
+          end
+
+          def invoke_callback(*)
+            @event_loop.post { super }
+          end
+
+          private
+            def ensure_listener_running
+              @thread ||= Thread.new do
+                Thread.current.abort_on_exception = true
+
+                conn = @adapter.redis_connection_for_subscriptions
+                listen conn
+              end
+            end
+
+            def when_connected(&block)
+              if @raw_client
+                block.call
+              else
+                @when_connected << block
+              end
+            end
+
+            def send_command(*command)
+              @raw_client.write(command)
+
+              very_raw_connection =
+                @raw_client.connection.instance_variable_defined?(:@connection) &&
+                @raw_client.connection.instance_variable_get(:@connection)
+
+              if very_raw_connection && very_raw_connection.respond_to?(:flush)
+                very_raw_connection.flush
+              end
+            end
+        end
+    end
+  end
+end

data/lib/action_cable/subscription_adapter/subscriber_map.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ActionCable
+  module SubscriptionAdapter
+    class SubscriberMap
+      def initialize
+        @subscribers = Hash.new { |h, k| h[k] = [] }
+        @sync = Mutex.new
+      end
+
+      def add_subscriber(channel, subscriber, on_success)
+        @sync.synchronize do
+          new_channel = !@subscribers.key?(channel)
+
+          @subscribers[channel] << subscriber
+
+          if new_channel
+            add_channel channel, on_success
+          elsif on_success
+            on_success.call
+          end
+        end
+      end
+
+      def remove_subscriber(channel, subscriber)
+        @sync.synchronize do
+          @subscribers[channel].delete(subscriber)
+
+          if @subscribers[channel].empty?
+            @subscribers.delete channel
+            remove_channel channel
+          end
+        end
+      end
+
+      def broadcast(channel, message)
+        list = @sync.synchronize do
+          return if !@subscribers.key?(channel)
+          @subscribers[channel].dup
+        end
+
+        list.each do |subscriber|
+          invoke_callback(subscriber, message)
+        end
+      end
+
+      def add_channel(channel, on_success)
+        on_success.call if on_success
+      end
+
+      def remove_channel(channel)
+      end
+
+      def invoke_callback(callback, message)
+        callback.call message
+      end
+    end
+  end
+end