solid_cable 2.0.2 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7179cc12b0e26e67a4cf8c7a3422143d6405d33806972e77e546f2643c47d4a
-  data.tar.gz: bb2bf9cbeca60b7eebca95c3dc13951e7769b616b18663c65bdf4dd915e23ca0
+  metadata.gz: 1aef7361e9ee2d03dbcd1d8bc89009cd4f3af500b1834e7fab52663850fde410
+  data.tar.gz: 63185c05065aa3ad657189fa7c2bbd8bf2a049eee2596e4e5d441c7c881ad258
 SHA512:
-  metadata.gz: ed13873bf8f5783d34946df8437687f2642fea10e74edd82cac2c266108311dcf52d709556a6916fe17c26428306bac931d031de6cacdb3f8dd470477339de56
-  data.tar.gz: d1ffc9ad2042e5910298ac4afe3562bda426423938a2aa62472ee46694b5dbe48a340a55c7b2649b4f024c1f75f113fb9b551366f6a7768c692e58af10e114a9
+  metadata.gz: 7b8da2e04fd45d8dea8098ad3d453d06d3df53881369480157f03fff63f1d1fa615fdfcc6a162aa2b85976c3767afc25ecae725663b375edc89568470176bda3
+  data.tar.gz: ba1fb17d9ac2c916e815db54d4495f6cd0f53f72d63f276932fcb935958b3e7853e7bd2685c5e677b5972f98a306910b2598405bf7ead4dfabb25aa2ba74b59e

data/README.md

@@ -2,6 +2,13 @@
 
 Solid Cable is a database-backed Action Cable adapter that keeps messages in a table and continously polls for updates. This makes it possible to drop the common dependency on Redis, if it isn't needed for any other purpose. Despite polling, the performance of Solid Cable is comparable to Redis in most situations. And in all circumstances, it makes it easier to deploy Rails when Redis is no longer a required dependency for Action Cable functionality.
 
+> [!NOTE]
+> Solid Cable is tested to work with MySQL, SQLite, and PostgreSQL.
+>
+> Action Cable already has a [dedicated PostgreSQL adapter](https://guides.rubyonrails.org/action_cable_overview.html#postgresql-adapter),
+> which utilizes the builtin `NOTIFY` command for better performance. However, that
+> adapter has an 8kb limit on its payload. Solid Cable is a great alternative if you find yourself
+> broadcasting large payloads, or prefer not to use the `NOTIFY` command.
 
 ## Installation
 
@@ -45,6 +52,16 @@ production:
 
 Then run `db:prepare` in production to ensure the database is created and the schema is loaded.
 
+### Single database configuration
+
+Running Solid Cable in a separate database is recommended, but it's also possible to use a single database for both the app and Action Cable.
+
+1. Copy the contents of `db/cable_schema.rb` into a normal migration and delete `db/cable_schema.rb`
+2. Remove `connects_to` from `config/cable.yml`
+3. `bin/rails db:migrate`
+
+You won't have multiple databases, so `database.yml` doesn't need to have primary and cable database.
+
 ## Configuration
 
 All configuration is managed via the `config/cable.yml` file. By default, it'll be configured like this:
@@ -67,14 +84,176 @@ The options are:
 - `message_retention` - sets the retention time for messages kept in the database. Used as the cut-off when trimming is performed. (Defaults to 1.day)
 - `autotrim` - sets wether you want Solid Cable to handle autotrimming messages. (Defaults to true)
 - `silence_polling` - whether to silence Active Record logs emitted when polling (Defaults to true)
+- `use_skip_locked` - whether to use `FOR UPDATE SKIP LOCKED` when performing trimming. This will be automatically detected in the future, and for now, you'd only need to set this to `false` if your database doesn't support it. For MySQL, that'd be versions < 8, and for PostgreSQL, versions < 9.5. If you use SQLite, this has no effect, as writes are sequential. (Defaults to true)
+- `trim_batch_size` - the batch size to use when deleting old records (default: `100`)
+
 
 ## Trimming
 
-Messages are autotrimmed based upon the `message_retention` setting to determine how long messages are to be kept around. If no `message_retention` is given or parsing fails, it defaults to `1.day`. Messages are trimmed when a subscriber unsubscribes.
+Messages are autotrimmed based upon the `message_retention` setting to determine how long messages are to be kept around. If no `message_retention` is given or parsing fails, it defaults to `1.day`. Messages are trimmed when a messsage is broadcast.
 
-Autotrimming can negatively impact performance depending on your workload because it is doing a delete on ubsubscribe. If
+Autotrimming can negatively impact performance slightly depending on your workload because it is potentially doing a delete on broadcast. If
 you would prefer, you can disable autotrimming by setting `autotrim: false` and you can manually enqueue the job later, `SolidCable::TrimJob.perform_later`, or run it on a recurring interval out of band.
 
+
+## Upgrading
+
+If you have already installed Solid Cable < 3 and are upgrading to version 3,
+run `solid_cable:update` to install a new migration.
+
+
+## Benchmarks
+
+Inside the `bench` directory there is a minimal Rails app that is used to benchmark.
+You are welcome to update the config/deploy.yml file to point to your own server
+if you want to deploy the app to your own server and run benchmarks.
+
+To benchmark we use [k6](https://k6.io). Most of the setup was gotten from this
+[article](https://evilmartians.com/chronicles/real-time-stress-anycable-k6-websockets-and-yabeda).
+1. Install k6
+1. Install xk6-cable by running `xk6 build --with
+   github.com/anycable/xk6-cable`. This will output a custom k6 binary.
+1. Run the load test with `./k6 run loadtest.js`
+    - This script takes a variety of ENV variables:
+        - WS_URL: The url to send websocket connections
+        - MAX: The number of virtual users to hit the server with
+        - TIME: The duration of the load test
+        - MESSAGES_NUM: The number of messages each VU will send to the server
+
+
+#### Results
+
+Our loadtest is run on a Hetzner CCX13, with a MESSAGES_NUM of 5, and a TIME of 90.
+
+##### SQLite
+
+With a polling interval of 0.1 seconds and autotrimming enabled.
+
+100 VUs
+```
+rtt..................: avg=135.82ms min=50ms     med=138ms    max=357ms    p(90)=174ms    p(95)=195ms
+ws_connecting........: avg=205.81ms min=149.35ms med=199.01ms max=509.48ms p(90)=254.04ms p(95)=261.77ms
+```
+250 VUs
+```
+rtt..................: avg=146.24ms min=50ms     med=144ms    max=435ms p(90)=209ms   p(95)=234.04ms
+ws_connecting........: avg=222.15ms min=146.47ms med=208.57ms max=1.3s  p(90)=263.6ms p(95)=284.18ms
+```
+500 VUs
+```
+rtt..................: avg=271.79ms min=48ms     med=205ms    max=1.15s p(90)=558ms    p(95)=660ms
+ws_connecting........: avg=248.81ms min=145.89ms med=221.89ms max=1.38s p(90)=290.41ms p(95)=322.2ms
+```
+750 VUs
+```
+rtt..................: avg=548.27ms min=51ms     med=438ms    max=5.19s  p(90)=1.18s  p(95)=1.29s
+ws_connecting........: avg=266.37ms min=144.06ms med=224.93ms max=2.33s  p(90)=298ms  p(95)=342.87ms
+```
+
+With trimming disabled
+
+250 VUs
+```
+rtt..................: avg=139.47ms min=48ms     med=142ms    max=807ms p(90)=189ms    p(95)=214ms
+ws_connecting........: avg=212.58ms min=146.19ms med=196.25ms max=1.25s p(90)=255.74ms p(95)=272.44ms
+```
+
+With a polling interval of 0.01 seconds it becomes comparable to Redis
+
+250 VUs
+```
+rtt..................: avg=84.22ms  min=43ms     med=69ms     max=416ms p(90)=137ms    p(95)=150ms
+ws_connecting........: avg=219.37ms min=144.71ms med=200.77ms max=2.17s p(90)=265.23ms p(95)=290.83ms
+```
+
+##### Redis
+
+This instance was hosted on the same machine.
+
+100 VUs
+```
+rtt..................: avg=68.95ms  min=41ms     med=56ms     max=6.23s  p(90)=114ms   p(95)=129ms
+ws_connecting........: avg=211.09ms min=153.23ms med=195.69ms max=1.44s  p(90)=258.1ms p(95)=272.23ms
+```
+250 VUs
+```
+rtt..................: avg=69.32ms  min=40ms     med=56ms     max=645ms p(90)=119ms    p(95)=135ms
+ws_connecting........: avg=212.95ms min=142.92ms med=196.31ms max=1.25s p(90)=260.25ms p(95)=273.49ms
+```
+500 VUs
+```
+rtt..................: avg=87.5ms   min=40ms     med=67ms     max=839ms p(90)=149ms    p(95)=176ms
+ws_connecting........: avg=242.62ms min=142.03ms med=213.76ms max=2.34s p(90)=291.25ms p(95)=324.04ms
+```
+750 VUs
+```
+rtt..................: avg=162.54ms min=39ms  med=123ms    max=2.26s p(90)=343.1ms  p(95)=438ms
+ws_connecting........: avg=353.08ms min=143ms med=264.15ms max=2.73s p(90)=541.36ms p(95)=1.15s
+```
+
+
+##### MySQL
+
+With a polling interval of 0.1 seconds and autotrimming enabled. This instance
+was also hosted on the same machine.
+
+100 VUs
+```
+rtt..................: avg=136.02ms min=51ms     med=137ms    max=877ms p(90)=168.1ms  p(95)=198ms
+ws_connecting........: avg=207.76ms min=151.93ms med=196.74ms max=1.21s p(90)=249.91ms p(95)=260.37ms
+```
+250 VUs
+```
+rtt..................: avg=159.33ms min=51ms    med=149ms    max=559ms p(90)=236ms    p(95)=263ms
+ws_connecting........: avg=232.38ms min=151.6ms med=218.09ms max=1.38s p(90)=287.99ms p(95)=324.6ms
+```
+500 VUs
+```
+rtt..................: avg=441.07ms min=51ms     med=312ms    max=2.29s  p(90)=931ms    p(95)=1.07s
+ws_connecting........: avg=256.73ms min=152.23ms med=231.02ms max=2.31s  p(90)=305.69ms p(95)=340.83ms
+```
+750 VUs
+```
+rtt..................: avg=822.08ms min=51ms     med=732ms    max=5.05s  p(90)=1.76s    p(95)=1.97s
+ws_connecting........: avg=278.08ms min=146.66ms med=236.35ms max=2.37s  p(90)=318.17ms p(95)=374.98ms
+```
+
+
+##### PostgreSQL with Solid Cable
+
+With a polling interval of 0.1 seconds and autotrimming enabled. This instance
+was also hosted on the same machine.
+
+100 VUs
+```
+rtt..................: avg=137.45ms min=48ms     med=139ms    max=439ms    p(90)=179.1ms  p(95)=204ms
+ws_connecting........: avg=207.13ms min=150.29ms med=197.76ms max=443.67ms p(90)=254.44ms p(95)=263.29ms
+```
+250 VUs
+```
+rtt..................: avg=151.63ms min=49ms     med=146ms    max=538ms p(90)=222ms    p(95)=248.04ms
+ws_connecting........: avg=245.89ms min=147.18ms med=205.57ms max=30s   p(90)=265.08ms p(95)=281.15ms
+```
+500 VUs
+```
+rtt..................: avg=362.79ms min=50ms     med=249ms    max=1.21s p(90)=757ms    p(95)=844ms
+ws_connecting........: avg=257.02ms min=146.13ms med=227.65ms max=2.39s p(90)=303.22ms p(95)=344.39ms
+```
+
+
+##### PostgreSQL with dedicated adapter
+
+100 VUs
+```
+rtt..................: avg=69.76ms  min=41ms     med=57ms     max=622ms p(90)=116ms    p(95)=133ms
+ws_connecting........: avg=210.97ms min=149.68ms med=196.06ms max=1.27s p(90)=259.67ms p(95)=273.17ms
+```
+250 VUs
+```
+rtt..................: avg=73.43ms  min=40ms     med=58ms     max=698ms p(90)=126ms    p(95)=141ms
+ws_connecting........: avg=210.83ms min=143.01ms med=195.22ms max=1.27s p(90)=259.27ms p(95)=272.6ms
+```
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/app/jobs/solid_cable/trim_job.rb

@@ -3,7 +3,24 @@
 module SolidCable
   class TrimJob < ActiveJob::Base
     def perform
-      ::SolidCable::Message.trimmable.delete_all
+      return unless trim?
+
+      ::SolidCable::Message.transaction do
+        ids = ::SolidCable::Message.trimmable.non_blocking_lock.
+              limit(trim_batch_size).pluck(:id)
+        ::SolidCable::Message.where(id: ids).delete_all
+      end
     end
+
+    private
+      def trim_batch_size
+        ::SolidCable.trim_batch_size
+      end
+
+      def trim?
+        expires_per_write = (1 / trim_batch_size.to_f) * ::SolidCable.trim_chance
+
+        rand < (expires_per_write - expires_per_write.floor)
+      end
   end
 end

data/app/models/solid_cable/message.rb

@@ -3,10 +3,28 @@
 module SolidCable
   class Message < SolidCable::Record
     scope :trimmable, lambda {
-      where(created_at: ..::SolidCable.message_retention.ago)
+      where(created_at: ...::SolidCable.message_retention.ago)
     }
     scope :broadcastable, lambda { |channels, last_id|
-      where(channel: channels).where(id: (last_id + 1)..).order(:id)
+      where(channel_hash: channel_hashes_for(channels)).
+        where(id: (last_id + 1)..).order(:id)
     }
+
+    class << self
+      def broadcast(channel, payload)
+        insert({ created_at: Time.current, channel:, payload:,
+          channel_hash: channel_hash_for(channel) })
+      end
+
+      def channel_hashes_for(channels)
+        channels.map { |channel| channel_hash_for(channel) }
+      end
+
+      # Need to unpack this as a signed integer since Postgresql and SQLite
+      # don't support unsigned integers
+      def channel_hash_for(channel)
+        Digest::SHA256.digest(channel.to_s).unpack1("q>")
+      end
+    end
   end
 end

data/app/models/solid_cable/record.rb

@@ -5,5 +5,13 @@ module SolidCable
     self.abstract_class = true
 
     connects_to(**SolidCable.connects_to) if SolidCable.connects_to.present?
+
+    def self.non_blocking_lock
+      if SolidCable.use_skip_locked
+        lock(Arel.sql("FOR UPDATE SKIP LOCKED"))
+      else
+        lock
+      end
+    end
   end
 end

data/lib/action_cable/subscription_adapter/solid_cable.rb

@@ -15,7 +15,9 @@ module ActionCable
       end
 
       def broadcast(channel, payload)
-        ::SolidCable::Message.insert({ channel:, payload: })
+        ::SolidCable::Message.broadcast(channel, payload)
+
+        ::SolidCable::TrimJob.perform_now if ::SolidCable.autotrim?
       end
 
       def subscribe(channel, callback, success_callback = nil)
@@ -29,90 +31,86 @@ module ActionCable
       delegate :shutdown, to: :listener
 
       private
-
-      def listener
-        @listener || @server.mutex.synchronize do
-          @listener ||= Listener.new(@server.event_loop)
+        def listener
+          @listener || @server.mutex.synchronize do
+            @listener ||= Listener.new(@server.event_loop)
+          end
         end
-      end
 
-      class Listener < ::ActionCable::SubscriptionAdapter::SubscriberMap
-        def initialize(event_loop)
-          super()
+        class Listener < ::ActionCable::SubscriptionAdapter::SubscriberMap
+          def initialize(event_loop)
+            super()
 
-          @event_loop = event_loop
+            @event_loop = event_loop
 
-          @thread = Thread.new do
-            Thread.current.abort_on_exception = true
-            listen
+            @thread = Thread.new do
+              Thread.current.abort_on_exception = true
+              listen
+            end
           end
-        end
 
-        def listen
-          while running?
-            with_polling_volume { broadcast_messages }
+          def listen
+            while running?
+              with_polling_volume { broadcast_messages }
 
-            sleep ::SolidCable.polling_interval
+              sleep ::SolidCable.polling_interval
+            end
           end
-        end
 
-        def shutdown
-          self.running = false
-          Thread.pass while thread.alive?
-        end
-
-        def add_channel(channel, on_success)
-          channels.add(channel)
-          event_loop.post(&on_success) if on_success
-        end
-
-        def remove_channel(channel)
-          channels.delete(channel)
+          def shutdown
+            self.running = false
+            Thread.pass while thread.alive?
+          end
 
-          ::SolidCable::TrimJob.perform_now if ::SolidCable.autotrim?
-        end
+          def add_channel(channel, on_success)
+            channels.add(channel)
+            event_loop.post(&on_success) if on_success
+          end
 
-        def invoke_callback(*)
-          event_loop.post { super }
-        end
+          def remove_channel(channel)
+            channels.delete(channel)
+          end
 
-        private
+          def invoke_callback(*)
+            event_loop.post { super }
+          end
 
-        attr_reader :event_loop, :thread
-        attr_writer :running, :last_id
+          private
+            attr_reader :event_loop, :thread
+            attr_writer :running, :last_id
 
-        def running?
-          if defined?(@running)
-            @running
-          else
-            self.running = true
-          end
-        end
+            def running?
+              if defined?(@running)
+                @running
+              else
+                self.running = true
+              end
+            end
 
-        def last_id
-          @last_id ||= ::SolidCable::Message.maximum(:id) || 0
-        end
+            def last_id
+              @last_id ||= ::SolidCable::Message.maximum(:id) || 0
+            end
 
-        def channels
-          @channels ||= Set.new
-        end
+            def channels
+              @channels ||= Set.new
+            end
 
-        def broadcast_messages
-          ::SolidCable::Message.broadcastable(channels, last_id).
-            each do |message|
-              broadcast(message.channel, message.payload)
-              self.last_id = message.id
+            def broadcast_messages
+              ::SolidCable::Message.broadcastable(channels, last_id).
+                each do |message|
+                  broadcast(message.channel, message.payload)
+                  self.last_id = message.id
+                end
             end
-        end
 
-        def with_polling_volume
-          if ::SolidCable.silence_polling?
-            ActiveRecord::Base.logger.silence { yield }
-          else
-            yield
-          end
+            def with_polling_volume
+              if ::SolidCable.silence_polling?
+                ActiveRecord::Base.logger.silence { yield }
+              else
+                yield
+              end
+            end
         end
-      end
     end
   end
 end

data/lib/generators/solid_cable/install/templates/config/cable.yml

@@ -1,3 +1,7 @@
+# Async adapter only works within the same process, so for manually triggering cable updates from a console,
+# and seeing results in the browser, you must do so from the web console (running inside the dev process),
+# not a terminal started via bin/rails console! Add "console" to any action or any ERB template view
+# to make the web console appear.
 development:
   adapter: async
 

data/lib/generators/solid_cable/install/templates/db/cable_schema.rb

@@ -1,13 +1,11 @@
-# frozen_string_literal: true
-
 ActiveRecord::Schema[7.1].define(version: 1) do
   create_table "solid_cable_messages", force: :cascade do |t|
-    t.text "channel"
-    t.text "payload"
+    t.binary "channel", limit: 1024, null: false
+    t.binary "payload", limit: 536870912, null: false
     t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
-    t.index ["channel"], name: "index_solid_cable_messages_on_channel",
-                         length: 500
+    t.integer "channel_hash", limit: 8, null: false
+    t.index ["channel"], name: "index_solid_cable_messages_on_channel"
+    t.index ["channel_hash"], name: "index_solid_cable_messages_on_channel_hash"
     t.index ["created_at"], name: "index_solid_cable_messages_on_created_at"
   end
 end

data/lib/generators/solid_cable/update/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Updates Solid Cable migrations
+
+Example:
+    bin/rails generate solid_cable:update
+
+    This will perform the following:
+        Installs new Solid Cable migrations

data/lib/generators/solid_cable/update/templates/db/migrate/create_compact_channel.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class CreateCompactChannel < ActiveRecord::Migration[7.2]
+  def change
+    change_column :solid_cable_messages, :channel, :binary, limit: 1024, null: false
+    add_column :solid_cable_messages, :channel_hash, :integer, limit: 8, if_not_exists: true
+    add_index :solid_cable_messages, :channel_hash, if_not_exists: true
+    change_column :solid_cable_messages, :payload, :binary, limit: 536_870_912, null: false
+
+    SolidCable::Message.find_each do |msg|
+      msg.update(channel_hash: SolidCable::Message.channel_hash_for(msg.channel))
+    end
+  end
+end

data/lib/generators/solid_cable/update/update_generator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+class SolidCable::UpdateGenerator < Rails::Generators::Base
+  include ActiveRecord::Generators::Migration
+
+  source_root File.expand_path("templates", __dir__)
+
+  def copy_files
+    migration_template "db/migrate/create_compact_channel.rb",
+                       "db/cable_migrate/create_compact_channel.rb"
+  end
+end

data/lib/solid_cable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidCable
-  VERSION = "2.0.2"
+  VERSION = "3.0.1"
 end

data/lib/solid_cable.rb

@@ -11,7 +11,7 @@ module SolidCable
     end
 
     def silence_polling?
-      !!cable_config.silence_polling
+      cable_config.silence_polling != false
     end
 
     def polling_interval
@@ -26,19 +26,40 @@ module SolidCable
       cable_config.autotrim != false
     end
 
-    private
+    def trim_batch_size
+      if (size = cable_config.trim_batch_size.to_i) < 2
+        100
+      else
+        size
+      end
+    end
 
-    def cable_config
-      Rails.application.config_for("cable")
+    def use_skip_locked
+      cable_config.use_skip_locked != false
     end
 
-    def parse_duration(duration, default:)
-      if duration.present?
-        *amount, units = duration.to_s.split(".")
-        amount.join(".").to_f.public_send(units)
-      else
-        default
-      end
+    # For every write that we do, we attempt to delete trim_chance times as
+    # many records. This ensures there is downward pressure on the cache size
+    # while there is valid data to delete. Read this as 'every time the trim job
+    # runs theres a trim_multiplier chance this trims'. Adjust number to make it
+    # more or less likely to trim. Only works like this if trim_batch_size is
+    # 100
+    def trim_chance
+      2
     end
+
+    private
+      def cable_config
+        Rails.application.config_for("cable")
+      end
+
+      def parse_duration(duration, default:)
+        if duration.present?
+          *amount, units = duration.to_s.split(".")
+          amount.join(".").to_f.public_send(units)
+        else
+          default
+        end
+      end
   end
 end

data/lib/tasks/solid_cable_tasks.rake

@@ -3,6 +3,10 @@
 desc "Copy over the schema and set cable adapter for Solid Cable"
 namespace :solid_cable do
   task :install do
-    Rails::Command.invoke :generate, ["solid_cable:install"]
+    Rails::Command.invoke :generate, [ "solid_cable:install" ]
+  end
+
+  task :update do
+    Rails::Command.invoke :generate, [ "solid_cable:update" ]
   end
 end

metadata

@@ -1,17 +1,59 @@
 --- !ruby/object:Gem::Specification
 name: solid_cable
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 3.0.1
 platform: ruby
 authors:
 - Nick Pezza
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-12 00:00:00.000000000 Z
+date: 2024-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+- !ruby/object:Gem::Dependency
+  name: actioncable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+- !ruby/object:Gem::Dependency
+  name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -42,6 +84,9 @@ files:
 - lib/generators/solid_cable/install/install_generator.rb
 - lib/generators/solid_cable/install/templates/config/cable.yml
 - lib/generators/solid_cable/install/templates/db/cable_schema.rb
+- lib/generators/solid_cable/update/USAGE
+- lib/generators/solid_cable/update/templates/db/migrate/create_compact_channel.rb
+- lib/generators/solid_cable/update/update_generator.rb
 - lib/solid_cable.rb
 - lib/solid_cable/engine.rb
 - lib/solid_cable/railtie.rb
@@ -52,7 +97,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: http://github.com/npezza93/solid_cable
-  source_code_uri: http://github.com/npezza93/solid_cable
+  source_code_uri: http://github.com/rails/solid_cable
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []