solid_cache 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ba0486907f0e4656593843d1cca1c7ec35763772ff6d5a2a4e43b9d43b023b3
-  data.tar.gz: a93991c212dcb6d0a1dedb20e2d8d85e0664092c2342db895489beafb9f17e23
+  metadata.gz: 3bb8fa17755c13f25f2a42794d3be5843de423f484d36d7d4a6c38c0241862c7
+  data.tar.gz: d71f6c7aad61cb20f1b1f2a077550e63bdb47d37c33b4a498855d9d35427a153
 SHA512:
-  metadata.gz: 9897aef78db43aff6bceea922aa43669f76a48852d4dc94e64ce8aa198c1ca7fd04152a15033760a6fecad11245b650369342345c6f07e366c3d3d4e0a71f1da
-  data.tar.gz: cd59a068b761fd6060005d9ef78328cd03a3420ee539c07a6afd14eed072a0e9a092d135fbadeb5a58d38aa5a146e8481286b50ef411548a15b701464c0394b0
+  metadata.gz: 716d333398fa3efa935668d918e92742df8f7c8056c7ee222a545167085f2fd3b871fb96d3a8d0f6961ea63f1c0e5ac69146c8469985afa3da9913d4f4b0de0f
+  data.tar.gz: f51f7265604cf7c22ff2cb1ba9d865c0210b3cc54f2e57a0503dca99be015d345feb03d6eecfe1ed8211eba7e049f7aa5c70d647985fa5444d7cc3a393e7c04d

data/README.md

@@ -4,7 +4,7 @@
 
 Solid Cache is a database-backed Active Support cache store implementation.
 
-Using SQL databases backed by SSDs we can have caches that are much larger and cheaper than traditional memory only Redis or Memcached backed caches.
+Using SQL databases backed by SSDs we can have caches that are much larger and cheaper than traditional memory-only Redis or Memcached backed caches.
 
 ## Usage
 
@@ -14,15 +14,15 @@ To set Solid Cache as your Rails cache, you should add this to your environment
 config.cache_store = :solid_cache_store
 ```
 
-Solid Cache is a FIFO (first in, first out) cache. While this is not as efficient as an LRU cache, this is mitigated by the longer cache lifespan.
+Solid Cache is a FIFO (first in, first out) cache. While this is not as efficient as an LRU cache, it is mitigated by the longer cache lifespan.
 
 A FIFO cache is much easier to manage:
-1. We don't need to track when items are read
+1. We don't need to track when items are read.
 2. We can estimate and control the cache size by comparing the maximum and minimum IDs.
 3. By deleting from one end of the table and adding at the other end we can avoid fragmentation (on MySQL at least).
 
 ### Installation
-Add this line to your application's Gemfile:
+Add this line to your application's `Gemfile`:
 
 ```ruby
 gem "solid_cache"
@@ -93,9 +93,9 @@ Setting `databases` to `[cache_db, cache_db2]` is the equivalent of:
 SolidCache::Record.connects_to shards: { cache_db1: { writing: :cache_db1 },  cache_db2: { writing: :cache_db2 } }
 ```
 
-If `connects_to` is set it will be passed directly.
+If `connects_to` is set, it will be passed directly.
 
-If none of these are set, then Solid Cache will use the `ActiveRecord::Base` connection pool. This means that cache reads and writes will be part of any wrapping
+If none of these are set, Solid Cache will use the `ActiveRecord::Base` connection pool. This means that cache reads and writes will be part of any wrapping
 database transaction.
 
 #### Engine configuration
@@ -104,7 +104,7 @@ There are three options that can be set on the engine:
 
 - `executor` - the [Rails executor](https://guides.rubyonrails.org/threading_and_code_execution.html#executor) used to wrap asynchronous operations, defaults to the app executor
 - `connects_to` - a custom connects to value for the abstract `SolidCache::Record` active record model. Required for sharding and/or using a separate cache database to the main app. This will overwrite any value set in `config/solid_cache.yml`
-- `size_estimate_samples` - if `max_size` is set on the cache, the number of the samples used to estimates the size.
+- `size_estimate_samples` - if `max_size` is set on the cache, the number of the samples used to estimates the size
 
 These can be set in your Rails configuration:
 
@@ -116,7 +116,7 @@ end
 
 #### Cache configuration
 
-Solid Cache supports these options in addition to the standard `ActiveSupport::Cache::Store` options.
+Solid Cache supports these options in addition to the standard `ActiveSupport::Cache::Store` options:
 
 - `error_handler` - a Proc to call to handle any `ActiveRecord::ActiveRecordError`s that are raises (default: log errors as warnings)
 - `expiry_batch_size` - the batch size to use when deleting old records (default: `100`)
@@ -125,27 +125,28 @@ Solid Cache supports these options in addition to the standard `ActiveSupport::C
 - `max_age` - the maximum age of entries in the cache (default: `2.weeks.to_i`). Can be set to `nil`, but this is not recommended unless using `max_entries` to limit the size of the cache.
 - `max_entries` - the maximum number of entries allowed in the cache (default: `nil`, meaning no limit)
 - `max_size` - the maximum size of the cache entries (default `nil`, meaning no limit)
-- `cluster` - a Hash of options for the cache database cluster, e.g `{ shards: [:database1, :database2, :database3] }`
-- `clusters` - and Array of Hashes for multiple cache clusters (ignored if `:cluster` is set)
+- `cluster` - (deprecated) a Hash of options for the cache database cluster, e.g `{ shards: [:database1, :database2, :database3] }`
+- `clusters` - (deprecated) an Array of Hashes for multiple cache clusters (ignored if `:cluster` is set)
+- `shards` - an Array of databases
 - `active_record_instrumentation` - whether to instrument the cache's queries (default: `true`)
 - `clear_with` - clear the cache with `:truncate` or `:delete` (default `truncate`, except for when `Rails.env.test?` then `delete`)
 - `max_key_bytesize` - the maximum size of a normalized key in bytes (default `1024`)
 
-For more information on cache clusters see [Sharding the cache](#sharding-the-cache)
+For more information on cache clusters, see [Sharding the cache](#sharding-the-cache)
 
 ### Cache expiry
 
 Solid Cache tracks writes to the cache. For every write it increments a counter by 1. Once the counter reaches 50% of the `expiry_batch_size` it adds a task to run on a background thread. That task will:
 
-1. Check if we have exceeded the `max_entries` or `max_size` values (if set)
+1. Check if we have exceeded the `max_entries` or `max_size` values (if set).
    The current entries are estimated by subtracting the max and min IDs from the `SolidCache::Entry` table.
    The current size is estimated by sampling the entry `byte_size` columns.
-2. If we have it will delete `expiry_batch_size` entries
-3. If not it will delete up to `expiry_batch_size` entries, provided they are all older than `max_age`.
+2. If we have, it will delete `expiry_batch_size` entries.
+3. If not, it will delete up to `expiry_batch_size` entries, provided they are all older than `max_age`.
 
 Expiring when we reach 50% of the batch size allows us to expire records from the cache faster than we write to it when we need to reduce the cache size.
 
-Only triggering expiry when we write means that the if the cache is idle, the background thread is also idle.
+Only triggering expiry when we write means that if the cache is idle, the background thread is also idle.
 
 If you want the cache expiry to be run in a background job instead of a thread, you can set `expiry_method` to `:job`. This will enqueue a `SolidCache::ExpiryJob`.
 
@@ -195,9 +196,9 @@ Solid Cache uses the [Maglev](https://static.googleusercontent.com/media/researc
 
 To shard:
 
-1. Add the configuration for the database shards to database.yml
-2. Configure the shards via `config.solid_cache.connects_to`
-3. Pass the shards for the cache to use via the cluster option
+1. Add the configuration for the database shards to database.yml.
+2. Configure the shards via `config.solid_cache.connects_to`.
+3. Pass the shards for the cache to use via the cluster option.
 
 For example:
 ```yml
@@ -220,43 +221,6 @@ production:
   databases: [cache_shard1, cache_shard2, cache_shard3]
 ```
 
-### Secondary cache clusters
-
-You can add secondary cache clusters. Reads will only be sent to the primary cluster (i.e. the first one listed).
-
-Writes will go to all clusters. The writes to the primary cluster are synchronous, but asynchronous to the secondary clusters.
-
-To specific multiple clusters you can do:
-
-```yaml
-# config/solid_cache.yml
-production:
-  databases: [cache_primary_shard1, cache_primary_shard2, cache_secondary_shard1, cache_secondary_shard2]
-  store_options:
-    clusters:
-      - shards: [cache_primary_shard1, cache_primary_shard2]
-      - shards: [cache_secondary_shard1, cache_secondary_shard2]
-```
-
-### Named shard destinations
-
-By default, the node key used for sharding is the name of the database in `database.yml`.
-
-It is possible to add names for the shards in the cluster config. This will allow you to shuffle or remove shards without breaking consistent hashing.
-
-```yaml
-production:
-  databases: [cache_primary_shard1, cache_primary_shard2, cache_secondary_shard1, cache_secondary_shard2]
-  store_options:
-    clusters:
-      - shards:
-          cache_primary_shard1: node1
-          cache_primary_shard2: node2
-      - shards:
-          cache_secondary_shard1: node3
-          cache_secondary_shard2: node4
-```
-
 ### Enabling encryption
 
 Add this to an initializer:
@@ -270,8 +234,8 @@ end
 ### Index size limits
 The Solid Cache migrations try to create an index with 1024 byte entries. If that is too big for your database, you should:
 
-1. Edit the index size in the migration
-2. Set `max_key_bytesize` on your cache to the new value
+1. Edit the index size in the migration.
+2. Set `max_key_bytesize` on your cache to the new value.
 
 ## Development
 
@@ -298,10 +262,10 @@ $ TARGET_DB=mysql bin/rake test
 $ TARGET_DB=postgres bin/rake test
 ```
 
-### Testing with multiple Rails version
+### Testing with multiple Rails versions
 
 Solid Cache relies on [appraisal](https://github.com/thoughtbot/appraisal/tree/main) to test
-multiple Rails version.
+multiple Rails versions.
 
 To run a test for a specific version run:
 

data/Rakefile

@@ -23,7 +23,7 @@ def run_without_aborting(*tasks)
 end
 
 def configs
-  [ :default, :cluster, :cluster_inferred, :clusters, :clusters_named, :database, :no_database ]
+  [ :default, :connects_to, :database, :no_database, :shards, :unprepared_statements ]
 end
 
 task :test do

data/app/models/solid_cache/entry/size/estimate.rb

@@ -27,7 +27,7 @@ module SolidCache
     # We then calculate the fraction of the rows we want to sample by dividing the sample size by the estimated number
     # of rows.
     #
-    # The we grab the byte_size sum of the rows in the range of key_hash values excluding any rows that are larger than
+    # Then we grab the byte_size sum of the rows in the range of key_hash values excluding any rows that are larger than
     # our minimum outlier cutoff. We then divide this by the sampling fraction to get an estimate of the size of the
     # non outlier rows
     #

data/app/models/solid_cache/entry/size/moving_average_estimate.rb

@@ -3,9 +3,9 @@
 module SolidCache
   class Entry
     module Size
-      # Moving averate cache size estimation
+      # Moving average cache size estimation
       #
-      # To reduce variablitity in the cache size estimate, we'll use a moving average of the previous 20 estimates.
+      # To reduce variability in the cache size estimate, we'll use a moving average of the previous 20 estimates.
       # The estimates are stored directly in the cache, under the "__solid_cache_entry_size_moving_average_estimates" key.
       #
       # We'll remove the largest and smallest estimates, and then average remaining ones.

data/app/models/solid_cache/entry.rb

@@ -5,7 +5,7 @@ module SolidCache
     include Expiration, Size
 
     # The estimated cost of an extra row in bytes, including fixed size columns, overhead, indexes and free space
-    # Based on expirimentation on SQLite, MySQL and Postgresql.
+    # Based on experimentation on SQLite, MySQL and Postgresql.
     # A bit high for SQLite (more like 90 bytes), but about right for MySQL/Postgresql.
     ESTIMATED_ROW_OVERHEAD = 140
     KEY_HASH_ID_RANGE = -(2**63)..(2**63 - 1)
@@ -52,7 +52,7 @@ module SolidCache
           uncached do
             result = lock.where(key_hash: key_hash_for(key)).pick(:key, :value)
             new_value = block.call(result&.first == key ? result[1] : nil)
-            write(key, new_value)
+            write(key, new_value) if new_value
             new_value
           end
         end
@@ -66,7 +66,7 @@ module SolidCache
 
       private
         def upsert_all_no_query_cache(payloads)
-          args = [ self,
+          args = [ self.all,
                    connection_for_insert_all,
                    add_key_hash_and_byte_size(payloads) ].compact
           options = { unique_by: upsert_unique_by,
@@ -112,12 +112,8 @@ module SolidCache
         end
 
         def get_all_sql(key_hashes)
-          if connection.prepared_statements?
-            @get_all_sql_binds ||= {}
-            @get_all_sql_binds[key_hashes.count] ||= build_sql(where(key_hash: key_hashes).select(:key, :value))
-          else
-            @get_all_sql_no_binds ||= build_sql(where(key_hash: [ 1, 2 ]).select(:key, :value)).gsub("?, ?", "?")
-          end
+          @get_all_sql ||= {}
+          @get_all_sql[key_hashes.count] ||= build_sql(where(key_hash: key_hashes).select(:key, :value))
         end
 
         def build_sql(relation)
@@ -134,7 +130,7 @@ module SolidCache
             if connection.prepared_statements?
               result = connection.select_all(sanitize_sql(query), "#{name} Load", Array(values), preparable: true)
             else
-              result = connection.select_all(sanitize_sql([ query, values ]), "#{name} Load", Array(values), preparable: false)
+              result = connection.select_all(sanitize_sql([ query, *values ]), "#{name} Load", Array(values), preparable: false)
             end
 
             result.cast_values(SolidCache::Entry.attribute_types)

data/lib/solid_cache/connections/sharded.rb

@@ -5,10 +5,9 @@ module SolidCache
     class Sharded
       attr_reader :names, :nodes, :consistent_hash
 
-      def initialize(names, nodes)
+      def initialize(names)
         @names = names
-        @nodes = nodes
-        @consistent_hash = MaglevHash.new(@nodes.keys)
+        @consistent_hash = MaglevHash.new(names)
       end
 
       def with_each(&block)
@@ -35,7 +34,7 @@ module SolidCache
 
       private
         def shard_for(key)
-          nodes[consistent_hash.node(key)]
+          consistent_hash.node(key)
         end
     end
   end

data/lib/solid_cache/connections.rb

@@ -7,13 +7,8 @@ module SolidCache
         case options
         when NilClass
           names = SolidCache.configuration.shard_keys
-          nodes = names.to_h { |name| [ name, name ] }
         when Array
           names = options.map(&:to_sym)
-          nodes = names.to_h { |name| [ name, name ] }
-        when Hash
-          names = options.keys.map(&:to_sym)
-          nodes = options.to_h { |names, nodes| [ nodes.to_sym, names.to_sym ] }
         end
 
         if (unknown_shards = names - SolidCache.configuration.shard_keys).any?
@@ -23,7 +18,7 @@ module SolidCache
         if names.size == 1
           Single.new(names.first)
         else
-          Sharded.new(names, nodes)
+          Sharded.new(names)
         end
       else
         Unmanaged.new

data/lib/solid_cache/store/api.rb

@@ -39,16 +39,27 @@ module SolidCache
           entry_read(key)
         end
 
-        def write_entry(key, entry, raw: false, **options)
+        def write_entry(key, entry, raw: false, unless_exist: false, **options)
           payload = serialize_entry(entry, raw: raw, **options)
-          # No-op for us, but this writes it to the local cache
-          write_serialized_entry(key, payload, raw: raw, **options)
 
-          entry_write(key, payload)
+          if unless_exist
+            written = false
+            entry_lock_and_write(key) do |value|
+              if value.nil? || deserialize_entry(value, **options).expired?
+                written = true
+                payload
+              end
+            end
+          else
+            written = entry_write(key, payload)
+          end
+
+          write_serialized_entry(key, payload, raw: raw, returning: written, **options)
+          written
         end
 
-        def write_serialized_entry(key, payload, raw: false, unless_exist: false, expires_in: nil, race_condition_ttl: nil, **options)
-          true
+        def write_serialized_entry(key, payload, raw: false, unless_exist: false, expires_in: nil, race_condition_ttl: nil, returning: true, **options)
+          returning
         end
 
         def read_serialized_entries(keys)

data/lib/solid_cache/store/connections.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module SolidCache
+  class Store
+    module Connections
+      attr_reader :shard_options
+
+      def initialize(options = {})
+        super(options)
+        if options[:clusters].present?
+          if options[:clusters].size > 1
+            raise ArgumentError, "Multiple clusters are no longer supported"
+          else
+            ActiveSupport.deprecator.warn(":clusters is deprecated, use :shards instead.")
+          end
+          @shard_options = options.fetch(:clusters).first[:shards]
+        elsif options[:cluster].present?
+          ActiveSupport.deprecator.warn(":cluster is deprecated, use :shards instead.")
+          @shard_options = options.fetch(:cluster, {})[:shards]
+        else
+          @shard_options = options.fetch(:shards, nil)
+        end
+
+        if [ Array, NilClass ].none? { |klass| @shard_options.is_a? klass }
+          raise ArgumentError, "`shards` is a `#{@shard_options.class.name}`, it should be Array or nil"
+        end
+      end
+
+      def with_each_connection(async: false, &block)
+        return enum_for(:with_each_connection) unless block_given?
+
+        connections.with_each do
+          execute(async, &block)
+        end
+      end
+
+      def with_connection_for(key, async: false, &block)
+        connections.with_connection_for(key) do
+          execute(async, &block)
+        end
+      end
+
+      def with_connection(name, async: false, &block)
+        connections.with(name) do
+          execute(async, &block)
+        end
+      end
+
+      def group_by_connection(keys)
+        connections.assign(keys)
+      end
+
+      def connection_names
+        connections.names
+      end
+
+      def connections
+        @connections ||= SolidCache::Connections.from_config(@shard_options)
+      end
+
+      private
+        def setup!
+          connections
+        end
+
+        def reading_key(key, failsafe:, failsafe_returning: nil, &block)
+          failsafe(failsafe, returning: failsafe_returning) do
+            with_connection_for(key, &block)
+          end
+        end
+
+        def reading_keys(keys, failsafe:, failsafe_returning: nil)
+          group_by_connection(keys).map do |connection, keys|
+            failsafe(failsafe, returning: failsafe_returning) do
+              with_connection(connection) do
+                yield keys
+              end
+            end
+          end
+        end
+
+
+        def writing_key(key, failsafe:, failsafe_returning: nil, &block)
+          failsafe(failsafe, returning: failsafe_returning) do
+            with_connection_for(key, &block)
+          end
+        end
+
+        def writing_keys(entries, failsafe:, failsafe_returning: nil)
+          group_by_connection(entries).map do |connection, entries|
+            failsafe(failsafe, returning: failsafe_returning) do
+              with_connection(connection) do
+                yield entries
+              end
+            end
+          end
+        end
+
+        def writing_all(failsafe:, failsafe_returning: nil, &block)
+          connection_names.map do |connection|
+            failsafe(failsafe, returning: failsafe_returning) do
+              with_connection(connection, &block)
+            end
+          end.first
+        end
+    end
+  end
+end

data/lib/solid_cache/store/entries.rb

@@ -29,7 +29,9 @@ module SolidCache
 
         def entry_lock_and_write(key, &block)
           writing_key(key, failsafe: :increment) do
-            Entry.lock_and_write(key, &block)
+            Entry.lock_and_write(key) do |value|
+              block.call(value).tap { |result| track_writes(1) if result }
+            end
           end
         end
 
@@ -46,17 +48,17 @@ module SolidCache
         end
 
         def entry_write(key, payload)
-          writing_key(key, failsafe: :write_entry, failsafe_returning: nil) do |cluster|
+          writing_key(key, failsafe: :write_entry, failsafe_returning: nil) do
             Entry.write(key, payload)
-            cluster.track_writes(1)
+            track_writes(1)
             true
           end
         end
 
         def entry_write_multi(entries)
-          writing_keys(entries, failsafe: :write_multi_entries, failsafe_returning: false) do |cluster, entries|
+          writing_keys(entries, failsafe: :write_multi_entries, failsafe_returning: false) do |entries|
             Entry.write_multi(entries)
-            cluster.track_writes(entries.count)
+            track_writes(entries.count)
             true
           end
         end

data/lib/solid_cache/{cluster → store}/execution.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module SolidCache
-  class Cluster
+  class Store
     module Execution
       def initialize(options = {})
         super(options)
@@ -16,7 +16,7 @@ module SolidCache
           @background << ->() do
             wrap_in_rails_executor do
               connections.with(current_shard) do
-                instrument(&block)
+                setup_instrumentation(&block)
               end
             end
           rescue Exception => exception
@@ -28,7 +28,7 @@ module SolidCache
           if async
             async(&block)
           else
-            instrument(&block)
+            setup_instrumentation(&block)
           end
         end
 
@@ -44,7 +44,7 @@ module SolidCache
           @active_record_instrumentation
         end
 
-        def instrument(&block)
+        def setup_instrumentation(&block)
           if active_record_instrumentation?
             block.call
           else

data/lib/solid_cache/{cluster → store}/expiry.rb

@@ -3,7 +3,7 @@
 require "concurrent/atomic/atomic_fixnum"
 
 module SolidCache
-  class Cluster
+  class Store
     module Expiry
       # For every write that we do, we attempt to delete EXPIRY_MULTIPLIER times as many records.
       # This ensures there is downward pressure on the cache size while there is valid data to delete

data/lib/solid_cache/{cluster → store}/stats.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 module SolidCache
-  class Cluster
+  class Store
     module Stats
       def initialize(options = {})
-        super()
+        super(options)
       end
 
       def stats

data/lib/solid_cache/store.rb

@@ -2,7 +2,7 @@
 
 module SolidCache
   class Store < ActiveSupport::Cache::Store
-    include Api, Clusters, Entries, Failsafe
+    include Api, Connections, Entries, Execution, Expiry, Failsafe, Stats
     prepend ActiveSupport::Cache::Strategy::LocalCache
 
     def initialize(options = {})
@@ -16,9 +16,5 @@ module SolidCache
     def setup!
       super
     end
-
-    def stats
-      primary_cluster.stats
-    end
   end
 end

data/lib/solid_cache/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidCache
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solid_cache
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Donal McBreen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-20 00:00:00.000000000 Z
+date: 2024-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -120,11 +120,6 @@ files:
 - lib/generators/solid_cache/install/install_generator.rb
 - lib/generators/solid_cache/install/templates/config/solid_cache.yml.tt
 - lib/solid_cache.rb
-- lib/solid_cache/cluster.rb
-- lib/solid_cache/cluster/connections.rb
-- lib/solid_cache/cluster/execution.rb
-- lib/solid_cache/cluster/expiry.rb
-- lib/solid_cache/cluster/stats.rb
 - lib/solid_cache/configuration.rb
 - lib/solid_cache/connections.rb
 - lib/solid_cache/connections/sharded.rb
@@ -134,9 +129,12 @@ files:
 - lib/solid_cache/maglev_hash.rb
 - lib/solid_cache/store.rb
 - lib/solid_cache/store/api.rb
-- lib/solid_cache/store/clusters.rb
+- lib/solid_cache/store/connections.rb
 - lib/solid_cache/store/entries.rb
+- lib/solid_cache/store/execution.rb
+- lib/solid_cache/store/expiry.rb
 - lib/solid_cache/store/failsafe.rb
+- lib/solid_cache/store/stats.rb
 - lib/solid_cache/version.rb
 - lib/tasks/solid_cache_tasks.rake
 homepage: http://github.com/rails/solid_cache
@@ -162,7 +160,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: A database backed ActiveSupport::Cache::Store

data/lib/solid_cache/cluster/connections.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module SolidCache
-  class Cluster
-    module Connections
-      attr_reader :shard_options
-
-      def initialize(options = {})
-        super(options)
-        @shard_options = options.fetch(:shards, nil)
-
-        if [ Hash, Array, NilClass ].none? { |klass| @shard_options.is_a? klass }
-          raise ArgumentError, "`shards` is a `#{@shard_options.class.name}`, it should be one of Array, Hash or nil"
-        end
-      end
-
-      def with_each_connection(async: false, &block)
-        return enum_for(:with_each_connection) unless block_given?
-
-        connections.with_each do
-          execute(async, &block)
-        end
-      end
-
-      def with_connection_for(key, async: false, &block)
-        connections.with_connection_for(key) do
-          execute(async, &block)
-        end
-      end
-
-      def with_connection(name, async: false, &block)
-        connections.with(name) do
-          execute(async, &block)
-        end
-      end
-
-      def group_by_connection(keys)
-        connections.assign(keys)
-      end
-
-      def connection_names
-        connections.names
-      end
-
-      def connections
-        @connections ||= SolidCache::Connections.from_config(@shard_options)
-      end
-
-      private
-        def setup!
-          connections
-        end
-    end
-  end
-end

data/lib/solid_cache/cluster.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module SolidCache
-  class Cluster
-    include Connections, Execution, Expiry, Stats
-
-    attr_reader :error_handler
-
-    def initialize(options = {})
-      @error_handler = options[:error_handler]
-      super(options)
-    end
-
-    def setup!
-      super
-    end
-  end
-end

data/lib/solid_cache/store/clusters.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module SolidCache
-  class Store
-    module Clusters
-      attr_reader :primary_cluster, :clusters
-
-      def initialize(options = {})
-        super(options)
-
-        clusters_options = options.fetch(:clusters) { [ options.fetch(:cluster, {}) ] }
-
-        @clusters = clusters_options.map.with_index do |cluster_options, index|
-          Cluster.new(options.merge(cluster_options).merge(async_writes: index != 0, error_handler: error_handler))
-        end
-
-        @primary_cluster = clusters.first
-      end
-
-      def setup!
-        clusters.each(&:setup!)
-      end
-
-      private
-        def reading_key(key, failsafe:, failsafe_returning: nil, &block)
-          failsafe(failsafe, returning: failsafe_returning) do
-            primary_cluster.with_connection_for(key, &block)
-          end
-        end
-
-        def reading_keys(keys, failsafe:, failsafe_returning: nil)
-          connection_keys = primary_cluster.group_by_connection(keys)
-
-          connection_keys.map do |connection, keys|
-            failsafe(failsafe, returning: failsafe_returning) do
-              primary_cluster.with_connection(connection) do
-                yield keys
-              end
-            end
-          end
-        end
-
-
-        def writing_key(key, failsafe:, failsafe_returning: nil)
-          first_cluster_sync_rest_async do |cluster, async|
-            failsafe(failsafe, returning: failsafe_returning) do
-              cluster.with_connection_for(key, async: async) do
-                yield cluster
-              end
-            end
-          end
-        end
-
-        def writing_keys(entries, failsafe:, failsafe_returning: nil)
-          first_cluster_sync_rest_async do |cluster, async|
-            connection_entries = cluster.group_by_connection(entries)
-
-            connection_entries.map do |connection, entries|
-              failsafe(failsafe, returning: failsafe_returning) do
-                cluster.with_connection(connection, async: async) do
-                  yield cluster, entries
-                end
-              end
-            end
-          end
-        end
-
-        def writing_all(failsafe:, failsafe_returning: nil, &block)
-          first_cluster_sync_rest_async do |cluster, async|
-            cluster.connection_names.map do |connection|
-              failsafe(failsafe, returning: failsafe_returning) do
-                cluster.with_connection(connection, async: async, &block)
-              end
-            end
-          end.first
-        end
-
-        def first_cluster_sync_rest_async
-          clusters.map.with_index { |cluster, index| yield cluster, index != 0 }.first
-        end
-    end
-  end
-end