anycable-rails-core 1.4.4 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62bc4f7d0aef85236e0ff6a983e2a8c2db681397a70dacc91c85bbd4662377e8
-  data.tar.gz: 20cae16d638d1c47a96d5b235350c156d5e98f597858f72c9acab35aba3b0f0f
+  metadata.gz: e23407a3fe0b10d54fdb4c0b368f23df917dc5f901b821312c9464c37099c23d
+  data.tar.gz: ce1ea7b919210c7ea6a2d0098a5bf90141ce3910d57f17f9cbb116b96d93753f
 SHA512:
-  metadata.gz: bbb7e9670097c6ee0ce230f1a8226ffe0449c2cf4556b84bf465638fef385140c0aadbf2378477e37d09969617e74c66acda8c3c1f0075280abdc1a32792da58
-  data.tar.gz: 3a5498a417a077468f7adc6638c31f7d92a304f541475957bc74233e674c9cc6fc010ce432c9699b0eba2d308c8c1aacb4d85a21a7da7f48f8773162ece3c3fd
+  metadata.gz: 658fffc579a1ddea3001a6ed05f6b59dbe1f05f48ce27c70924cd0ae18b0d8c2bd4c3151b0ea82b52ea78f37e9217f2b80769683dadeba21b2f9f50b6588a566
+  data.tar.gz: c8982b7cae01bfdefa4c0bef71581b7de2b579a0471bf2ff32619c043e84710822026e9814682474e84c386880808d79a651db0d42ff68d0d7ae646630050522

data/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 ## master
 
+## 1.5.0 (2024-04-01)
+
+- Allow specifying the _whispering_ stream via `#stream_from(..., whisper: true)`. ([@palkan][])
+
+  You can use specify the stream to use for _whispering_ (client-initiated broadcasts) by adding `whisper: true` to the `#stream_from` (or `#stream_for`) method call.
+
+  NOTE: This feature is only supported when using AnyCable server and ignored otherwise.
+
+- Support passing objects to `ActionCable.server.broadcast`. ([@palkan][])
+
+  Make it possible to call `ActionCable.server.broadcast(user, data)` or `ActionCable.server.broadcast([user, :context], data)`. This is a companion functionality for `#signed_stream_name`.
+
+- Added `websocket_url` configuration option to specify the URL of AnyCable server. ([@palkan][])
+
+  It's used to configure `config.action_cable.url` if AnyCable is activated. No need to set up it manually.
+
+- Added `rails g anycable:bin` to create a binstub to run AnyCable server. ([@palkan][])
+
+- Added signed streams helpers. ([@palkan][])
+
+  You can use `#signed_stream_name(streamable)` to generate a signed stream name.
+
+- Added JWT authentication helpers. ([@palkan][])
+
+  No more need in a separate `anycable-rails-jwt` gem.
+
+## 1.4.5
+
+- Restrict `anycable` gem version.
+
 ## 1.4.4 (2024-03-08) 🌷
 
 - Minor fixes

data/lib/action_cable/subscription_adapter/any_cable.rb

@@ -8,7 +8,7 @@ module ActionCable
     # 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.
+        Looks like you are trying to connect to Rails Action Cable server, not an AnyCable one.
 
         Please make sure your client is configured to connect to AnyCable server.
 

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

@@ -10,6 +10,11 @@ ActionCable::Server::Base.prepend(Module.new do
       super(channel, payload)
     end
   end
+
+  def broadcaster_for(broadcasting, **options)
+    broadcasting = AnyCable::Rails.stream_name_from(broadcasting)
+    super(broadcasting, **options)
+  end
 end)
 
 ActionCable::Channel::Base.singleton_class.prepend(Module.new do

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

@@ -22,12 +22,20 @@ ActionCable::Channel::Base.prepend(Module.new do
     super unless anycabled?
   end
 
-  def stream_from(broadcasting, _callback = nil, **)
+  def stream_from(broadcasting, _callback = nil, **opts)
+    whispering = opts.delete(:whisper)
     return super unless anycabled?
 
     broadcasting = String(broadcasting)
 
     connection.anycable_socket.subscribe identifier, broadcasting
+    if whispering
+      connection.anycable_socket.whisper identifier, broadcasting
+    end
+  end
+
+  def stream_for(model, callback = nil, **opts, &block)
+    stream_from(broadcasting_for(model), callback || block, **opts)
   end
 
   def stop_stream_from(broadcasting)

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "action_cable"
+
+ActionCable::Connection::Base.include(Module.new do
+  # This method is assumed to be overriden in the connection class to enable public
+  # streams
+  def allow_public_streams?
+    false
+  end
+end)
+
+# Handle $pubsub channel in Subscriptions
+ActionCable::Connection::Subscriptions.prepend(Module.new do
+  # The contents are mostly copied from the original,
+  # there is no good way to configure channels mapping due to #safe_constantize
+  # and the layers of JSON
+  # https://github.com/rails/rails/blob/main/actioncable/lib/action_cable/connection/subscriptions.rb
+  def add(data)
+    id_key = data["identifier"]
+    id_options = ActiveSupport::JSON.decode(id_key).with_indifferent_access
+
+    return if subscriptions.key?(id_key)
+
+    return super unless id_options[:channel] == "$pubsub"
+
+    subscription = AnyCable::Rails::PubSubChannel.new(connection, id_key, id_options)
+    subscriptions[id_key] = subscription
+    subscription.subscribe_to_channel
+  end
+end)

data/lib/anycable/rails/channel_state.rb

@@ -10,11 +10,16 @@ module AnyCable
             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?
+                return unless anycabled?
+
+                raw_val = __istate__["#{name}"]
+                val = raw_val.present? ? AnyCable::Serializer.deserialize(JSON.parse(raw_val)) : nil
+
+                @#{name} = val.try(:with_indifferent_access) || val
               end
 
               def #{name}=(val)
-                __istate__["#{name}"] = AnyCable::Rails.serialize(val, json: true) if anycabled?
+                __istate__["#{name}"] = AnyCable::Serializer.serialize(val).to_json if anycabled?
                 instance_variable_set(:@#{name}, val)
               end
             RUBY
@@ -53,11 +58,14 @@ module AnyCable
             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?
+                return unless anycabled?
+
+                val = __cstate__["#{name}"]
+                @#{name} = val.present? ? AnyCable::Serializer.deserialize(JSON.parse(val)) : nil
               end
 
               def #{name}=(val)
-                __cstate__["#{name}"] = AnyCable::Rails.serialize(val, json: true) if anycabled?
+                __cstate__["#{name}"] = AnyCable::Serializer.serialize(val).to_json if anycabled?
                 instance_variable_set(:@#{name}, val)
               end
             RUBY

data/lib/anycable/rails/compatibility.rb

@@ -11,7 +11,7 @@ module AnyCable
     ]
 
     ActionCable::Channel::Base.prepend(Module.new do
-      def stream_from(broadcasting, callback = nil, coder: nil)
+      def stream_from(broadcasting, callback = nil, coder: nil, **)
         if coder.present? && coder != ActiveSupport::JSON
           raise AnyCable::CompatibilityError, "Custom coders are not supported by AnyCable"
         end

data/lib/anycable/rails/config.rb

@@ -9,15 +9,19 @@ require "anyway/rails"
 # - `access_logs_disabled` (defaults to true) — whether to print Started/Finished logs
 # - `persistent_session_enabled` (defaults to false) — whether to store session changes in the connection state
 # - `embedded` (defaults to false) — whether to run RPC server inside a Rails server process
-# - `http_rpc_mount_path` (default to nil) — path to mount HTTP RPC server
+# - `http_rpc_mount_path` (defaults to nil) — path to mount HTTP RPC server
 # - `batch_broadcasts` (defaults to false) — whether to batch broadcasts automatically for code wrapped with Rails executor
+# - `jwt_param` (defaults to 'jid') — the name of the JWT authentication query paramter or header
+# - `websocket_url` (defaults to nil) — the URL of AnyCable server WebSocket endpoint
 AnyCable::Config.attr_config(
   access_logs_disabled: true,
   persistent_session_enabled: false,
   embedded: false,
+  jwt_param: "jid",
   http_rpc_mount_path: nil,
   batch_broadcasts: false,
   socket_id_header: "X-Socket-ID",
-  disable_rpc_pool_size_warning: false
+  disable_rpc_pool_size_warning: false,
+  websocket_url: nil
 )
 AnyCable::Config.ignore_options :access_logs_disabled, :persistent_session_enabled

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

@@ -24,7 +24,7 @@ module AnyCable
             obj = instance_variable_get("@#{id}")
             next unless obj
 
-            acc[id] = AnyCable::Rails.serialize(obj)
+            acc[id] = AnyCable::Serializer.serialize(obj)
           end.compact
         end
 
@@ -37,7 +37,7 @@ module AnyCable
           return unless @cached_ids
 
           @cached_ids[name] ||= @cached_ids.fetch(name) do
-            AnyCable::Rails.deserialize(@serialized_ids[name.to_s])
+            AnyCable::Serializer.deserialize(@serialized_ids[name.to_s])
           end
         end
       end

data/lib/anycable/rails/ext/jwt.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module Rails
+    module Ext
+      # This module adds AnyCable JWT helpers to Action Cable
+      module JWT
+        # Handle expired tokens here to respond with a different disconnect reason
+        def handle_open
+          super
+        rescue AnyCable::JWT::ExpiredSignature
+          logger.error "An expired JWT token was rejected"
+          close(reason: "token_expired", reconnect: false) if websocket&.alive?
+        end
+
+        def anycable_jwt_present?
+          request.params[AnyCable.config.jwt_param].present? ||
+            request.headers["x-#{AnyCable.config.jwt_param}"].present?
+        end
+
+        def identify_from_anycable_jwt!
+          token = request.params[AnyCable.config.jwt_param].presence ||
+            request.headers["x-#{AnyCable.config.jwt_param}"].presence
+
+          identifiers = AnyCable::JWT.decode(token)
+          identifiers.each do |k, v|
+            public_send("#{k}=", v)
+          end
+        rescue AnyCable::JWT::VerificationError
+          reject_unauthorized_connection
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rails/ext.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module Rails
+    module Ext
+      autoload :JWT, "anycable/rails/ext/jwt"
+      autoload :SignedStreams, "anycable/rails/ext/signed_streams"
+    end
+  end
+end

data/lib/anycable/rails/helper.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module AnyCable
+  module Rails
+    module Helper
+      def action_cable_with_jwt_meta_tag(**identifiers)
+        # From: https://github.com/rails/rails/blob/main/actioncable/lib/action_cable/helpers/action_cable_helper.rb
+        base_url = ActionCable.server.config.url ||
+          ActionCable.server.config.mount_path ||
+          raise("No Action Cable URL configured -- please configure this at config.action_cable.url")
+
+        token = JWT.encode(identifiers)
+
+        parts = [base_url, "#{AnyCable.config.jwt_param}=#{token}"]
+
+        uri = URI.parse(base_url)
+
+        url = parts.join(uri.query ? "&" : "?")
+
+        tag "meta", name: "action-cable-url", content: url
+      end
+
+      def any_cable_jwt_meta_tag(**identifiers)
+        token = JWT.encode(identifiers)
+
+        tag "meta", name: "any-cable-jwt", content: token
+      end
+
+      def signed_stream_name(streamables)
+        Rails.signed_stream_name(streamables)
+      end
+    end
+  end
+end

data/lib/anycable/rails/object_serializer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module Rails
+    module ObjectSerializer
+      module_function
+
+      # Serialize via GlobalID if available
+      def serialize(obj)
+        obj.try(:to_gid_param)
+      end
+
+      # Deserialize from GlobalID
+      def deserialize(str)
+        GlobalID::Locator.locate(str)
+      end
+    end
+  end
+end

data/lib/anycable/rails/pubsub_channel.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module Rails
+    class PubSubChannel < ActionCable::Channel::Base
+      def subscribed
+        stream_name =
+          if params[:stream_name] && connection.allow_public_streams?
+            params[:stream_name]
+          elsif params[:signed_stream_name]
+            AnyCable::Streams.verified(params[:signed_stream_name])
+          end
+
+        if stream_name
+          stream_from stream_name
+        else
+          reject
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rails/railtie.rb

@@ -4,6 +4,7 @@ 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/action_cable_ext/broadcast_options"
+require "anycable/rails/action_cable_ext/signed_streams"
 
 require "anycable/rails/channel_state"
 require "anycable/rails/connection_factory"
@@ -17,6 +18,19 @@ module AnyCable
         app.config.action_cable.mount_path = nil
       end
 
+      initializer "anycable.websocket_url", after: "action_cable.set_configs" do |app|
+        next unless AnyCable::Rails.enabled?
+
+        websocket_url = AnyCable.config.websocket_url.presence
+        next unless websocket_url
+
+        app.config.action_cable.url = websocket_url
+
+        ActiveSupport.on_load(:action_cable) do
+          ::ActionCable.server.config.url = websocket_url
+        end
+      end
+
       initializer "anycable.logger", after: "action_cable.logger" do |_app|
         AnyCable.logger = ::ActionCable.server.config.logger
 
@@ -51,6 +65,11 @@ module AnyCable
         end
       end
 
+      initializer "anycable.object_serializer" do |_app|
+        require "anycable/rails/object_serializer"
+        AnyCable::Serializer.object_serializer = AnyCable::Rails::ObjectSerializer
+      end
+
       initializer "anycable.executor" do |app|
         require "anycable/rails/middlewares/executor"
         # see https://github.com/rails/rails/pull/33469/files
@@ -131,6 +150,12 @@ module AnyCable
         end
       end
 
+      initializer "anycable.helpers" do
+        ActiveSupport.on_load(:action_view) do
+          include AnyCable::Rails::Helper
+        end
+      end
+
       # Since Rails 6.1
       if respond_to?(:server)
         server do

data/lib/anycable/rails/version.rb

@@ -2,6 +2,6 @@
 
 module AnyCable
   module Rails
-    VERSION = "1.4.4"
+    VERSION = "1.5.0"
   end
 end

data/lib/anycable/rails.rb

@@ -8,9 +8,14 @@ require "anycable/rails/rack"
 require "globalid"
 require "active_support/core_ext/module/attribute_accessors_per_thread"
 
+require "anycable/rails/ext"
+
 module AnyCable
   # Rails handler for AnyCable
   module Rails
+    autoload :Helper, "anycable/rails/helper"
+    autoload :PubSubChannel, "anycable/rails/pubsub_channel"
+
     require "anycable/rails/railtie"
 
     ADAPTER_ALIASES = %w[any_cable anycable].freeze
@@ -51,28 +56,15 @@ module AnyCable
         end
       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)
+      def signed_stream_name(streamables)
+        Streams.signed(stream_name_from(streamables))
       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
+      def stream_name_from(streamables)
+        if streamables.is_a?(Array)
+          streamables.map { |streamable| stream_name_from(streamable) }.join(":")
+        else
+          streamables.then { |streamable| streamable.try(:to_gid_param) || streamable.to_param }
         end
       end
 

data/lib/generators/anycable/bin/USAGE

@@ -0,0 +1,10 @@
+Description:
+    Generate bin/anycable-go to automatially install and run AnyCable server locally
+
+Example:
+    rails generate anycable:bin
+
+    This will create:
+        `bin/anycable-go`.
+
+    rails generate anycable:bin --version=1.4.0

data/lib/generators/anycable/bin/bin_generator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "generators/anycable/with_os_helpers"
+
+module AnyCableRailsGenerators
+  # Generates bin/anycable-go binstub
+  class BinGenerator < ::Rails::Generators::Base
+    namespace "anycable:bin"
+
+    source_root File.expand_path("templates", __dir__)
+
+    class_option :version,
+      type: :string,
+      desc: "Specify AnyCable server version (defaults to latest release)",
+      version: "latest"
+
+    def generate_bin
+      inside("bin") do
+        template "anycable-go"
+        chmod "anycable-go", 0755, verbose: false # rubocop:disable Style/NumericLiteralPrefix
+      end
+
+      in_root do
+        next unless File.file?(".gitignore")
+
+        ignores = File.read(".gitignore").lines
+
+        if ignores.none? { |line| line.match?(/^bin\/dist$/) }
+          append_file ".gitignore", "bin/dist\n"
+        end
+      end
+
+      true
+    end
+
+    private
+
+    def anycable_go_version
+      @anycable_go_version ||= normalize_version(options[:version]) || "latest"
+    end
+
+    def normalize_version(version)
+      return unless version
+      return if version.chomp == "latest"
+
+      # We need a full version for bin/anycable-go script
+      segments = Gem::Version.new(version).segments
+      segments << 0 until segments.size >= 3
+      segments.join(".")
+    end
+  end
+end

data/lib/generators/anycable/bin/templates/bin/anycable-go.tt

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+cd $(dirname $0)/..
+
+# It's recommended to use the exact version of AnyCable here
+version="<%= anycable_go_version %>"
+
+if [ ! -f ./bin/dist/anycable-go ]; then
+  echo "AnyCable server is not installed, downloading..."
+  ./bin/rails g anycable:download --version=$version --bin-path=./bin/dist
+fi
+
+curVersion=$(./bin/dist/anycable-go -v)
+
+if [[ "$version" != "latest" ]]; then
+  if [[ "$curVersion" != "$version"* ]]; then
+    echo "AnyCable server version is not $version, downloading a new one..."
+    ./bin/rails g anycable:download --version=$version --bin-path=./bin/dist
+  fi
+fi
+
+./bin/dist/anycable-go $@

data/lib/generators/anycable/download/USAGE

@@ -1,5 +1,5 @@
 Description:
-    Install AnyCable-Go web server locally (the latest version by default).
+    Install AnyCable real-time server locally (the latest version by default).
 
 Example:
     rails generate anycable:download
@@ -11,4 +11,4 @@ Example:
 
     rails generate anycable:download --bin-path=/usr/local/bin
 
-    rails generate anycable:download --version=1.0.0
+    rails generate anycable:download --version=1.4.0

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

@@ -13,10 +13,10 @@ module AnyCableRailsGenerators
 
     class_option :bin_path,
       type: :string,
-      desc: "Where to download AnyCable-Go server binary (default: #{DEFAULT_BIN_PATH})"
+      desc: "Where to download AnyCable server binary (default: #{DEFAULT_BIN_PATH})"
     class_option :version,
       type: :string,
-      desc: "Specify the AnyCable-Go version (defaults to latest release)"
+      desc: "Specify the AnyCable version (defaults to latest release)"
 
     def download_bin
       out = options[:bin_path] || DEFAULT_BIN_PATH
@@ -74,7 +74,7 @@ module AnyCableRailsGenerators
         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
+          say_status :error, "❌ Failed to install AnyCable real-time server", :red
           raise StandardError, "Path #{path} is not writable!"
         end
       end

data/lib/generators/anycable/setup/USAGE

@@ -3,9 +3,3 @@ Description:
 
 Example:
     rails generate anycable:setup
-
-    # You can opt-in to use HTTP RPC
-    rails generate anycable:setup --rpc=http
-
-    # You can specify which version of anycable-go to use
-    rails generate anycable:setup --version=1.4

data/lib/generators/anycable/setup/setup_generator.rb

@@ -10,105 +10,63 @@ module AnyCableRailsGenerators
 
     DOCS_ROOT = "https://docs.anycable.io"
     DEVELOPMENT_METHODS = %w[skip local docker].freeze
-    RPC_IMPL = %w[grpc http].freeze
+    DEPLOYMENT_METHODS = %w[other fly heroku anycable_plus].freeze
+    RPC_IMPL = %w[none grpc http].freeze
 
     class_option :devenv,
       type: :string,
-      desc: "Select your development environment (options: #{DEVELOPMENT_METHODS.join(", ")})"
+      desc: "Select your development environment (options: #{DEVELOPMENT_METHODS.reverse.join(", ")})"
     class_option :rpc,
       type: :string,
-      desc: "Select RPC implementation (options: #{RPC_IMPL.join(", ")})",
-      default: "grpc"
-    class_option :skip_heroku,
+      desc: "Select RPC implementation (options: #{RPC_IMPL.reverse.join(", ")})"
+    class_option :skip_procfile,
       type: :boolean,
-      desc: "Do not copy Heroku configs"
-    class_option :skip_procfile_dev,
-      type: :boolean,
-      desc: "Do not create Procfile.dev"
-    class_option :skip_jwt,
-      type: :boolean,
-      desc: "Do not install anycable-rails-jwt"
-    class_option :skip_install,
-      type: :boolean,
-      desc: "Do not run bundle install when adding new gems"
+      desc: "Do not create/update Procfile.dev"
     class_option :version,
       type: :string,
-      desc: "Specify the AnyCable-Go version (defaults to latest release)"
+      desc: "Specify AnyCable server version (defaults to latest release)",
+      default: "latest"
 
     def welcome
-      say "👋 Welcome to AnyCable interactive installer."
+      say ""
+      say "👋 Welcome to AnyCable interactive installer. We'll guide you through the process of installing AnyCable for your Rails application. Buckle up!"
+      say ""
     end
 
-    def configs
-      inside("config") do
-        template "cable.yml"
-        template "anycable.yml"
-      end
-    end
+    def rpc_implementation
+      say "AnyCable connects to your Rails server to communicate with Action Cable channels (via RPC API). Learn more from the docs 👉 #{DOCS_ROOT}/anycable-go/rpc"
+      say ""
 
-    def cable_url
-      environment(nil, env: :development) do
-        <<~SNIPPET
-          # Specify AnyCable WebSocket server URL to use by JS client
-          config.after_initialize do
-            config.action_cable.url = ActionCable.server.config.url = ENV.fetch("CABLE_URL", "ws://localhost:8080/cable") if AnyCable::Rails.enabled?
-          end
-        SNIPPET
-      end
+      answer = RPC_IMPL.index(options[:rpc]) || 99
 
-      environment(nil, env: :production) do
-        <<~SNIPPET
-          # Specify AnyCable WebSocket server URL to use by JS client
-          config.after_initialize do
-            config.action_cable.url = ActionCable.server.config.url = ENV.fetch("CABLE_URL", "/cable") if AnyCable::Rails.enabled?
-          end
-        SNIPPET
+      until RPC_IMPL[answer.to_i]
+        answer = ask "Do you want to use gRPC or HTTP for AnyCable RPC? (1) gRPC, (2) HTTP, (0) None"
       end
 
-      say_status :info, "✅ 'config.action_cable.url' has been configured"
-      say_status :help, "⚠️  If you're using JS client make sure you have " \
-                        "`action_cable_meta_tag` included before any <script> tag in your application.html"
+      @rpc_impl = RPC_IMPL[answer.to_i]
     end
 
     def development_method
       answer = DEVELOPMENT_METHODS.index(options[:devenv]) || 99
 
+      say ""
+
       until DEVELOPMENT_METHODS[answer.to_i]
-        answer = ask "Do you want to run anycable-go locally or as a Docker container? (1) Local, (2) Docker, (0) Skip"
+        answer = ask "Do you want to run AnyCable server (anycable-go) locally or as a Docker container? (1) Local, (2) Docker, (0) Skip"
       end
 
-      case env = DEVELOPMENT_METHODS[answer.to_i]
+      @devenv = DEVELOPMENT_METHODS[answer.to_i]
+
+      case @devenv
       when "skip"
-        say_status :help, "⚠️  Please, read this guide on how to install AnyCable-Go server 👉 #{DOCS_ROOT}/anycable-go/getting_started", :yellow
+        say_status :help, "⚠️  Please, read this guide on how to install AnyCable server 👉 #{DOCS_ROOT}/anycable-go/getting_started", :yellow
       else
-        send "install_for_#{env}"
+        send "install_for_#{@devenv}"
       end
     end
 
-    def heroku
-      if options[:skip_heroku].nil?
-        return unless yes? "Do you use Heroku for deployment? [Yn]"
-      elsif options[:skip_heroku]
-        return
-      end
-
-      in_root do
-        next unless File.file?("Procfile")
-        next if http_rpc?
-
-        contents = File.read("Procfile")
-        contents.sub!(/^web: (.*)$/, %q(web: [[ "$ANYCABLE_DEPLOYMENT" == "true" ]] && bundle exec anycable --server-command="anycable-go" || \1))
-        File.write("Procfile", contents)
-        say_status :info, "✅ Procfile updated"
-      end
-
-      say_status :help, "️️⚠️  Please, read the required steps to configure Heroku applications 👉 #{DOCS_ROOT}/deployment/heroku", :yellow
-    end
-
     def devise
-      in_root do
-        return unless File.file?("config/initializers/devise.rb")
-      end
+      return unless devise?
 
       inside("config/initializers") do
         template "anycable.rb"
@@ -117,10 +75,12 @@ module AnyCableRailsGenerators
       say_status :info, "✅ config/initializers/anycable.rb with Devise configuration has been added"
     end
 
-    def stimulus_reflex
-      return unless stimulus_reflex?
+    def configs
+      inside("config") do
+        template "anycable.yml"
+      end
 
-      say_status :help, "⚠️  Please, check out the documentation on using AnyCable with Stimulus Reflex: #{DOCS_ROOT}/rails/stimulus_reflex"
+      update_cable_yml
     end
 
     def rubocop_compatibility
@@ -131,14 +91,15 @@ module AnyCableRailsGenerators
       say_status :help, "⚠️  Please, take a look at the icompatibilities above and fix them. See #{DOCS_ROOT}/rails/compatibility" unless res
     end
 
-    def jwt
-      return if options[:skip_jwt]
-
-      return unless options[:skip_jwt] == false || yes?("Do you want to use JWT for authentication? [Yn]")
+    def cable_url_info
+      say_status :help, "⚠️  If you're using JS client make sure you have " \
+                        "`action_cable_meta_tag` or `action_cable_with_jwt_meta_tag` included in your HTML layout"
+    end
 
-      opts = " --skip-install" if options[:skip_install]
+    def deployment_method
+      say_status :info, "🚢  See our deployment guide to learn how to run AnyCable in production 👉 #{DOCS_ROOT}/deployment"
 
-      run "bundle add anycable-rails-jwt#{opts}"
+      say_status :info, "Check out AnyCable+, our hosted AnyCable solution: https://plus.anycable.io"
     end
 
     def finish
@@ -147,10 +108,6 @@ module AnyCableRailsGenerators
 
     private
 
-    def stimulus_reflex?
-      !!gemfile_lock&.match?(/^\s+stimulus_reflex\b/)
-    end
-
     def redis?
       !!gemfile_lock&.match?(/^\s+redis\b/)
     end
@@ -167,8 +124,20 @@ module AnyCableRailsGenerators
       !!gemfile_lock&.match?(/^\s+rubocop\b/)
     end
 
+    def devise?
+      !!gemfile_lock&.match?(/^\s+devise\b/)
+    end
+
+    def local?
+      @devenv == "local"
+    end
+
+    def grpc?
+      @rpc_impl == "grpc"
+    end
+
     def http_rpc?
-      options[:rpc] == "http"
+      @rpc_impl == "http"
     end
 
     def gemfile_lock
@@ -183,83 +152,143 @@ module AnyCableRailsGenerators
     end
 
     def install_for_docker
-      # Remove localhost from configuraiton
-      gsub_file "config/anycable.yml", /^.*redis_url:.*localhost[^\n]+\n/, ""
-
       say_status :help, "️️⚠️  Docker development configuration could vary", :yellow
 
-      say "Here is an example snippet for docker-compose.yml:"
-      say <<~YML
-        ─────────────────────────────────────────
-        ws:
-          image: anycable/anycable-go:1.4
-          ports:
-            - '8080:8080'
-          environment:
-            ANYCABLE_HOST: "0.0.0.0"
-            ANYCABLE_REDIS_URL: redis://redis:6379/0
-            ANYCABLE_RPC_HOST: anycable:50051
-            ANYCABLE_DEBUG: 1
-          depends_on:
-            redis:
-              condition: service_healthy
-
-        anycable:
-          <<: *backend
-          command: bundle exec anycable
-          environment:
-            <<: *backend_environment
-            ANYCABLE_REDIS_URL: redis://redis:6379/0
-            ANYCABLE_RPC_HOST: 0.0.0.0:50051
-            ANYCABLE_DEBUG: 1
-          ports:
-            - '50051'
-          depends_on:
-            <<: *backend_depends_on
-            ws:
-              condition: service_started
-        ─────────────────────────────────────────
-      YML
+      say "Here is an example snippet for Docker Compose:"
+
+      if @rpc_impl == "grpc"
+        say <<~YML
+          ─────────────────────────────────────────
+          # your Rails application service
+          rails: &rails
+            # ...
+            ports:
+              - '3000:3000'
+            environment: &rails_environment
+              # ...
+              ANYCABLE_HTTP_BROADCAST_URL: http://ws:8090/_broadcast
+            depends_on: &rails_depends_on
+              #...
+              anycable:
+                condition: service_started
+
+          ws:
+            image: anycable/anycable-go:1.5
+            ports:
+              - '8080:8080'
+              - '8090'
+            environment:
+              ANYCABLE_HOST: "0.0.0.0"
+              ANYCABLE_BROADCAST_ADAPTER: http
+              ANYCABLE_RPC_HOST: anycable:50051
+              ANYCABLE_DEBUG: ${ANYCABLE_DEBUG:-true}
+
+          anycable:
+            <<: *rails
+            command: bundle exec anycable
+            environment:
+              <<: *rails_environment
+              ANYCABLE_RPC_HOST: 0.0.0.0:50051
+            ports:
+              - '50051'
+            depends_on:
+              <<: *rails_depends_on
+              ws:
+                condition: service_started
+          ─────────────────────────────────────────
+        YML
+      else
+        say <<~YML
+          ─────────────────────────────────────────
+          # Your Rails application service
+          rails: &rails
+            # ...
+            ports:
+              - '3000:3000'
+            environment: &rails_environment
+              # ...
+              ANYCABLE_HTTP_BROADCAST_URL: http://ws:8090/_broadcast
+            depends_on: &rails_depends_on
+              #...
+              anycable:
+                condition: service_started
+
+          ws:
+            image: anycable/anycable-go:1.5
+            ports:
+              - '8080:8080'
+            environment:
+              ANYCABLE_HOST: "0.0.0.0"
+              ANYCABLE_BROADCAST_ADAPTER: http
+              ANYCABLE_RPC_HOST: http://rails:3000/_anycable
+              ANYCABLE_DEBUG: ${ANYCABLE_DEBUG:-true}
+          ─────────────────────────────────────────
+        YML
+      end
     end
 
     def install_for_local
-      inside("bin") do
-        template "anycable-go"
-        chmod "anycable-go", 0755, verbose: false # rubocop:disable Style/NumericLiteralPrefix
+      unless file_exists?("bin/anycable-go")
+        generate "anycable:bin", "--version #{options[:version]}"
       end
+      template_proc_files
+      true
+    end
 
-      if file_exists?(".gitignore")
-        append_file ".gitignore", "bin/dist\n"
-      end
+    def update_cable_yml
+      if file_exists?("config/cable.yml")
+        in_root do
+          contents = File.read("config/cable.yml")
+          # Replace any adapter: x with any_cable unless x == "test"
+          new_contents = contents.gsub(/\sadapter:\s*([^$\n]+)/) do |match|
+            adapter = Regexp.last_match[1]
+            next match if adapter == "test" || adapter.include?("any_cable")
 
-      template_proc_files
+            match.sub(adapter, %(<%= ENV.fetch("ACTION_CABLE_ADAPTER", "any_cable") %>))
+          end
+
+          File.write "config/cable.yml", new_contents
+        end
+      else
+        inside("config") do
+          template "cable.yml"
+        end
+      end
     end
 
     def template_proc_files
       file_name = "Procfile.dev"
 
       if file_exists?(file_name)
-        unless http_rpc?
-          append_file file_name, "anycable: bundle exec anycable\n", force: true
-        end
-        append_file file_name, "ws: bin/anycable-go #{anycable_go_options}", force: true
+        update_procfile(file_name)
       else
-        say_status :help, "💡 We recommend using Hivemind to manage multiple processes in development 👉 https://github.com/DarthSim/hivemind", :yellow
+        say_status :help, "💡 We recommend using Overmind to manage multiple processes in development 👉 https://github.com/DarthSim/overmind", :yellow
 
-        if options[:skip_procfile_dev].nil?
-          return unless yes? "Do you want to create a '#{file_name}' file?"
-        elsif options[:skip_procfile_dev]
-          return
-        end
+        return if options[:skip_procfile_dev]
 
         template file_name
       end
     end
 
+    def update_procfile(file_name)
+      in_root do
+        contents = File.read(file_name)
+
+        unless http_rpc?
+          unless contents.match?(/^anycable:\s/)
+            append_file file_name, "anycable: bundle exec anycable\n", force: true
+          end
+        end
+        unless contents.match?(/^ws:\s/)
+          append_file file_name, "ws: bin/anycable-go #{anycable_go_options}", force: true
+        end
+      end
+    end
+
     def anycable_go_options
       opts = ["--port=8080"]
       opts << "--broadcast_adapter=http" unless redis?
-      opts << "--rpc_impl=http --rpc_host=http://localhost:3000/_anycable" if http_rpc?
+      opts << "--rpc_host=http://localhost:3000/_anycable" if http_rpc?
       opts.join(" ")
     end
 
@@ -268,18 +297,5 @@ module AnyCableRailsGenerators
         return File.file?(name)
       end
     end
-
-    def anycable_go_version
-      @anycable_go_version ||= normalize_version(options[:version]) || "latest"
-    end
-
-    def normalize_version(version)
-      return unless version
-
-      # We need a full version for bin/anycable-go script
-      segments = Gem::Version.new(version).segments
-      segments << 0 until segments.size >= 3
-      segments.join(".")
-    end
   end
 end

data/lib/generators/anycable/setup/templates/bin/anycable-go.tt

@@ -2,11 +2,11 @@
 
 cd $(dirname $0)/..
 
-# It's recommended to use the exact version of AnyCable-Go here
+# It's recommended to use the exact version of AnyCable here
 version="<%= anycable_go_version %>"
 
 if [ ! -f ./bin/dist/anycable-go ]; then
-  echo "AnyCable-go is not installed, downloading..."
+  echo "AnyCable server is not installed, downloading..."
   ./bin/rails g anycable:download --version=$version --bin-path=./bin/dist
 fi
 
@@ -14,7 +14,7 @@ curVersion=$(./bin/dist/anycable-go -v)
 
 if [[ "$version" != "latest" ]]; then
   if [[ "$curVersion" != "$version"* ]]; then
-    echo "AnyCable-go version is not $version, downloading a new one..."
+    echo "AnyCable server version is not $version, downloading a new one..."
     ./bin/rails g anycable:download --version=$version --bin-path=./bin/dist
   fi
 fi

data/lib/generators/anycable/setup/templates/config/anycable.yml.tt

@@ -21,26 +21,33 @@ default: &default
   # Use NATS to broadcast messages to AnyCable server
   broadcast_adapter: nats
   <%- else -%>
-  # Use HTTP adapter for a quick start (since redis gem is not present in the project)
+  # Use HTTP broadcaster
   broadcast_adapter: http
   <%- end -%>
-  # Use the same channel name for WebSocket server, e.g.:
-  #   $ anycable-go --redis_channel="__anycable__"
-  redis_channel: "__anycable__"
   <%- if redis? -%>
   # You can use REDIS_URL env var to configure Redis URL.
   # Localhost is used by default.
   # redis_url: "redis://localhost:6379/1"
+  # Use the same channel name for WebSocket server, e.g.:
+  #   $ anycable-go --redis_channel="__anycable__"
+  # redis_channel: "__anycable__"
   <%- end -%>
   <%- if http_rpc? -%>
+  # Use HTTP RPC mounted at the specified path of your web server
+  # Read more about AnyCable RPC:  <%= DOCS_ROOT %>/anycable-go/rpc
   http_rpc_mount_path: "/_anycable"
   <%- end -%>
 
 development:
   <<: *default
+  # WebSocket endpoint of your AnyCable server for clients to connect to
+  # Make sure you have the `action_cable_meta_tag` in your HTML layout
+  # to propogate this value to the client app
+  websocket_url: "ws://localhost:8080/cable"
 
 test:
   <<: *default
 
 production:
   <<: *default
+  websocket_url: ~

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: anycable-rails-core
 version: !ruby/object:Gem::Version
-  version: 1.4.4
+  version: 1.5.0
 platform: ruby
 authors:
 - palkan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-08 00:00:00.000000000 Z
+date: 2024-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: anycable-core
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: 1.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: 1.5.0
 - !ruby/object:Gem::Dependency
   name: actioncable
   requirement: !ruby/object:Gem::Requirement
@@ -70,6 +70,7 @@ files:
 - lib/anycable/rails/action_cable_ext/channel.rb
 - lib/anycable/rails/action_cable_ext/connection.rb
 - lib/anycable/rails/action_cable_ext/remote_connections.rb
+- lib/anycable/rails/action_cable_ext/signed_streams.rb
 - lib/anycable/rails/channel_state.rb
 - lib/anycable/rails/compatibility.rb
 - lib/anycable/rails/compatibility/rubocop.rb
@@ -83,12 +84,20 @@ files:
 - lib/anycable/rails/connections/persistent_session.rb
 - lib/anycable/rails/connections/serializable_identification.rb
 - lib/anycable/rails/connections/session_proxy.rb
+- lib/anycable/rails/ext.rb
+- lib/anycable/rails/ext/jwt.rb
+- lib/anycable/rails/helper.rb
 - lib/anycable/rails/middlewares/executor.rb
 - lib/anycable/rails/middlewares/log_tagging.rb
+- lib/anycable/rails/object_serializer.rb
+- lib/anycable/rails/pubsub_channel.rb
 - lib/anycable/rails/rack.rb
 - lib/anycable/rails/railtie.rb
 - lib/anycable/rails/socket_id_tracking.rb
 - lib/anycable/rails/version.rb
+- lib/generators/anycable/bin/USAGE
+- lib/generators/anycable/bin/bin_generator.rb
+- lib/generators/anycable/bin/templates/bin/anycable-go.tt
 - lib/generators/anycable/download/USAGE
 - lib/generators/anycable/download/download_generator.rb
 - lib/generators/anycable/setup/USAGE