anycable-rails-core 1.4.0

data/lib/anycable/rails/connections/session_proxy.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module Rails
+    module Connections
+      # Wrap `request.session` to lazily load values provided
+      # in the RPC call (set by the previous calls)
+      class SessionProxy
+        attr_reader :rack_session, :socket_session
+
+        def initialize(rack_session, socket_session)
+          @rack_session = rack_session
+          @socket_session = JSON.parse(socket_session).with_indifferent_access
+        end
+
+        %i[has_key? [] []= fetch delete dig].each do |mid|
+          class_eval <<~CODE, __FILE__, __LINE__ + 1
+            def #{mid}(*args, **kwargs, &block)
+              restore_key! args.first
+              rack_session.#{mid}(*args, **kwargs, &block)
+            end
+          CODE
+        end
+
+        alias_method :include?, :has_key?
+        alias_method :key?, :has_key?
+
+        %i[update merge! to_hash].each do |mid|
+          class_eval <<~CODE, __FILE__, __LINE__ + 1
+            def #{mid}(*args, **kwargs, &block)
+              restore!
+              rack_session.#{mid}(*args, **kwargs, &block)
+            end
+          CODE
+        end
+
+        alias_method :to_h, :to_hash
+
+        def keys
+          rack_session.keys + socket_session.keys
+        end
+
+        # Delegate both publuc and private methods to rack_session
+        def respond_to_missing?(name, include_private = false)
+          return false if name == :marshal_dump || name == :_dump
+          rack_session.respond_to?(name, include_private) || super
+        end
+
+        def method_missing(method, *args, &block)
+          if rack_session.respond_to?(method, true)
+            rack_session.send(method, *args, &block)
+          else
+            super
+          end
+        end
+
+        # This method is used by StimulusReflex to obtain `@by`
+        def instance_variable_get(name)
+          super || rack_session.instance_variable_get(name)
+        end
+
+        private
+
+        def restore!
+          socket_session.keys.each(&method(:restore_key!))
+        end
+
+        def restore_key!(key)
+          return unless socket_session.key?(key)
+          val = socket_session.delete(key)
+          rack_session[key] =
+            if val.is_a?(String)
+              GlobalID::Locator.locate(val) || val
+            else
+              val
+            end
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rails/middlewares/executor.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module Rails
+    module Middlewares
+      # Executor runs Rails executor for each call
+      # See https://guides.rubyonrails.org/v5.2.0/threading_and_code_execution.html#framework-behavior
+      class Executor < AnyCable::Middleware
+        attr_reader :executor
+
+        def initialize(executor)
+          @executor = executor
+        end
+
+        def call(method, message, metadata)
+          if ::Rails.respond_to?(:error)
+            executor.wrap do
+              sid = metadata["sid"]
+
+              ::Rails.error.record(context: {method: method, payload: message.to_h, sid: sid}) do
+                yield
+              end
+            end
+          else
+            executor.wrap { yield }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rails/middlewares/log_tagging.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module Rails
+    module Middlewares
+      # Middleware to add `sid` (session ID) tag to logs.
+      #
+      # Session ID could be provided through gRPC metadata `sid` key.
+      #
+      # See https://github.com/grpc/grpc-go/blob/master/Documentation/grpc-metadata.md
+      class LogTagging < AnyCable::Middleware
+        def call(_method, _request, metadata)
+          sid = metadata["sid"]
+          return yield unless sid
+
+          AnyCable.logger.tagged("AnyCable sid=#{sid}") { yield }
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rails/rack.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "rails/configuration"
+require "action_dispatch/middleware/stack"
+
+module AnyCable
+  module Rails
+    # Rack middleware stack to modify the HTTP request object.
+    #
+    # AnyCable Websocket server does not use Rack middleware processing mechanism (which Rails uses
+    # when Action Cable is mounted into the main app).
+    #
+    # Some middlewares could enhance request env with useful information.
+    #
+    # For instance, consider the Rails session middleware: it's responsible for restoring the
+    # session data from cookies.
+    #
+    # AnyCable adds session middelware by default to its own stack.
+    #
+    # You can also use any Rack/Rails middleware you want. For example, to enable Devise/Warden
+    # you can add the following code to an initializer or any other configuration file:
+    #
+    #   AnyCable::Rails::Rack.middleware.use Warden::Manager do |config|
+    #     Devise.warden_config = config
+    #   end
+    module Rack
+      def self.app_build_lock
+        @app_build_lock
+      end
+
+      @app_build_lock = Mutex.new
+
+      def self.middleware
+        @middleware ||= ::Rails::Configuration::MiddlewareStackProxy.new
+      end
+
+      def self.default_middleware_stack
+        config = ::Rails.application.config
+
+        ActionDispatch::MiddlewareStack.new do |middleware|
+          middleware.use(config.session_store, config.session_options) if config.session_store
+        end
+      end
+
+      def self.app
+        @rack_app || app_build_lock.synchronize do
+          @rack_app ||= default_middleware_stack.yield_self do |stack|
+                          middleware.merge_into(stack)
+                        end.yield_self do |stack|
+            stack.build { [-1, {}, []] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rails/railtie.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "anycable/rails/action_cable_ext/connection"
+require "anycable/rails/action_cable_ext/channel"
+require "anycable/rails/action_cable_ext/remote_connections"
+
+require "anycable/rails/channel_state"
+require "anycable/rails/connection_factory"
+
+module AnyCable
+  module Rails
+    class Railtie < ::Rails::Railtie # :nodoc:
+      initializer "anycable.disable_action_cable_mount", after: "action_cable.set_configs" do |app|
+        next unless AnyCable::Rails.enabled?
+
+        app.config.action_cable.mount_path = nil
+      end
+
+      initializer "anycable.logger", after: "action_cable.logger" do |_app|
+        AnyCable.logger = ::ActionCable.server.config.logger
+
+        AnyCable.configure_server do
+          server_logger = AnyCable.logger = ::ActionCable.server.config.logger
+          AnyCable.logger = ActiveSupport::TaggedLogging.new(server_logger) if server_logger.is_a?(::Logger)
+          # Broadcast server logs to STDOUT in development
+          if ::Rails.env.development? &&
+              !ActiveSupport::Logger.logger_outputs_to?(::Rails.logger, $stdout)
+            console = ActiveSupport::Logger.new($stdout)
+            console.formatter = ::Rails.logger.formatter if ::Rails.logger.respond_to?(:formatter)
+            console.level = ::Rails.logger.level if ::Rails.logger.respond_to?(:level)
+            AnyCable.logger.extend(ActiveSupport::Logger.broadcast(console))
+          end
+        end
+
+        # Add tagging middleware
+        if AnyCable.logger.respond_to?(:tagged)
+          require "anycable/rails/middlewares/log_tagging"
+
+          AnyCable.middleware.use(AnyCable::Rails::Middlewares::LogTagging)
+        end
+      end
+
+      initializer "anycable.executor" do |app|
+        require "anycable/rails/middlewares/executor"
+        # see https://github.com/rails/rails/pull/33469/files
+        executor = app.config.reload_classes_only_on_change ? app.reloader : app.executor
+        AnyCable.middleware.use(AnyCable::Rails::Middlewares::Executor.new(executor))
+
+        if app.executor.respond_to?(:error_reporter)
+          AnyCable.capture_exception do |ex, method, message|
+            ::Rails.error.report(ex, handled: false, context: {method: method.to_sym, payload: message})
+          end
+        end
+      end
+
+      initializer "anycable.connection_factory", after: "action_cable.set_configs" do |app|
+        ActiveSupport.on_load(:action_cable) do
+          app.config.to_prepare do
+            AnyCable.connection_factory = AnyCable::Rails::ConnectionFactory.new
+          end
+
+          if AnyCable.config.persistent_session_enabled?
+            require "anycable/rails/connections/persistent_session"
+          end
+        end
+      end
+
+      initializer "anycable.routes" do
+        next unless AnyCable::Rails.enabled?
+
+        config.after_initialize do |app|
+          config = AnyCable.config
+          unless config.http_rpc_mount_path.nil?
+            app.routes.prepend do
+              mount AnyCable::HTTRPC::Server.new => config.http_rpc_mount_path, :internal => true
+            end
+          end
+        end
+      end
+
+      # Since Rails 6.1
+      if respond_to?(:server)
+        server do
+          next unless AnyCable.config.embedded? && AnyCable::Rails.enabled?
+
+          require "anycable/cli"
+          AnyCable::CLI.embed!
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rails/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module Rails
+    VERSION = "1.4.0"
+  end
+end

data/lib/anycable/rails.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "anycable"
+require "anycable/rails/version"
+require "anycable/rails/config"
+require "anycable/rails/rack"
+
+require "globalid"
+
+module AnyCable
+  # Rails handler for AnyCable
+  module Rails
+    require "anycable/rails/railtie"
+
+    ADAPTER_ALIASES = %w[any_cable anycable].freeze
+
+    class << self
+      def enabled?
+        adapter = ::ActionCable.server.config.cable&.fetch("adapter", nil)
+        compatible_adapter?(adapter)
+      end
+
+      def compatible_adapter?(adapter)
+        ADAPTER_ALIASES.include?(adapter)
+      end
+
+      # Serialize connection/channel state variable to string
+      # using GlobalID where possible or JSON (if json: true)
+      def serialize(obj, json: false)
+        obj.try(:to_gid_param) || (json ? obj.to_json : obj)
+      end
+
+      # Deserialize previously serialized value from string to
+      # Ruby object.
+      # If the resulting object is a Hash, make it indifferent
+      def deserialize(str, json: false)
+        str.yield_self do |val|
+          next val unless val.is_a?(String)
+
+          gval = GlobalID::Locator.locate(val)
+          return gval if gval
+
+          next val unless json
+
+          JSON.parse(val)
+        end.yield_self do |val|
+          next val.with_indifferent_access if val.is_a?(Hash)
+          val
+        end
+      end
+
+      module Extension
+        def broadcast(channel, payload)
+          super
+          ::AnyCable.broadcast(channel, payload)
+        end
+      end
+
+      def extend_adapter!(adapter)
+        adapter.extend(Extension)
+      end
+    end
+  end
+end
+
+# Warn if application has been already initialized.
+# AnyCable should be loaded before initialization in order to work correctly.
+if defined?(::Rails) && ::Rails.application && ::Rails.application.initialized?
+  puts("\n**************************************************")
+  puts(
+    "⛔️  WARNING: AnyCable loaded after application initialization. Might not work correctly.\n" \
+    "Please, make sure to remove `require: false` in your Gemfile or " \
+    "require manually in `environment.rb` before `Rails.application.initialize!`"
+  )
+  puts("**************************************************\n\n")
+end

data/lib/anycable-rails.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "anycable/rails"

data/lib/generators/anycable/download/USAGE

@@ -0,0 +1,14 @@
+Description:
+    Install AnyCable-Go web server locally (the latest version by default).
+
+Example:
+    rails generate anycable:download
+
+    This will ask:
+        Where to store a binary file.
+    This will create:
+        `<bin_path>/anycable-go`.
+
+    rails generate anycable:download --bin-path=/usr/local/bin
+
+    rails generate anycable:download --version=1.0.0

data/lib/generators/anycable/download/download_generator.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "generators/anycable/with_os_helpers"
+
+module AnyCableRailsGenerators
+  # Downloads anycable-go binary
+  class DownloadGenerator < ::Rails::Generators::Base
+    namespace "anycable:download"
+
+    include WithOSHelpers
+
+    VERSION = "latest"
+
+    class_option :bin_path,
+      type: :string,
+      desc: "Where to download AnyCable-Go server binary (default: #{DEFAULT_BIN_PATH})"
+    class_option :version,
+      type: :string,
+      desc: "Specify the AnyCable-Go version (defaults to latest release)"
+
+    def download_bin
+      out = options[:bin_path] || DEFAULT_BIN_PATH
+      version = options[:version] || VERSION
+
+      download_exe(
+        release_url(version),
+        to: out,
+        file_name: "anycable-go"
+      )
+
+      true
+    end
+
+    private
+
+    def release_url(version)
+      return latest_release_url(version) if version == "latest"
+
+      if Gem::Version.new(version).segments.first >= 1
+        new_release_url("v#{version}")
+      else
+        legacy_release_url("v#{version}")
+      end
+    end
+
+    def legacy_release_url(version)
+      "https://github.com/anycable/anycable-go/releases/download/#{version}/" \
+        "anycable-go-v#{version}-#{os_name}-#{cpu_name}"
+    end
+
+    def new_release_url(version)
+      "https://github.com/anycable/anycable-go/releases/download/#{version}/" \
+        "anycable-go-#{os_name}-#{cpu_name}"
+    end
+
+    def latest_release_url(version)
+      "https://github.com/anycable/anycable-go/releases/latest/download/" \
+        "anycable-go-#{os_name}-#{cpu_name}"
+    end
+
+    def download_exe(url, to:, file_name:)
+      file_path = File.join(to, file_name)
+
+      FileUtils.mkdir_p(to) unless File.directory?(to)
+
+      run "#{sudo(to)}curl -L #{url} -o #{file_path}", abort_on_failure: true
+      run "#{sudo(to)}chmod +x #{file_path}", abort_on_failure: true
+      run "#{file_path} -v", abort_on_failure: true
+    end
+
+    def sudo(path)
+      sudo = ""
+      unless File.writable?(path)
+        if yes? "Path is not writable 😕. Do you have sudo privileges?"
+          sudo = "sudo "
+        else
+          say_status :error, "❌ Failed to install AnyCable-Go WebSocket server", :red
+          raise StandardError, "Path #{path} is not writable!"
+        end
+      end
+
+      sudo
+    end
+  end
+end

data/lib/generators/anycable/setup/USAGE

@@ -0,0 +1,2 @@
+Description:
+    Configures your application to work with AnyCable interactively.