actioncable-next 0.1.0

data/lib/action_cable/connection/base.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/rescuable"
+
+module ActionCable
+  module Connection
+    # # Action Cable Connection Base
+    #
+    # For every WebSocket connection the Action Cable server accepts, a Connection
+    # object will be instantiated. This instance becomes the parent of all of the
+    # channel subscriptions that are created from there on. Incoming messages are
+    # then routed to these channel subscriptions based on an identifier sent by the
+    # Action Cable consumer. The Connection itself does not deal with any specific
+    # application logic beyond authentication and authorization.
+    #
+    # Here's a basic example:
+    #
+    #     module ApplicationCable
+    #       class Connection < ActionCable::Connection::Base
+    #         identified_by :current_user
+    #
+    #         def connect
+    #           self.current_user = find_verified_user
+    #           logger.add_tags current_user.name
+    #         end
+    #
+    #         def disconnect
+    #           # Any cleanup work needed when the cable connection is cut.
+    #         end
+    #
+    #         private
+    #           def find_verified_user
+    #             User.find_by_identity(cookies.encrypted[:identity_id]) ||
+    #               reject_unauthorized_connection
+    #           end
+    #       end
+    #     end
+    #
+    # First, we declare that this connection can be identified by its current_user.
+    # This allows us to later be able to find all connections established for that
+    # current_user (and potentially disconnect them). You can declare as many
+    # identification indexes as you like. Declaring an identification means that an
+    # attr_accessor is automatically set for that key.
+    #
+    # Second, we rely on the fact that the WebSocket connection is established with
+    # the cookies from the domain being sent along. This makes it easy to use signed
+    # cookies that were set when logging in via a web interface to authorize the
+    # WebSocket connection.
+    #
+    # Finally, we add a tag to the connection-specific logger with the name of the
+    # current user to easily distinguish their messages in the log.
+    #
+    class Base
+      include Identification
+      include InternalChannel
+      include Authorization
+      include Callbacks
+      include ActiveSupport::Rescuable
+
+      attr_reader :subscriptions, :logger
+      private attr_reader :server, :socket
+
+      delegate :pubsub, :executor, :config, to: :server
+      delegate :env, :request, :protocol, :perform_work, to: :socket, allow_nil: true
+
+      def initialize(server, socket)
+        @server = server
+        @socket = socket
+
+        @logger = socket.logger
+        @subscriptions  = Subscriptions.new(self)
+
+        @_internal_subscriptions = nil
+
+        @started_at = Time.now
+      end
+
+      # This method is called every time an Action Cable client establishes an underlying connection.
+      # Override it in your class to define authentication logic and
+      # populate connection identifiers.
+      def connect
+      end
+
+      # This method is called every time an Action Cable client disconnects.
+      # Override it in your class to cleanup the relevant application state (e.g., presence, online counts, etc.)
+      def disconnect
+      end
+
+      def handle_open
+        connect
+        subscribe_to_internal_channel
+        send_welcome_message
+      rescue ActionCable::Connection::Authorization::UnauthorizedError
+        close(reason: ActionCable::INTERNAL[:disconnect_reasons][:unauthorized], reconnect: false)
+      end
+
+      def handle_close
+        subscriptions.unsubscribe_from_all
+        unsubscribe_from_internal_channel
+
+        disconnect
+      end
+
+      def handle_channel_command(payload)
+        run_callbacks :command do
+          subscriptions.execute_command payload
+        end
+      rescue Exception => e
+        rescue_with_handler(e) || raise
+      end
+
+      alias_method :handle_incoming, :handle_channel_command
+
+      def transmit(data) # :nodoc:
+        socket.transmit(data)
+      end
+
+      # Close the connection.
+      def close(reason: nil, reconnect: true)
+        transmit(
+          type: ActionCable::INTERNAL[:message_types][:disconnect],
+          reason: reason,
+          reconnect: reconnect
+        )
+        socket.close
+      end
+
+      # Return a basic hash of statistics for the connection keyed with `identifier`,
+      # `started_at`, `subscriptions`, and `request_id`. This can be returned by a
+      # health check against the connection.
+      def statistics
+        {
+          identifier: connection_identifier,
+          started_at: @started_at,
+          subscriptions: subscriptions.identifiers,
+          request_id: env["action_dispatch.request_id"]
+        }
+      end
+
+      def beat
+        transmit type: ActionCable::INTERNAL[:message_types][:ping], message: Time.now.to_i
+      end
+
+      def inspect # :nodoc:
+        "#<#{self.class.name}:#{'%#016x' % (object_id << 1)}>"
+      end
+
+      private
+        # The cookies of the request that initiated the WebSocket connection. Useful for performing authorization checks.
+        def cookies # :doc:
+          request.cookie_jar
+        end
+
+        def send_welcome_message
+          # Send welcome message to the internal connection monitor channel. This ensures
+          # the connection monitor state is reset after a successful websocket connection.
+          transmit type: ActionCable::INTERNAL[:message_types][:welcome]
+        end
+    end
+  end
+end
+
+ActiveSupport.run_load_hooks(:action_cable_connection, ActionCable::Connection::Base)

data/lib/action_cable/connection/callbacks.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/callbacks"
+
+module ActionCable
+  module Connection
+    # # Action Cable Connection Callbacks
+    #
+    # The [before_command](rdoc-ref:ClassMethods#before_command),
+    # [after_command](rdoc-ref:ClassMethods#after_command), and
+    # [around_command](rdoc-ref:ClassMethods#around_command) callbacks are invoked
+    # when sending commands to the client, such as when subscribing, unsubscribing,
+    # or performing an action.
+    #
+    # #### Example
+    #
+    #     module ApplicationCable
+    #       class Connection < ActionCable::Connection::Base
+    #         identified_by :user
+    #
+    #         around_command :set_current_account
+    #
+    #         private
+    #
+    #         def set_current_account
+    #           # Now all channels could use Current.account
+    #           Current.set(account: user.account) { yield }
+    #         end
+    #       end
+    #     end
+    #
+    module Callbacks
+      extend  ActiveSupport::Concern
+      include ActiveSupport::Callbacks
+
+      included do
+        define_callbacks :command
+      end
+
+      module ClassMethods
+        def before_command(*methods, &block)
+          set_callback(:command, :before, *methods, &block)
+        end
+
+        def after_command(*methods, &block)
+          set_callback(:command, :after, *methods, &block)
+        end
+
+        def around_command(*methods, &block)
+          set_callback(:command, :around, *methods, &block)
+        end
+      end
+    end
+  end
+end

data/lib/action_cable/connection/identification.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "set"
+
+module ActionCable
+  module Connection
+    module Identification
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :identifiers, default: Set.new
+      end
+
+      module ClassMethods
+        # Mark a key as being a connection identifier index that can then be used to
+        # find the specific connection again later. Common identifiers are current_user
+        # and current_account, but could be anything, really.
+        #
+        # Note that anything marked as an identifier will automatically create a
+        # delegate by the same name on any channel instances created off the connection.
+        def identified_by(*identifiers)
+          Array(identifiers).each { |identifier| attr_accessor identifier }
+          self.identifiers += identifiers
+        end
+      end
+
+      # Return a single connection identifier that combines the value of all the
+      # registered identifiers into a single gid.
+      def connection_identifier
+        unless defined? @connection_identifier
+          @connection_identifier = connection_gid identifiers.filter_map { |id| instance_variable_get("@#{id}") }
+        end
+
+        @connection_identifier
+      end
+
+      private
+        def connection_gid(ids)
+          ids.map do |o|
+            if o.respond_to? :to_gid_param
+              o.to_gid_param
+            else
+              o.to_s
+            end
+          end.sort.join(":")
+        end
+    end
+  end
+end

data/lib/action_cable/connection/internal_channel.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  module Connection
+    # # Action Cable InternalChannel
+    #
+    # Makes it possible for the RemoteConnection to disconnect a specific
+    # connection.
+    module InternalChannel
+      extend ActiveSupport::Concern
+
+      private
+        def internal_channel
+          "action_cable/#{connection_identifier}"
+        end
+
+        def subscribe_to_internal_channel
+          if connection_identifier.present?
+            callback = -> (message) { process_internal_message ActiveSupport::JSON.decode(message) }
+            @_internal_subscriptions ||= []
+            @_internal_subscriptions << [ internal_channel, callback ]
+
+            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| pubsub.unsubscribe(channel, callback) }
+          end
+        end
+
+        def process_internal_message(message)
+          case message["type"]
+          when "disconnect"
+            logger.info "Removing connection (#{connection_identifier})"
+            close(reason: ActionCable::INTERNAL[:disconnect_reasons][:remote], reconnect: message.fetch("reconnect", true))
+          end
+        rescue Exception => e
+          logger.error "There was an exception - #{e.class}(#{e.message})"
+          logger.error e.backtrace.join("\n")
+
+          close
+        end
+    end
+  end
+end

data/lib/action_cable/connection/subscriptions.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/hash/indifferent_access"
+
+module ActionCable
+  module Connection
+    # # Action Cable Connection Subscriptions
+    #
+    # Collection class for all the channel subscriptions established on a given
+    # connection. Responsible for routing incoming commands that arrive on the
+    # connection to the proper channel.
+    class Subscriptions # :nodoc:
+      class Error < StandardError; end
+
+      class AlreadySubscribedError < Error
+        def initialize(identifier)
+          super "Already subscribed to #{identifier}"
+        end
+      end
+
+      class ChannelNotFound < Error
+        def initialize(channel_id)
+          super "Channel not found: #{channel_id}"
+        end
+      end
+
+      class MalformedCommandError < Error
+        def initialize(data)
+          super "Malformed command: #{data.inspect}"
+        end
+      end
+
+      class UnknownCommandError < Error
+        def initialize(command)
+          super "Received unrecognized command: #{command}"
+        end
+      end
+
+      class UnknownSubscription < Error
+        def initialize(identifier)
+          "Unable to find subscription with identifier: #{identifier}"
+        end
+      end
+
+      def initialize(connection)
+        @connection = connection
+        @subscriptions = {}
+      end
+
+      def execute_command(data)
+        case data["command"]
+        when "subscribe"   then add data
+        when "unsubscribe" then remove data
+        when "message"     then perform_action data
+        else
+          raise UnknownCommandError, data["command"]
+        end
+      end
+
+      def add(data)
+        id_key = data["identifier"]
+
+        raise MalformedCommandError, data unless id_key.present?
+
+        raise AlreadySubscribedError, id_key if subscriptions.key?(id_key)
+
+        subscription = subscription_from_identifier(id_key)
+
+        if subscription
+          subscriptions[id_key] = subscription
+          subscription.subscribe_to_channel
+        else
+          id_options = ActiveSupport::JSON.decode(id_key).with_indifferent_access
+          raise ChannelNotFound, id_options[:channel]
+        end
+      end
+
+      def remove(data)
+        logger.info "Unsubscribing from channel: #{data['identifier']}"
+        remove_subscription find(data)
+      end
+
+      def remove_subscription(subscription)
+        subscription.unsubscribe_from_channel
+        subscriptions.delete(subscription.identifier)
+      end
+
+      def perform_action(data)
+        find(data).perform_action ActiveSupport::JSON.decode(data["data"])
+      end
+
+      def identifiers
+        subscriptions.keys
+      end
+
+      def unsubscribe_from_all
+        subscriptions.each { |id, channel| remove_subscription(channel) }
+      end
+
+      private
+        attr_reader :connection, :subscriptions
+        delegate :logger, to: :connection
+
+        def find(data)
+          if subscription = subscriptions[data["identifier"]]
+            subscription
+          else
+            raise UnknownSubscription, data["identifier"]
+          end
+        end
+
+        def subscription_from_identifier(id_key)
+          id_options = ActiveSupport::JSON.decode(id_key).with_indifferent_access
+          subscription_klass = id_options[:channel].safe_constantize
+
+          if subscription_klass && ActionCable::Channel::Base > subscription_klass
+            subscription_klass.new(connection, id_key, id_options)
+          end
+        end
+    end
+  end
+end