actioncable-next 0.1.0

data/lib/action_cable/subscription_adapter/postgresql.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+gem "pg", "~> 1.1"
+require "pg"
+require "openssl"
+
+module ActionCable
+  module SubscriptionAdapter
+    class PostgreSQL < Base # :nodoc:
+      prepend ChannelPrefix
+
+      def initialize(*)
+        super
+        @mutex = Mutex.new
+        @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)
+        pg_conn.exec("SET application_name = #{pg_conn.escape_identifier(identifier)}")
+        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 ? OpenSSL::Digest::SHA1.hexdigest(channel) : channel
+        end
+
+        def listener
+          @listener || @mutex.synchronize { @listener ||= Listener.new(self, executor) }
+        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::Async
+          def initialize(adapter, executor)
+            super(executor)
+
+            @adapter = adapter
+            @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}")
+                      @executor.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
+        end
+    end
+  end
+end

data/lib/action_cable/subscription_adapter/redis.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+gem "redis", ">= 4", "< 6"
+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
+        ::Redis.new(config.except(:adapter, :channel_prefix))
+      end
+
+      def initialize(*)
+        super
+        @listener = nil
+        @mutex = Mutex.new
+        @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 || @mutex.synchronize { @listener ||= Listener.new(self, config_options, executor) }
+        end
+
+        def redis_connection_for_broadcasts
+          @redis_connection_for_broadcasts || @mutex.synchronize do
+            @redis_connection_for_broadcasts ||= redis_connection
+          end
+        end
+
+        def redis_connection
+          self.class.redis_connector.call(config_options)
+        end
+
+        def config_options
+          @config_options ||= config.cable.deep_symbolize_keys.merge(id: identifier)
+        end
+
+        class Listener < SubscriberMap::Async
+          delegate :logger, to: :@adapter
+
+          def initialize(adapter, config_options, executor)
+            super(executor)
+
+            @adapter = adapter
+
+            @subscribe_callbacks = Hash.new { |h, k| h[k] = [] }
+            @subscription_lock = Mutex.new
+
+            @reconnect_attempt = 0
+            # Use the same config as used by Redis conn
+            @reconnect_attempts = config_options.fetch(:reconnect_attempts, 1)
+            @reconnect_attempts = Array.new(@reconnect_attempts, 0) if @reconnect_attempts.is_a?(Integer)
+
+            @subscribed_client = nil
+
+            @when_connected = []
+
+            @thread = nil
+          end
+
+          def listen(conn)
+            conn.without_reconnect do
+              original_client = extract_subscribed_client(conn)
+
+              conn.subscribe("_action_cable_internal") do |on|
+                on.subscribe do |chan, count|
+                  @subscription_lock.synchronize do
+                    if count == 1
+                      @reconnect_attempt = 0
+                      @subscribed_client = original_client
+
+                      until @when_connected.empty?
+                        @when_connected.shift.call
+                      end
+                    end
+
+                    if callbacks = @subscribe_callbacks[chan]
+                      next_callback = callbacks.shift
+                      @executor.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
+                      @subscribed_client = nil
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          def shutdown
+            @subscription_lock.synchronize do
+              return if @thread.nil?
+
+              when_connected do
+                @subscribed_client.unsubscribe
+                @subscribed_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 { @subscribed_client.subscribe(channel) }
+            end
+          end
+
+          def remove_channel(channel)
+            @subscription_lock.synchronize do
+              when_connected { @subscribed_client.unsubscribe(channel) }
+            end
+          end
+
+          private
+            def ensure_listener_running
+              @thread ||= Thread.new do
+                Thread.current.abort_on_exception = true
+
+                begin
+                  conn = @adapter.redis_connection_for_subscriptions
+                  listen conn
+                rescue ConnectionError => e
+                  reset
+                  if retry_connecting?
+                    logger&.warn "Redis connection failed: #{e.message}. Trying to reconnect..."
+                    when_connected { resubscribe }
+                    retry
+                  else
+                    logger&.error "Failed to reconnect to Redis after #{@reconnect_attempt} attempts."
+                  end
+                end
+              end
+            end
+
+            def when_connected(&block)
+              if @subscribed_client
+                block.call
+              else
+                @when_connected << block
+              end
+            end
+
+            def retry_connecting?
+              @reconnect_attempt += 1
+
+              return false if @reconnect_attempt > @reconnect_attempts.size
+
+              sleep_t = @reconnect_attempts[@reconnect_attempt - 1]
+
+              sleep(sleep_t) if sleep_t > 0
+
+              true
+            end
+
+            def resubscribe
+              channels = @sync.synchronize do
+                @subscribers.keys
+              end
+              @subscribed_client.subscribe(*channels) unless channels.empty?
+            end
+
+            def reset
+              @subscription_lock.synchronize do
+                @subscribed_client = nil
+                @subscribe_callbacks.clear
+                @when_connected.clear
+              end
+            end
+
+            if ::Redis::VERSION < "5"
+              ConnectionError = ::Redis::BaseConnectionError
+
+              class SubscribedClient
+                def initialize(raw_client)
+                  @raw_client = raw_client
+                end
+
+                def subscribe(*channel)
+                  send_command("subscribe", *channel)
+                end
+
+                def unsubscribe(*channel)
+                  send_command("unsubscribe", *channel)
+                end
+
+                private
+                  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
+                    nil
+                  end
+              end
+
+              def extract_subscribed_client(conn)
+                SubscribedClient.new(conn._client)
+              end
+            else
+              ConnectionError = RedisClient::ConnectionError
+
+              def extract_subscribed_client(conn)
+                conn
+              end
+            end
+        end
+    end
+  end
+end

data/lib/action_cable/subscription_adapter/subscriber_map.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+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
+
+      class Async < self
+        def initialize(executor)
+          @executor = executor
+          super()
+        end
+
+        def add_subscriber(*)
+          @executor.post { super }
+        end
+
+        def remove_subscriber(*)
+          @executor.post { super }
+        end
+
+        def invoke_callback(*)
+          @executor.post { super }
+        end
+      end
+    end
+  end
+end

data/lib/action_cable/subscription_adapter/test.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  module SubscriptionAdapter
+    # ## Test adapter for Action Cable
+    #
+    # The test adapter should be used only in testing. Along with
+    # ActionCable::TestHelper it makes a great tool to test your Rails application.
+    #
+    # To use the test adapter set `adapter` value to `test` in your
+    # `config/cable.yml` file.
+    #
+    # NOTE: `Test` adapter extends the `ActionCable::SubscriptionAdapter::Async`
+    # adapter, so it could be used in system tests too.
+    class Test < Async
+      def broadcast(channel, payload)
+        broadcasts(channel) << payload
+        super
+      end
+
+      def broadcasts(channel)
+        channels_data[channel] ||= []
+      end
+
+      def clear_messages(channel)
+        channels_data[channel] = []
+      end
+
+      def clear
+        @channels_data = nil
+      end
+
+      private
+        def channels_data
+          @channels_data ||= {}
+        end
+    end
+  end
+end

data/lib/action_cable/test_case.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/test_case"
+
+module ActionCable
+  class TestCase < ActiveSupport::TestCase
+    include ActionCable::TestHelper
+
+    ActiveSupport.run_load_hooks(:action_cable_test_case, self)
+  end
+end

data/lib/action_cable/test_helper.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  # Provides helper methods for testing Action Cable broadcasting
+  module TestHelper
+    def before_setup # :nodoc:
+      server = ActionCable.server
+      test_adapter = ActionCable::SubscriptionAdapter::Test.new(server)
+
+      @old_pubsub_adapter = server.pubsub
+
+      server.instance_variable_set(:@pubsub, test_adapter)
+      super
+    end
+
+    def after_teardown # :nodoc:
+      super
+      ActionCable.server.instance_variable_set(:@pubsub, @old_pubsub_adapter)
+    end
+
+    # Asserts that the number of broadcasted messages to the stream matches the
+    # given number.
+    #
+    #     def test_broadcasts
+    #       assert_broadcasts 'messages', 0
+    #       ActionCable.server.broadcast 'messages', { text: 'hello' }
+    #       assert_broadcasts 'messages', 1
+    #       ActionCable.server.broadcast 'messages', { text: 'world' }
+    #       assert_broadcasts 'messages', 2
+    #     end
+    #
+    # If a block is passed, that block should cause the specified number of messages
+    # to be broadcasted.
+    #
+    #     def test_broadcasts_again
+    #       assert_broadcasts('messages', 1) do
+    #         ActionCable.server.broadcast 'messages', { text: 'hello' }
+    #       end
+    #
+    #       assert_broadcasts('messages', 2) do
+    #         ActionCable.server.broadcast 'messages', { text: 'hi' }
+    #         ActionCable.server.broadcast 'messages', { text: 'how are you?' }
+    #       end
+    #     end
+    #
+    def assert_broadcasts(stream, number, &block)
+      if block_given?
+        new_messages = new_broadcasts_from(broadcasts(stream), stream, "assert_broadcasts", &block)
+
+        actual_count = new_messages.size
+        assert_equal number, actual_count, "#{number} broadcasts to #{stream} expected, but #{actual_count} were sent"
+      else
+        actual_count = broadcasts(stream).size
+        assert_equal number, actual_count, "#{number} broadcasts to #{stream} expected, but #{actual_count} were sent"
+      end
+    end
+
+    # Asserts that no messages have been sent to the stream.
+    #
+    #     def test_no_broadcasts
+    #       assert_no_broadcasts 'messages'
+    #       ActionCable.server.broadcast 'messages', { text: 'hi' }
+    #       assert_broadcasts 'messages', 1
+    #     end
+    #
+    # If a block is passed, that block should not cause any message to be sent.
+    #
+    #     def test_broadcasts_again
+    #       assert_no_broadcasts 'messages' do
+    #         # No job messages should be sent from this block
+    #       end
+    #     end
+    #
+    # Note: This assertion is simply a shortcut for:
+    #
+    #     assert_broadcasts 'messages', 0, &block
+    #
+    def assert_no_broadcasts(stream, &block)
+      assert_broadcasts stream, 0, &block
+    end
+
+    # Returns the messages that are broadcasted in the block.
+    #
+    #     def test_broadcasts
+    #       messages = capture_broadcasts('messages') do
+    #         ActionCable.server.broadcast 'messages', { text: 'hi' }
+    #         ActionCable.server.broadcast 'messages', { text: 'how are you?' }
+    #       end
+    #       assert_equal 2, messages.length
+    #       assert_equal({ text: 'hi' }, messages.first)
+    #       assert_equal({ text: 'how are you?' }, messages.last)
+    #     end
+    #
+    def capture_broadcasts(stream, &block)
+      new_broadcasts_from(broadcasts(stream), stream, "capture_broadcasts", &block).map { |m| ActiveSupport::JSON.decode(m) }
+    end
+
+    # Asserts that the specified message has been sent to the stream.
+    #
+    #     def test_assert_transmitted_message
+    #       ActionCable.server.broadcast 'messages', text: 'hello'
+    #       assert_broadcast_on('messages', text: 'hello')
+    #     end
+    #
+    # If a block is passed, that block should cause a message with the specified
+    # data to be sent.
+    #
+    #     def test_assert_broadcast_on_again
+    #       assert_broadcast_on('messages', text: 'hello') do
+    #         ActionCable.server.broadcast 'messages', text: 'hello'
+    #       end
+    #     end
+    #
+    def assert_broadcast_on(stream, data, &block)
+      # Encode to JSON and back–we want to use this value to compare with decoded
+      # JSON. Comparing JSON strings doesn't work due to the order if the keys.
+      serialized_msg =
+        ActiveSupport::JSON.decode(ActiveSupport::JSON.encode(data))
+
+      new_messages = broadcasts(stream)
+      if block_given?
+        new_messages = new_broadcasts_from(new_messages, stream, "assert_broadcast_on", &block)
+      end
+
+      message = new_messages.find { |msg| ActiveSupport::JSON.decode(msg) == serialized_msg }
+
+      error_message = "No messages sent with #{data} to #{stream}"
+
+      if new_messages.any?
+        error_message = new_messages.inject("#{error_message}\nMessage(s) found:\n") do |error_message, new_message|
+          error_message + "#{ActiveSupport::JSON.decode(new_message)}\n"
+        end
+      else
+        error_message = "#{error_message}\nNo message found for #{stream}"
+      end
+
+      assert message, error_message
+    end
+
+    def pubsub_adapter # :nodoc:
+      ActionCable.server.pubsub
+    end
+
+    delegate :broadcasts, :clear_messages, to: :pubsub_adapter
+
+    private
+      def new_broadcasts_from(current_messages, stream, assertion, &block)
+        old_messages = current_messages
+        clear_messages(stream)
+
+        _assert_nothing_raised_or_warn(assertion, &block)
+        new_messages = broadcasts(stream)
+        clear_messages(stream)
+
+        # Restore all sent messages
+        (old_messages + new_messages).each { |m| pubsub_adapter.broadcast(stream, m) }
+
+        new_messages
+      end
+  end
+end

data/lib/action_cable/version.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require_relative "gem_version"
+
+module ActionCable
+  # Returns the currently loaded version of Action Cable as a `Gem::Version`.
+  def self.version
+    gem_version
+  end
+end