litecable 0.4.0

data/lib/lite_cable/coders/raw.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module LiteCable
+  module Coders
+    # No-op coder
+    module Raw
+      class << self
+        def decode(val)
+          val
+        end
+
+        alias encode decode
+      end
+    end
+  end
+end

data/lib/lite_cable/config.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+require "anyway"
+require 'logger'
+
+module LiteCable
+  # Anycable configuration
+  class Config < Anyway::Config
+    require "lite_cable/coders/json"
+    require "lite_cable/coders/raw"
+
+    config_name :litecable
+
+    attr_config :logger,
+                coder: Coders::JSON,
+                identifier_coder: Coders::Raw,
+                log_level: Logger::INFO
+  end
+end

data/lib/lite_cable/connection.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module LiteCable
+  module Connection # :nodoc:
+    require "lite_cable/connection/authorization"
+    require "lite_cable/connection/identification"
+    require "lite_cable/connection/base"
+    require "lite_cable/connection/streams"
+    require "lite_cable/connection/subscriptions"
+  end
+end

data/lib/lite_cable/connection/authorization.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module LiteCable
+  module Connection
+    class UnauthorizedError < StandardError; end
+
+    # Include methods to control authorization flow
+    module Authorization
+      def reject_unauthorized_connection
+        raise UnauthorizedError
+      end
+    end
+  end
+end

data/lib/lite_cable/connection/base.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+module LiteCable
+  # rubocop:disable Metrics/LineLength
+  module Connection
+    # A Connection object represents a client "connected" to the application.
+    # It contains all of the channel subscriptions. Incoming messages are then routed to these channel subscriptions
+    # based on an identifier sent by the consumer.
+    # The Connection itself does not deal with any specific application logic beyond authentication and authorization.
+    #
+    # Here's a basic example:
+    #
+    #   module MyApplication
+    #     class Connection < LiteCable::Connection::Base
+    #       identified_by :current_user
+    #
+    #       def connect
+    #         self.current_user = find_verified_user
+    #       end
+    #
+    #       def disconnect
+    #         # Any cleanup work needed when the cable connection is cut.
+    #       end
+    #
+    #       private
+    #         def find_verified_user
+    #           User.find_by_identity(cookies[:identity]) ||
+    #             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 connection is established with the cookies from the domain being sent along. This makes
+    # it easy to use cookies that were set when logging in via a web interface to authorize the connection.
+    #
+    class Base
+      # rubocop:enable Metrics/LineLength
+      include Authorization
+      prepend Identification
+      include Logging
+
+      attr_reader :subscriptions, :streams, :coder
+
+      def initialize(socket, coder: nil)
+        @socket = socket
+        @coder = coder || LiteCable.config.coder
+
+        @subscriptions = Subscriptions.new(self)
+        @streams = Streams.new(socket)
+      end
+
+      def handle_open
+        connect if respond_to?(:connect)
+        send_welcome_message
+        log(:debug) { log_fmt("Opened") }
+      rescue UnauthorizedError
+        log(:debug) { log_fmt("Authorization failed") }
+        close
+      end
+
+      def handle_close
+        disconnected!
+        subscriptions.remove_all
+
+        disconnect if respond_to?(:disconnect)
+        log(:debug) { log_fmt("Closed") }
+      end
+
+      def handle_command(websocket_message)
+        command = decode(websocket_message)
+        subscriptions.execute_command command
+      rescue Subscriptions::Error, Channel::Error, Channel::Registry::Error => e
+        log(:error, log_fmt("Connection command failed: #{e}"))
+        close
+      end
+
+      def transmit(cable_message)
+        return if disconnected?
+        socket.transmit encode(cable_message)
+      end
+
+      def close
+        socket.close
+      end
+
+      # Rack::Request instance of underlying socket
+      def request
+        socket.request
+      end
+
+      # Request cookies
+      def cookies
+        request.cookies
+      end
+
+      def disconnected?
+        @_disconnected == true
+      end
+
+      private
+
+      attr_reader :socket
+
+      def disconnected!
+        @_disconnected = true
+      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: LiteCable::INTERNAL[:message_types][:welcome]
+      end
+
+      def encode(cable_message)
+        coder.encode cable_message
+      end
+
+      def decode(websocket_message)
+        coder.decode websocket_message
+      end
+
+      def log_fmt(msg)
+        "[connection:#{identifier}] #{msg}"
+      end
+    end
+  end
+end

data/lib/lite_cable/connection/identification.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+require "set"
+
+module LiteCable
+  module Connection
+    module Identification # :nodoc:
+      module ClassMethods # :nodoc:
+        # Mark a key as being a connection identifier index
+        # that can then be used to find the specific connection again later.
+        def identified_by(*identifiers)
+          Array(identifiers).each do |identifier|
+            attr_writer identifier
+            define_method(identifier) do
+              return instance_variable_get(:"@#{identifier}") if
+                instance_variable_defined?(:"@#{identifier}")
+              fetch_identifier(identifier.to_s)
+            end
+          end
+
+          self.identifiers += identifiers
+        end
+      end
+
+      def self.prepended(base)
+        base.class_eval do
+          class << self
+            attr_writer :identifiers
+
+            def identifiers
+              @identifiers ||= Set.new
+            end
+
+            include ClassMethods
+          end
+        end
+      end
+
+      def initialize(socket, identifiers: nil, **hargs)
+        @encoded_ids = identifiers ? JSON.parse(identifiers) : {}
+        super socket, **hargs
+      end
+
+      def identifiers
+        self.class.identifiers
+      end
+
+      # Return a single connection identifier
+      # that combines the value of all the registered identifiers into a single id.
+      #
+      # You can specify a custom identifier_coder in config
+      # to implement specific logic of encoding/decoding
+      # custom classes to identifiers.
+      #
+      # By default uses Raw coder.
+      def identifier
+        unless defined? @identifier
+          values = identifiers_hash.values.compact
+          @identifier = values.empty? ? nil : values.map(&:to_s).sort.join(":")
+        end
+
+        @identifier
+      end
+
+      # Generate identifiers info as hash.
+      def identifiers_hash
+        identifiers.each_with_object({}) do |id, acc|
+          obj = instance_variable_get("@#{id}")
+          next unless obj
+          acc[id.to_s] = LiteCable.config.identifier_coder.encode(obj)
+        end
+      end
+
+      def identifiers_json
+        identifiers_hash.to_json
+      end
+
+      # Fetch identifier and deserialize if neccessary
+      def fetch_identifier(name)
+        val = @encoded_ids[name]
+        val = LiteCable.config.identifier_coder.decode(val) unless val.nil?
+        instance_variable_set(
+          :"@#{name}",
+          val
+        )
+      end
+    end
+  end
+end

data/lib/lite_cable/connection/streams.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+module LiteCable
+  module Connection
+    # Manage the connection streams
+    class Streams
+      attr_reader :socket
+
+      def initialize(socket)
+        @socket = socket
+      end
+
+      # Start streaming from broadcasting to the channel.
+      def add(channel_id, broadcasting)
+        socket.subscribe(channel_id, broadcasting)
+      end
+
+      # Stop streaming from broadcasting to the channel.
+      def remove(channel_id, broadcasting)
+        socket.unsubscribe(channel_id, broadcasting)
+      end
+
+      # Stop all streams for the channel
+      def remove_all(channel_id)
+        socket.unsubscribe_from_all(channel_id)
+      end
+    end
+  end
+end

data/lib/lite_cable/connection/subscriptions.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+module LiteCable
+  module Connection
+    # Manage the connection channels and route messages
+    class Subscriptions
+      class Error < StandardError; end
+      class AlreadySubscribedError < Error; end
+      class UnknownCommandError < Error; end
+      class ChannelNotFoundError < Error; end
+
+      include Logging
+
+      def initialize(connection)
+        @connection = connection
+        @subscriptions = {}
+      end
+
+      def identifiers
+        subscriptions.keys
+      end
+
+      def add(identifier, subscribe = true)
+        raise AlreadySubscribedError if find(identifier)
+
+        params = connection.coder.decode(identifier)
+
+        channel_id = params.delete("channel")
+
+        channel_class = Channel::Registry.find!(channel_id)
+
+        subscriptions[identifier] = channel_class.new(connection, identifier, params)
+        subscribe ? subscribe_channel(subscriptions[identifier]) : subscriptions[identifier]
+      end
+
+      def remove(identifier)
+        channel = find!(identifier)
+        subscriptions.delete(identifier)
+        channel.handle_unsubscribe
+        log(:debug) { log_fmt("Unsubscribed from channel #{channel.class.id}") }
+        transmit_subscription_cancel(channel.identifier)
+      end
+
+      def remove_all
+        subscriptions.keys.each(&method(:remove))
+      end
+
+      def perform_action(identifier, data)
+        channel = find!(identifier)
+        channel.handle_action data
+      end
+
+      def execute_command(data)
+        command = data.delete("command")
+        case command
+        when "subscribe"   then add(data["identifier"])
+        when "unsubscribe" then remove(data["identifier"])
+        when "message"     then perform_action(data["identifier"], data["data"])
+        else
+          raise UnknownCommandError
+        end
+      end
+
+      def find(identifier)
+        subscriptions[identifier]
+      end
+
+      def find!(identifier)
+        channel = find(identifier)
+        raise ChannelNotFoundError unless channel
+        channel
+      end
+
+      private
+
+      attr_reader :connection, :subscriptions
+
+      def subscribe_channel(channel)
+        channel.handle_subscribe
+        log(:debug) { log_fmt("Subscribed to channel #{channel.class.id}") }
+        transmit_subscription_confirmation(channel.identifier)
+        channel
+      rescue Channel::RejectedError
+        subscriptions.delete(channel.identifier)
+        transmit_subscription_rejection(channel.identifier)
+        nil
+      end
+
+      def transmit_subscription_confirmation(identifier)
+        connection.transmit identifier: identifier,
+                            type: LiteCable::INTERNAL[:message_types][:confirmation]
+      end
+
+      def transmit_subscription_rejection(identifier)
+        connection.transmit identifier: identifier,
+                            type: LiteCable::INTERNAL[:message_types][:rejection]
+      end
+
+      def transmit_subscription_cancel(identifier)
+        connection.transmit identifier: identifier,
+                            type: LiteCable::INTERNAL[:message_types][:cancel]
+      end
+
+      def log_fmt(msg)
+        "[connection:#{connection.identifier}] #{msg}"
+      end
+    end
+  end
+end

data/lib/lite_cable/internal.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module LiteCable
+  INTERNAL = {
+    message_types: {
+      welcome: "welcome",
+      ping: "ping",
+      confirmation: "confirm_subscription",
+      rejection: "reject_subscription",
+      cancel: "cancel_subscription"
+    }.freeze,
+    protocols: ["actioncable-v1-json", "actioncable-unsupported"].freeze
+  }.freeze
+end

data/lib/lite_cable/logging.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require 'logger'
+
+module LiteCable
+  module Logging # :nodoc:
+    PREFIX = "LiteCable"
+
+    class << self
+      def logger
+        return @logger if instance_variable_defined?(:@logger)
+
+        @logger = LiteCable.config.logger
+        return if @logger == false
+
+        @logger ||= ::Logger.new(STDERR).tap do |logger|
+          logger.level = LiteCable.config.log_level
+        end
+      end
+    end
+
+    private
+
+    def log(level, message = nil)
+      return unless LiteCable::Logging.logger
+      LiteCable::Logging.logger.send(level, PREFIX) { message || yield }
+    end
+  end
+end