anycable-rails-core 1.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7bc0b1eac8c453d0054d508826fd33e58b32684c89694fbbc393d2796db8f0c1
+  data.tar.gz: 82ff10fabf21471a9fdcc14e6d76d294902b89372002734538b66e1e7569ab1d
+SHA512:
+  metadata.gz: 53cda30136d94edc95e319a0e80bed3ce19716d15dd0e69eae0fc14ffb0c45d58ec0fb466bece171736f4821a7aeeba6ec774c228e8915deb7b2eea01fed1565
+  data.tar.gz: 2787f8c23179f2283fe9b68982f0e3f0ea8fde5222ef97dba7294464523d8968f57f1c71f166f0d44583047747bbd40433e7603afb07c45f3b58eac98bba3cf4

data/CHANGELOG.md

@@ -0,0 +1,203 @@
+# Change log
+
+## master
+
+## 1.4.0 (2023-07-07)
+
+- Add HTTP RPC integration. ([@palkan][])
+
+Specify `http_rpc_mounth_path` in your `anycable.yml` to enable HTTP RPC.
+
+- Fix `anycable:download` command. ([@palkan][])
+
+Detect MacOS arm64, create target bin path if it doesn't exist.
+
+## 1.3.7 (2023-02-28)
+
+- Fix `anycable` gem dependency constraints.
+
+- Require Ruby 2.7+.
+
+## 1.3.6 (2023-02-28)
+
+- Handle `nil` streams gracefully. ([@palkan][])
+
+- Report exceptions via the `Rails.error.report` interface. ([@palkan][])
+
+## 1.3.5 (2023-01-04)
+
+- Make misconfiguration error more informative. ([@palkan][])
+
+## 1.3.4 (2022-06-28)
+
+- Add support and backport for Connection command callbacks. ([@palkan][])
+
+## 1.3.3 (2022-04-20)
+
+- Added `sid` (unique connection identifier) field to the `welcome` message if present. ([@palkan][])
+
+- Fixed handling Ruby Logger incompatible loggers. ([@palkan][])
+
+## 1.3.2 (2022-03-04)
+
+- Allow Ruby 2.6.
+
+## 1.3.1 (2022-02-28)
+
+- Fix Action Cable Channel patch to not change methods signatures. ([@palkan][])
+
+Otherwise it could lead to conflicts with other patches.
+
+## 1.3.0 (2022-02-21)
+
+- Introduce `AnyCable::Rails.extend_adapter!` to make any pubsub adapter AnyCable-compatible. ([@palkan][])
+
+- Refactored Action Cable patching to preserve original functionality and avoid monkey-patching collisions. ([@palkan][])
+
+## 1.2.1 (2022-01-31)
+
+- Add a temporary fix to be compatible with `sentry-rails`. ([@palkan][])
+
+See [#165](https://github.com/anycable/anycable-rails/issues/165).
+
+- Run embedded RPC server only if `any_cable` adapter is used for Action Cable. ([@palkan][])
+
+## 1.2.0 (2021-12-21) 🎄
+
+- Drop Rails 5 support.
+
+- Drop Ruby 2.6 support.
+
+## 1.1.4 (2021-11-11)
+
+- Added `Connection#state_attr_accessor`. ([@palkan][])
+
+## 1.1.3 (2021-10-11)
+
+- Relax Action Cable dependency. ([@palkan][])
+
+Action Cable 5.1 is allowed (though not recommended).
+
+## 1.1.2 (2021-06-23)
+
+- Bring back dependency on `anycable` (instead of `anycable-core`). ([@palkan][])
+
+Make it easier to get started by adding just a single gem.
+
+## 1.1.1 (2021-06-08)
+
+- Updated documentation links in the generator. ([@palkan][])
+
+## 1.1.0 🚸 (2021-06-01)
+
+- No changes since 1.1.0.rc1.1.
+
+## 1.1.0.rc1.1 (2021-05-12)
+
+- Fixed config loading regression introduced in 1.1.0.rc1.
+
+## 1.1.0.rc1 (2021-05-12)
+
+- Adding `anycable` or `grpc` gem as an explicit dependency is required.
+
+Now, `anycable-rails` depends on `anycable-core`, which doesn't include gRPC server implementation.
+You should either add `anycable` or `grpc` (>= 1.37) gem as an explicit dependency.
+
+- Add option to embed AnyCable RPC into a Rails server process. ([@palkan][])
+
+Set `embedded: true` in the configuration to launch RPC along with `rails s` (only for Rails 6.1+).
+
+- **Ruby >= 2.6** is required.
+- **Rails >= 6.0** is required.
+
+## 1.0.7 (2021-03-05)
+
+- Ruby 3 compatibility. ([@palkan][])
+
+## 1.0.6 (2021-02-25)
+
+- Keep an explicit list of instance vars to ignore in compatibility checks. ([@palkan][])
+
+You can ignore custom vars by adding them to the list: `AnyCable::Compatibility::IGNORE_INSTANCE_VARS << :@my_var`.
+
+## 1.0.5 (2021-02-24)
+
+- Fixed bug with compatibility false negatives in development. ([@palkan][])
+
+See [#151](https://github.com/anycable/anycable-rails/issues/151).
+
+## 1.0.4 (2020-10-02)
+
+- Relax Rails dependencies. ([@palkan][])
+
+Only add `actioncable` and `globalid` as runtime dependencies, not the whole `rails`.
+
+## 1.0.3 (2020-09-16)
+
+- Fixed bug with building a request object when session store is absent. ([@palkan][])
+
+## 1.0.2 (2020-09-08)
+
+- Added missing channel state support to `#unsubscribed` callbacks. ([@palkan][])
+
+## 1.0.1 (2020-07-07)
+
+- Fixed patching Action Cable testing classes. ([@palkan][])
+
+## 1.0.0 (2020-07-01)
+
+- Support `rescue_from` in connections (Rails 6.1). ([@palkan][])
+
+- Make AnyCable patches compatible with Action Cable testing. ([@palkan][])
+
+- Do not add localhost `redis_url` to `anycable.yml` when Docker development method is chosen in `anycable:setup`. ([@palkan][])
+
+- Fix connection identifiers deserialization regression. ([@palkan][])
+
+Using non-strings or non-GlobalId-encoded objects was broken.
+
+- Improve `anycable:setup` generator. ([@palkan][])
+
+Update Docker snippet, do not enable persistent sessions automatically,
+fix setting `config.action_cable.url` in environment configuration.
+
+- Add `state_attr_accessor` for channels. ([@palkan][])
+
+Just like `attr_accessor` but "persists" the state between RPC calls.
+
+- Add `Channel#stop_stream_from` support. ([@palkan][])
+
+- Add `RemoteConnections` support. ([@palkan][])
+
+- Add `AnyCable::Rails.enabled?` method which returns true if Action Cable uses AnyCable adapter. ([@palkan][])
+
+- Add `anycable:download` generator to download `anycable-go` binary. ([@palkan][])
+
+- **Ruby 2.5+ is required**. ([@palkan][])
+
+- Support `disconnect` messages. ([@palkan][])
+
+Added in Rails 6 (see [PR#34194](https://github.com/rails/rails/pull/34194)).
+
+- Add ability to persist _dirty_ `request.session` between RPC calls. ([@palkan][])
+
+This feature emulates the Action Cable behaviour where it's possible to use `request.session` as a shared Hash-like store.
+This could be used by some applications (e.g., [StimulusReflex](https://github.com/hopsoft/stimulus_reflex)-based).
+
+You must turn this feature on by setting `persistent_session_enabled: true` in the AnyCable configuration.
+
+- Add ability to use Rack middlewares when build a request for a connection. ([@bibendi][])
+
+- Add set up generator to configure a Rails application by running `bin/rails g anycable:setup`. ([@bibendi][])
+
+- Require a minimum version of Ruby when installing the gem. ([@bibendi][])
+
+- Add ability to develop the gem with Docker. ([@bibendi][])
+
+See [Changelog](https://github.com/anycable/anycable-rails/blob/0-6-stable/CHANGELOG.md) for versions <1.0.0.
+
+[@palkan]: https://github.com/palkan
+[@alekseyl]: https://github.com/alekseyl
+[@DmitryTsepelev]: https://github.com/DmitryTsepelev
+[@sponomarev]: https://github.com/sponomarev
+[@bibendi]: https://github.com/bibendi

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017-2023 palkan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,106 @@
+[![Gem Version](https://badge.fury.io/rb/anycable-rails.svg)](https://rubygems.org/gems/anycable-rails)
+[![Build](https://github.com/anycable/anycable-rails/workflows/Build/badge.svg)](https://github.com/anycable/anycable-rails/actions)
+[![Documentation](https://img.shields.io/badge/docs-link-brightgreen.svg)](https://docs.anycable.io/rails/getting_started)
+
+# AnyCable Rails
+
+AnyCable allows you to use any WebSocket server (written in any language) as a replacement for built-in Rails Action Cable server.
+
+With AnyCable you can use channels, client-side JS, broadcasting - (almost) all that you can do with Action Cable.
+
+You can even use Action Cable in development and not be afraid of [compatibility issues](#compatibility).
+
+💾 [Example Application](https://github.com/anycable/anycable_rails_demo)
+
+📑 [Documentation](https://docs.anycable.io/rails/getting_started).
+
+> [AnyCable Pro](https://docs.anycable.io/pro) has been launched 🚀
+
+<a href="https://evilmartians.com/">
+<img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54"></a>
+
+## Requirements
+
+- Ruby >= 2.6
+- Rails >= 6.0 (Rails 5.1 could work but we're no longer enforce compatibility on CI)
+- Redis (see [other options](https://github.com/anycable/anycable/issues/2) for broadcasting)
+
+## Usage
+
+Add `anycable-rails` gem to your Gemfile:
+
+```ruby
+gem "anycable-rails"
+
+# when using Redis broadcast adapter
+gem "redis", ">= 4.0"
+```
+
+### Interactive set up
+
+After the gem was installed, you can run an interactive wizard to configure your Rails application for using with AnyCable by running a generator:
+
+```sh
+bundle exec rails g anycable:setup
+```
+
+### Manual set up
+
+Specify AnyCable subscription adapter for Action Cable:
+
+```yml
+# config/cable.yml
+development:
+  adapter: any_cable # or anycable
+
+production:
+  adapter: any_cable
+```
+
+and specify AnyCable WebSocket server URL:
+
+```ruby
+# For development it's likely the localhost
+
+# config/environments/development.rb
+config.action_cable.url = "ws://localhost:8080/cable"
+
+# For production it's likely to have a sub-domain and secure connection
+
+# config/environments/production.rb
+config.action_cable.url = "wss://ws.example.com/cable"
+```
+
+Then, run AnyCable RPC server:
+
+```sh
+$ bundle exec anycable
+
+# don't forget to provide Rails env
+
+$ RAILS_ENV=production bundle exec anycable
+```
+
+And, finally, run AnyCable WebSocket server, e.g. [anycable-go](https://docs.anycable.io/anycable-go/getting_started):
+
+```sh
+anycable-go --host=localhost --port=8080
+```
+
+See [documentation](https://docs.anycable.io/rails/getting_started) for more information on AnyCable + Rails usage.
+
+## Action Cable Compatibility
+
+See [documentation](https://docs.anycable.io/rails/compatibility).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/anycable/anycable-rails](https://github.com/anycable/anycable-rails).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Security Contact
+
+To report a security vulnerability, please contact us at `anycable@evilmartians.com`. We will coordinate the fix and disclosure.

data/lib/action_cable/subscription_adapter/any_cable.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "anycable-rails"
+
+module ActionCable
+  module SubscriptionAdapter
+    # AnyCable subscription adapter delegates broadcasts
+    # to AnyCable
+    class AnyCable < Base
+      ACTION_CABLE_SERVER_ERROR_MESSAGE = <<~STR
+        Looks like you're trying to connect to Rails Action Cable server, not an AnyCable one.
+
+        Please make sure your client is configured to connect to AnyCable server.
+
+        See https://docs.anycable.io/troubleshooting
+      STR
+
+      def initialize(*)
+      end
+
+      def broadcast(channel, payload)
+        ::AnyCable.broadcast(channel, payload)
+      end
+
+      def subscribe(*)
+        raise NotImplementedError, ACTION_CABLE_SERVER_ERROR_MESSAGE
+      end
+
+      def unsubscribe(*)
+        raise NotImplementedError, ACTION_CABLE_SERVER_ERROR_MESSAGE
+      end
+
+      def shutdown
+        # nothing to do
+        # we only need this method for development,
+        # 'cause code reloading triggers `server.restart` -> `pubsub.shutdown`
+      end
+    end
+  end
+end

data/lib/action_cable/subscription_adapter/anycable.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "any_cable"
+
+module ActionCable
+  module SubscriptionAdapter
+    # Aliasing adapter
+    Anycable = AnyCable
+  end
+end

data/lib/anycable/rails/action_cable_ext/channel.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "action_cable"
+
+ActionCable::Channel::Base.prepend(Module.new do
+  def subscribe_to_channel
+    super unless anycabled? && !@__anycable_subscribing__
+  end
+
+  def handle_subscribe
+    @__anycable_subscribing__ = true
+    subscribe_to_channel
+  ensure
+    @__anycable_subscribing__ = false
+  end
+
+  def start_periodic_timers
+    super unless anycabled?
+  end
+
+  def stop_periodic_timers
+    super unless anycabled?
+  end
+
+  def stream_from(broadcasting, _callback = nil, **)
+    return super unless anycabled?
+
+    broadcasting = String(broadcasting)
+
+    connection.anycable_socket.subscribe identifier, broadcasting
+  end
+
+  def stop_stream_from(broadcasting)
+    return super unless anycabled?
+
+    connection.anycable_socket.unsubscribe identifier, broadcasting
+  end
+
+  def stop_all_streams
+    return super unless anycabled?
+
+    connection.anycable_socket.unsubscribe_from_all identifier
+  end
+
+  private
+
+  def anycabled?
+    # Use instance variable check here for testing compatibility
+    connection.instance_variable_defined?(:@anycable_socket)
+  end
+end)

data/lib/anycable/rails/action_cable_ext/connection.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "action_cable"
+require "anycable/rails/connections/serializable_identification"
+
+ActionCable::Connection::Base.include(AnyCable::Rails::Connections::SerializableIdentification)
+ActionCable::Connection::Base.prepend(Module.new do
+  attr_reader :anycable_socket
+  attr_accessor :anycable_request_builder
+
+  # In AnyCable, we lazily populate env by passing it through the middleware chain,
+  # so we access it via #request
+  def env
+    return super unless anycabled?
+
+    request.env
+  end
+
+  def anycabled?
+    @anycable_socket
+  end
+
+  private
+
+  def request
+    return super unless anycabled?
+
+    @request ||= anycable_request_builder.build_rack_request(@env)
+  end
+end)
+
+# Backport command callbacks: https://github.com/rails/rails/pull/44696
+unless ActionCable::Connection::Base.respond_to?(:before_command)
+  ActionCable::Connection::Base.include ActiveSupport::Callbacks
+  ActionCable::Connection::Base.define_callbacks :command
+  ActionCable::Connection::Base.extend(Module.new do
+    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)
+
+  ActionCable::Connection::Base.prepend(Module.new do
+    def dispatch_websocket_message(websocket_message)
+      return super unless websocket.alive?
+
+      handle_channel_command(decode(websocket_message))
+    end
+
+    def handle_channel_command(payload)
+      run_callbacks :command do
+        subscriptions.execute_command payload
+      end
+    end
+  end)
+end
+
+# Trigger autoload
+test_case_defined = false
+
+begin
+  ActionCable::Connection::TestCase # rubocop:disable Lint/Void
+  test_case_defined = true
+rescue NameError
+end
+
+# Backport: https://github.com/rails/rails/pull/45445
+if test_case_defined && !ActionCable::Connection::TestConnection.method_defined?(:transmissions)
+  ActionCable::Connection::TestConnection.prepend(Module.new do
+    attr_reader :transmissions
+
+    def initialize(*)
+      super
+
+      @transmissions = []
+      @subscriptions = ActionCable::Connection::Subscriptions.new(self)
+    end
+
+    def transmit(cable_message)
+      transmissions << cable_message.with_indifferent_access
+    end
+  end)
+end

data/lib/anycable/rails/action_cable_ext/remote_connections.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "action_cable/remote_connections"
+
+ActionCable::RemoteConnections::RemoteConnection.include(AnyCable::Rails::Connections::SerializableIdentification)
+
+ActionCable::RemoteConnections::RemoteConnection.prepend(Module.new do
+  def disconnect(reconnect: true)
+    # Legacy Action Cable functionality if case we're not fully migrated yet
+    super() unless AnyCable::Rails.enabled?
+    ::AnyCable.broadcast_adapter.broadcast_command("disconnect", identifier: identifiers_json, reconnect: reconnect)
+  end
+end)

data/lib/anycable/rails/channel_state.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module Rails
+    module ChannelState
+      module ClassMethods
+        def state_attr_accessor(*names)
+          names.each do |name|
+            channel_state_attributes << name
+            class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{name}
+                return @#{name} if instance_variable_defined?(:@#{name})
+                @#{name} = AnyCable::Rails.deserialize(__istate__["#{name}"], json: true) if anycabled?
+              end
+
+              def #{name}=(val)
+                __istate__["#{name}"] = AnyCable::Rails.serialize(val, json: true) if anycabled?
+                instance_variable_set(:@#{name}, val)
+              end
+            RUBY
+          end
+        end
+
+        def channel_state_attributes
+          return @channel_state_attributes if instance_variable_defined?(:@channel_state_attributes)
+
+          @channel_state_attributes =
+            if superclass.respond_to?(:channel_state_attributes)
+              superclass.channel_state_attributes.dup
+            else
+              []
+            end
+        end
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      # Make it possible to provide istate explicitly for a channel instance
+      attr_writer :__istate__
+
+      def __istate__
+        @__istate__ ||= connection.anycable_socket.istate
+      end
+    end
+
+    module ConnectionState
+      module ClassMethods
+        def state_attr_accessor(*names)
+          names.each do |name|
+            connection_state_attributes << name
+            class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{name}
+                return @#{name} if instance_variable_defined?(:@#{name})
+                @#{name} = AnyCable::Rails.deserialize(__cstate__["#{name}"], json: true) if anycabled?
+              end
+
+              def #{name}=(val)
+                __cstate__["#{name}"] = AnyCable::Rails.serialize(val, json: true) if anycabled?
+                instance_variable_set(:@#{name}, val)
+              end
+            RUBY
+          end
+        end
+
+        def connection_state_attributes
+          return @connection_state_attributes if instance_variable_defined?(:@connection_state_attributes)
+
+          @connection_state_attributes =
+            if superclass.respond_to?(:connection_state_attributes)
+              superclass.connection_state_attributes.dup
+            else
+              []
+            end
+        end
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      # Make it possible to provide istate explicitly for a connection instance
+      attr_writer :__cstate__
+
+      def __cstate__
+        @__cstate__ ||= anycable_socket.cstate
+      end
+    end
+  end
+end
+
+if ActiveSupport::VERSION::MAJOR < 6
+  # `state_attr_accessor` must be available in Action Cable
+  ActiveSupport.on_load(:action_cable) do
+    ::ActionCable::Connection::Base.include(AnyCable::Rails::ConnectionState)
+    ::ActionCable::Channel::Base.include(AnyCable::Rails::ChannelState)
+  end
+else
+  # `state_attr_accessor` must be available in Action Cable
+  ActiveSupport.on_load(:action_cable_connection) do
+    ::ActionCable::Connection::Base.include(AnyCable::Rails::ConnectionState)
+  end
+
+  ActiveSupport.on_load(:action_cable_channel) do
+    ::ActionCable::Channel::Base.include(AnyCable::Rails::ChannelState)
+  end
+end

data/lib/anycable/rails/compatibility/rubocop/config/default.yml

@@ -0,0 +1,14 @@
+AnyCable/InstanceVars:
+  Enabled: true
+  Include:
+    - "**/channels/**/*.rb"
+
+AnyCable/StreamFrom:
+  Enabled: true
+  Include:
+    - "**/channels/**/*.rb"
+
+AnyCable/PeriodicalTimers:
+  Enabled: true
+  Include:
+    - "**/channels/**/*.rb"