omg-actioncable 8.0.0.alpha2

data/lib/action_cable/subscription_adapter/base.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+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
+
+      def identifier
+        @server.config.cable[:id] ||= "ActionCable-PID-#{$$}"
+      end
+    end
+  end
+end

data/lib/action_cable/subscription_adapter/channel_prefix.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+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,39 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+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,134 @@
+# 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
+        @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 || @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,256 @@
+# 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
+        @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, config_options, @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(config_options)
+        end
+
+        def config_options
+          @config_options ||= @server.config.cable.deep_symbolize_keys.merge(id: identifier)
+        end
+
+        class Listener < SubscriberMap
+          def initialize(adapter, config_options, event_loop)
+            super()
+
+            @adapter = adapter
+            @event_loop = event_loop
+
+            @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
+                      @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
+                      @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
+
+          def invoke_callback(*)
+            @event_loop.post { super }
+          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
+                  reset
+                  if retry_connecting?
+                    when_connected { resubscribe }
+                    retry
+                  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,61 @@
+# 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
+    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