cache_failover 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed9e82f26ea1cb43e4b188cee7620bb345adba1f320144e3eee891c8b6eba03c
-  data.tar.gz: 702f7c9c24287051704a9bc56c5a758db81d764cf5a3b26204ae3dc7b3ae529b
+  metadata.gz: 61679cceaaaf7075f3481d5b2ff7cdb9fd978414ffb859622c8a381897654f41
+  data.tar.gz: bfe5ec32fe1d16861b448fd48f51517fb1a131bead3ef6fb7c046ffc526753eb
 SHA512:
-  metadata.gz: 84a2ebf66e5e039fb714bff24879fc52aa63d76aa80434dd69f85fdcb24fbfa4763e32996288f8cc55b95dde9ef1f09693f68acacd2c1f98fe0c3137bb4b6c8d
-  data.tar.gz: bb2fadf0c46ecd0a4bcd28b7ffbc7535badc43aac63f23937007136a069256d508745d177113c82102a8da50f2d168cb4de1720b7595b356baa514a9c8de5ee1
+  metadata.gz: e41b6fb49aa9877f0379e719e2ec199f9b89ff0368c2ef85865716365f71e6c7a93e963e981e2addde5596068c2e40c39f142469905d5a84de1574a9cb6cca75
+  data.tar.gz: 1718e7588f2cce108b46a23dc02e5354b11ad50721b2ff05a7f422661311b433925c9442877fc61e99690056051b2844b3e1f01d5cd2b31d6c17a4fc478ecd9f

data/README.md

@@ -2,6 +2,12 @@
 
 ## Installation
 
+This Gem allows you to configure multiple cache stores in a failover configuration. If the first cache store fails, this gem will attempt to use the next cache store in the list. If the first cache store comes back online, it will revert to using that store.
+
+This is useful for high availability and redundancy, such as using a Redis Cache with SolidCache (DB) as a backup in case Redis goes down.
+
+Keep in mind, if you use your cache as a session store, users will be logged out.
+
 `Gemfile`
 
 ```ruby
@@ -49,5 +55,7 @@ config.cache_store = CacheFailover::Store.new(
 ## WIP
 - Memory Cache Support
 - File Cache support
+- Sync cache stores
+- Add option to not use cache stores after failure unless the application is rebooted.
 - More options
 - Tests

data/lib/cache_failover/store.rb

@@ -19,17 +19,37 @@ module CacheFailover
       cache_db: 'cache'
     }
 
-    attr_reader :core_store
-
     def initialize(cache_stores)
-      _core_store = cache_stores.find do |cs|
-        options(cs[:options])
-        Logger.new("log/#{CONFIG[:RAILS_ENV]}.log").info("CacheFailover: caching_up?: #{cs[:store].class.name}")
-        Logger.new("log/#{CONFIG[:RAILS_ENV]}.log").info("CacheFailover: caching_up?: #{options}")
-        Logger.new("log/#{CONFIG[:RAILS_ENV]}.log").info("#{caching_up?(cs[:store], options)}")
-        caching_up?(cs[:store], options)
+      core_stores(cache_stores)
+      core_store
+    end
+
+    def core_store
+      if defined?(Thread.current[:cache_core_store]) && Thread.current[:cache_core_store].present? && caching_up?(Thread.current[:cache_core_store], options)
+        return Thread.current[:cache_core_store]
+      else
+        Thread.current[:cache_core_store] = nil
+        core_stores.each do |cs|
+          next if defined?(Thread.current[:cache_core_store]) && Thread.current[:cache_core_store].present?
+          Thread.current[:cache_core_store] = cs[:store]
+          options(cs[:options])
+          cache_failover_logger.info("CacheFailover: caching_up?: #{cs[:store].class.name}")
+          cache_failover_logger.info("CacheFailover: caching_up?: #{options}")
+          _store_up = caching_up?(cs[:store], options)
+          cache_failover_logger.info("#{_store_up}")
+          if _store_up == true
+            break
+          else
+            Thread.current[:cache_core_store] = nil
+            next
+          end
+        end
       end
-      @core_store = _core_store[:store]
+    end
+
+    def core_stores(core_stores = [])
+      return @core_stores if defined?(@core_stores) && core_stores.blank?
+      @core_stores = core_stores
     end
 
     def options(init_options = {})
@@ -38,6 +58,8 @@ module CacheFailover
     end
 
     def fetch(name, init_options = nil, &block)
+      retries = 0
+      begin
       options(init_options)
 
       if !block_given? && options[:force]
@@ -45,7 +67,7 @@ module CacheFailover
       end
 
       get_value(
-        @core_store.fetch(expanded_cache_key(name), options.merge(compress: false)) do
+        core_store.fetch(expanded_cache_key(name), options.merge(compress: false)) do
           if block_given?
             store_value(block.call, options)
           else
@@ -54,100 +76,179 @@ module CacheFailover
         end,
         options
       )
+      rescue => ex
+        Thread.current[:cache_core_store] = nil
+        core_store
+        retry if (retries += 1) < core_stores.length
+      end
     end
 
     def write(name, value, init_options = nil)
-      options(init_options)
+      retries = 0
+      begin
+        options(init_options)
 
-      payload = store_value(value, options)
+        payload = store_value(value, options)
 
-      @core_store.write(
-        expanded_cache_key(name),
-        payload,
-        options.merge(compress: false)
-      )
+        core_store.write(
+          expanded_cache_key(name),
+          payload,
+          options.merge(compress: false)
+        )
+      rescue => ex
+        Thread.current[:cache_core_store] = nil
+        core_store
+        retry if (retries += 1) < core_stores.length
+      end
     end
 
     def read(name, init_options = nil)
-      options(init_options)
+      retries = 0
+      begin
+        options(init_options)
 
-      payload = @core_store.read(
-        expanded_cache_key(name),
-        options
-      )
+        payload = core_store.read(
+          expanded_cache_key(name),
+          options
+        )
 
-      get_value(payload, options)
+        get_value(payload, options)
+      rescue => ex
+        Thread.current[:cache_core_store] = nil
+        core_store
+        retry if (retries += 1) < core_stores.length
+      end
     end
 
     def write_multi(hash, init_options = nil)
-      options(init_options)
+      retries = 0
+      begin
+        options(init_options)
 
-      new_hash = hash.map do |key, val|
-        [
-          expanded_cache_key(key),
-          store_value(val, options),
-        ]
-      end
+        new_hash = hash.map do |key, val|
+          [
+            expanded_cache_key(key),
+            store_value(val, options),
+          ]
+        end
 
-      @core_store.write_multi(
-        new_hash,
-        options.merge(compress: false)
-      )
+        core_store.write_multi(
+          new_hash,
+          options.merge(compress: false)
+        )
+      rescue => ex
+        Thread.current[:cache_core_store] = nil
+        core_store
+        retry if (retries += 1) < core_stores.length
+      end
     end
 
     def read_multi(*names)
-      options = names.extract_options!
-      names = names.map { |name| expanded_cache_key(name) }
-      options(options)
+      retries = 0
+      begin
+        options = names.extract_options!
+        names = names.map { |name| expanded_cache_key(name) }
+        options(options)
 
-      core_store.read_multi(*names, options).map do |key, val|
-        [key, get_value(val, options)]
-      end.to_h
+        core_store.read_multi(*names, options).map do |key, val|
+          [key, get_value(val, options)]
+        end.to_h
+      rescue => ex
+        Thread.current[:cache_core_store] = nil
+        core_store
+        retry if (retries += 1) < core_stores.length
+      end
     end
 
     def fetch_multi(*names)
-      options = names.extract_options!
-      expanded_names = names.map { |name| expanded_cache_key(name) }
-      options(options)
-
-      reads = core_store.send(:read_multi_entries, expanded_names, **options)
-      reads.map do |key, val|
-        [key, store_value(val, options)]
-      end.to_h
-
-      writes = {}
-      ordered = names.index_with do |name|
-        reads.fetch(name) { writes[name] = yield(name) }
-      end
+      retries = 0
+      begin
+        options = names.extract_options!
+        expanded_names = names.map { |name| expanded_cache_key(name) }
+        options(options)
+
+        reads = core_store.send(:read_multi_entries, expanded_names, **options)
+        reads.map do |key, val|
+          [key, store_value(val, options)]
+        end.to_h
+
+        writes = {}
+        ordered = names.index_with do |name|
+          reads.fetch(name) { writes[name] = yield(name) }
+        end
 
-      write_multi(writes)
-      ordered
+        write_multi(writes)
+        ordered
+      rescue => ex
+        Thread.current[:cache_core_store] = nil
+        core_store
+        retry if (retries += 1) < core_stores.length
+      end
     end
 
     def exist?(name, init_options = {})
-      @core_store.exist?(expanded_cache_key(name), init_options)
+      retries = 0
+      begin
+        core_store.exist?(expanded_cache_key(name), init_options)
+      rescue => ex
+        Thread.current[:cache_core_store] = nil
+        core_store
+        retry if (retries += 1) < core_stores.length
+      end
     end
 
     def delete(name, init_options = {})
-      @core_store.delete(expanded_cache_key(name), init_options)
+      retries = 0
+      begin
+        core_store.delete(expanded_cache_key(name), init_options)
+      rescue => ex
+        Thread.current[:cache_core_store] = nil
+        core_store
+        retry if (retries += 1) < core_stores.length
+      end
     end
 
     def clear(init_options = {})
-      @core_store.clear(**init_options)
+      retries = 0
+      begin
+        core_store.clear(**init_options)
+      rescue => ex
+        Thread.current[:cache_core_store] = nil
+        core_store
+        retry if (retries += 1) < core_stores.length
+      end
     end
 
     def increment(name, amount = 1, **init_options)
-      @core_store.increment(expanded_cache_key(name), amount, **init_options)
+      retries = 0
+      begin
+        core_store.increment(expanded_cache_key(name), amount, **init_options)
+      rescue => ex
+        Thread.current[:cache_core_store] = nil
+        core_store
+        retry if (retries += 1) < core_stores.length
+      end
     end
 
     def decrement(name, amount = 1, **init_options)
-      @core_store.decrement(expanded_cache_key(name), amount, **init_options)
+      retries = 0
+      begin
+        core_store.decrement(expanded_cache_key(name), amount, **init_options)
+      rescue => ex
+        Thread.current[:cache_core_store] = nil
+        core_store
+        retry if (retries += 1) < core_stores.length
+      end
     end
 
     def self.supports_cache_versioning?
       true
     end
 
+    def cache_failover_logger
+      @cache_failover_logger ||= Logger.new("log/#{CONFIG[:RAILS_ENV]}.log")
+    end
+
     private
 
     def redis_cnxn(init_options)
@@ -183,7 +284,7 @@ module CacheFailover
         Timeout.timeout((init_options[:timeout] || 1)) do
           case store.class.name
           when 'ActiveSupport::Cache::RedisCacheStore'
-            (redis_cnxn(init_options).call('ping') == 'PONG' rescue false)
+            redis_cnxn(init_options).call('ping') == 'PONG'
           when 'ActiveSupport::Cache::MemCacheStore'
             dalli_cnxn(init_options).alive!
             dalli_cnxn(init_options).delete('cache_test')
@@ -197,6 +298,7 @@ module CacheFailover
           end
         end
       rescue => ex
+        Thread.current[:cache_core_store] = nil
         false
       end
     end
@@ -266,5 +368,7 @@ module CacheFailover
     end
 
   end
+
+
 end
 

data/lib/cache_failover/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CacheFailover
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cache_failover
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - chronicaust
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-10-27 00:00:00.000000000 Z
+date: 2024-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport